import AppKit
import ConjureKit
import Testing
@testable import Conjure

@Test @MainActor
func notesSwitchWithoutLeakingEditsUndoOrAttachmentsAndRestoreSelection() throws {
    _ = NSApplication.shared
    let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
    let suite = "NotesEditing.\(UUID().uuidString)"
    let defaults = try #require(UserDefaults(suiteName: suite))
    defer {
        try? FileManager.default.removeItem(at: directory)
        defaults.removePersistentDomain(forName: suite)
    }
    let controller = NotesController(defaults: defaults, directory: directory)
    let window = NSWindow(contentRect: NSRect(x: 0, y: 0, width: 750, height: 390), styleMask: [.borderless], backing: .buffered, defer: false)
    window.contentViewController = controller
    defer { _ = controller.close(); window.orderOut(nil) }
    func descendants(_ view: NSView) -> [NSView] { [view] + view.subviews.flatMap(descendants) }
    let views = descendants(controller.view)
    let editor = try #require(views.compactMap { $0 as? NSTextView }.first)
    let browse = try #require(views.compactMap { $0 as? NSButton }.first { $0.title == "Browse Notes" })
    #expect(browse.keyEquivalent == "p")
    #expect(!views.compactMap { $0 as? NSButton }.contains { $0.title == "New Note" })
    func selectedID() throws -> UUID { try #require(defaults.string(forKey: "selectedNote").flatMap(UUID.init(uuidString:))) }
    func picker(_ tool: NotesController) throws -> NSSearchField {
        try #require(descendants(tool.view).compactMap { $0 as? NSSearchField }.first { $0.accessibilityLabel() == "Search notes" })
    }
    func filter(_ field: NSSearchField, _ query: String) {
        field.stringValue = query
        field.delegate?.controlTextDidChange?(Notification(name: NSControl.textDidChangeNotification, object: field))
        field.window?.contentView?.layoutSubtreeIfNeeded()
    }
    let firstID = try selectedID()
    // Empty notes have duplicate titles; UUID identity must survive the shared picker.
    window.makeFirstResponder(editor)
    let newNoteKey = try #require(NSEvent.keyEvent(with: .keyDown, location: .zero,
        modifierFlags: .command, timestamp: 1, windowNumber: window.windowNumber, context: nil,
        characters: "n", charactersIgnoringModifiers: "n", isARepeat: false, keyCode: 45))
    #expect(window.performKeyEquivalent(with: newNoteKey))
    let secondID = try selectedID()
    #expect(secondID != firstID)
    for expectedID in [firstID, secondID] {
        browse.performClick(nil)
        _ = try picker(controller)
        let table = try #require(descendants(controller.view).compactMap { $0 as? NSTableView }.first)
        #expect(table.numberOfRows == 2)
        #expect(controller.handleControlKey(table.selectedRow == 0 ? "j" : "k"))
        #expect(controller.handle(#selector(NSResponder.insertNewline(_:))))
        #expect(try selectedID() == expectedID)
        #expect(window.firstResponder === editor)
    }
    #expect(!controller.handleControlKey("j"))
    #expect(!controller.handle(#selector(NSResponder.insertNewline(_:))))
    editor.insertText("# Second 🦊\n**bold** and `code`", replacementRange: editor.selectedRange())
    #expect((editor.textStorage?.attribute(.font, at: 0, effectiveRange: nil) as? NSFont)?.pointSize == 17)
    let codeRange = (editor.string as NSString).range(of: "`code`")
    let codeFont = try #require(editor.textStorage?.attribute(.font, at: codeRange.location, effectiveRange: nil) as? NSFont)
    #expect(codeFont.isFixedPitch)
    browse.performClick(nil)
    filter(try picker(controller), "nttld")
    #expect(controller.handle(#selector(NSResponder.insertNewline(_:))))
    #expect(try selectedID() == firstID)
    #expect(editor.string.isEmpty)
    #expect(editor.undoManager?.canUndo != true)
    editor.insertText("First note", replacementRange: editor.selectedRange())
    let bitmap = try #require(NSBitmapImageRep(bitmapDataPlanes: nil, pixelsWide: 1, pixelsHigh: 1, bitsPerSample: 8, samplesPerPixel: 4, hasAlpha: true, isPlanar: false, colorSpaceName: .deviceRGB, bytesPerRow: 0, bitsPerPixel: 0))
    bitmap.setColor(.red, atX: 0, y: 0)
    let imageURL = directory.appendingPathComponent("image.png")
    let png = try #require(bitmap.representation(using: .png, properties: [:]))
    try png.write(to: imageURL)
    let pasteboard = NSPasteboard.withUniqueName()
    defer { pasteboard.releaseGlobally() }
    pasteboard.setData(png, forType: .png)
    #expect(editor.readSelection(from: pasteboard))
    pasteboard.clearContents()
    pasteboard.writeObjects([imageURL as NSURL])
    #expect(editor.readSelection(from: pasteboard))
    #expect(controller.save())
    let returnKey = try #require(NSEvent.keyEvent(with: .keyDown, location: .zero,
        modifierFlags: [], timestamp: 2, windowNumber: window.windowNumber, context: nil,
        characters: "\r", charactersIgnoringModifiers: "\r", isARepeat: false, keyCode: 36))
    editor.keyDown(with: returnKey)
    #expect(editor.string == "First note\u{fffc}\u{fffc}\n")
    #expect(try selectedID() == firstID)
    let restored = try NotesStore(directory: directory)
    let first = try #require(restored.notes.first { $0.id == firstID })
    #expect(first.contents.string == "First note\u{fffc}\u{fffc}\n")
    #expect(first.contents.attribute(.attachment, at: 10, effectiveRange: nil) is NSTextAttachment)
    #expect(first.contents.attribute(.attachment, at: 11, effectiveRange: nil) is NSTextAttachment)
    #expect(restored.notes.first { $0.id == secondID }?.contents.string == "# Second 🦊\n**bold** and `code`")
    let reopened = NotesController(defaults: defaults, directory: directory)
    let reopenedWindow = NSWindow(contentRect: window.frame, styleMask: [.borderless], backing: .buffered, defer: false)
    reopenedWindow.contentViewController = reopened
    defer { _ = reopened.close(); reopenedWindow.orderOut(nil) }
    let reopenedViews = descendants(reopened.view)
    let reopenedEditor = try #require(reopenedViews.compactMap { $0 as? NotesTextView }.first)
    #expect(reopenedEditor.string == first.contents.string)
    // Removing Markdown must also remove its previous visual style without changing the source.
    reopenedEditor.insertText("Plain text", replacementRange: NSRange(location: 0, length: reopenedEditor.string.utf16.count))
    #expect((reopenedEditor.textStorage?.attribute(.font, at: 0, effectiveRange: nil) as? NSFont)?.pointSize == 14)
    #expect(reopenedEditor.string == "Plain text")
    let backup = directory.appendingPathExtension("backup")
    defer { try? FileManager.default.removeItem(at: backup) }
    try FileManager.default.moveItem(at: directory, to: backup)
    try Data("Blocked storage".utf8).write(to: directory)
    reopenedEditor.insertText("- [X] Unsaved", replacementRange: NSRange(location: 0, length: reopenedEditor.string.utf16.count))
    var closed = false
    reopened.closed = { closed = true }
    reopened.goBack()
    #expect(!closed)
    #expect(!reopened.save())
    reopened.browseNotes()
    filter(try picker(reopened), "scnd")
    #expect(reopened.handle(#selector(NSResponder.insertNewline(_:))))
    #expect(reopenedEditor.string == "\u{fffc} Unsaved")
    #expect(reopenedEditor.markdownString == "- [X] Unsaved")
    #expect(try selectedID() == firstID)
    reopened.browseNotes()
    #expect(!reopened.close())
    #expect(!closed)
    #expect(try picker(reopened).window === reopenedWindow)
    try FileManager.default.removeItem(at: directory)
    try FileManager.default.moveItem(at: backup, to: directory)
    #expect(reopened.save())
    #expect(try NotesStore(directory: directory).notes.first { $0.id == firstID }?.contents.string == "- [X] Unsaved")
    #expect(reopened.close())
    #expect(closed)
    #expect(!descendants(reopened.view).contains { ($0 as? NSSearchField)?.accessibilityLabel() == "Search notes" })
}

@Test @MainActor
func notesLauncherRoutesShortcutsAndTearsDownPickersWithoutTakingEditorNavigation() throws {
    _ = NSApplication.shared
    let suite = "NotesShortcuts.\(UUID().uuidString)"
    let defaults = try #require(UserDefaults(suiteName: suite))
    let directory = FileManager.default.temporaryDirectory.appendingPathComponent(suite)
    defer {
        defaults.removePersistentDomain(forName: suite)
        try? FileManager.default.removeItem(at: directory)
    }
    let store = try NotesStore(directory: directory)
    let atlas = try store.create()
    let journal = try store.create()
    try store.update(id: atlas, contents: NSAttributedString(string: "Project Atlas"))
    try store.update(id: journal, contents: NSAttributedString(string: "Weekend journal"))
    defaults.set(atlas.uuidString, forKey: "selectedNote")
    let launcher = LauncherWindowController(
        history: LaunchHistory(defaults: defaults, now: { Date(timeIntervalSinceReferenceDate: 12_000) }),
        defaults: defaults, notesDirectory: directory)
    let window = try #require(launcher.window)
    defer { launcher.dismiss(restoringFocus: false) }
    let content = try #require(window.contentView)
    func descendants(_ view: NSView) -> [NSView] { [view] + view.subviews.flatMap(descendants) }
    func search(_ label: String) throws -> NSSearchField {
        try #require(descendants(content).compactMap { $0 as? NSSearchField }.first { $0.accessibilityLabel() == label })
    }
    func key(_ text: String, code: UInt16, flags: NSEvent.ModifierFlags = []) throws -> NSEvent {
        let characters = flags == .control && text == "k" ? "\u{b}" : text
        return try #require(NSEvent.keyEvent(with: .keyDown, location: .zero, modifierFlags: flags,
            timestamp: 1, windowNumber: window.windowNumber, context: nil, characters: characters,
            charactersIgnoringModifiers: text, isARepeat: false, keyCode: code))
    }
    func command(_ text: String, code: UInt16) throws {
        #expect(window.performKeyEquivalent(with: try key(text, code: code, flags: .command)))
    }
    func filter(_ field: NSSearchField, _ text: String) {
        field.stringValue = text
        field.delegate?.controlTextDidChange?(Notification(name: NSControl.textDidChangeNotification, object: field))
        content.layoutSubtreeIfNeeded()
    }
    let launcherSearch = try #require(descendants(content).compactMap { $0 as? NSSearchField }.first)
    launcherSearch.stringValue = "notes"
    launcher.controlTextDidChange(Notification(name: NSControl.textDidChangeNotification, object: launcherSearch))
    #expect(launcher.control(launcherSearch, textView: NSTextView(), doCommandBy: #selector(NSResponder.insertNewline(_:))))
    window.makeKeyAndOrderFront(nil)
    let browse = try #require(descendants(content).compactMap { $0 as? NSButton }.first { $0.title == "Browse Notes" })
    let tool = try #require(browse.target as? NotesController)
    let editor = try #require(descendants(content).compactMap { $0 as? NSTextView }.first { $0.accessibilityLabel() == "Note editor" })
    window.makeFirstResponder(editor)
    try command("p", code: 35)
    let picker = try search("Search notes")
    let table = try #require(descendants(content).compactMap { $0 as? NSTableView }.first { $0.accessibilityLabel() == "Notes" })
    #expect(window.firstResponder === picker.currentEditor())
    #expect(browse.superview?.isAccessibilityHidden() == true)
    #expect(tool.handle(#selector(NSResponder.moveUp(_:))))
    window.sendEvent(try key("j", code: 38, flags: .control))
    #expect(table.selectedRow == 1)
    window.sendEvent(try key("k", code: 40, flags: .control))
    #expect(table.selectedRow == 0)
    filter(picker, "wkndjrnl")
    #expect(table.numberOfRows == 1)
    #expect(tool.handle(#selector(NSResponder.insertNewline(_:))))
    #expect(defaults.string(forKey: "selectedNote") == journal.uuidString)
    #expect(editor.string == "Weekend journal")
    #expect(window.firstResponder === editor)
    try command("p", code: 35)
    _ = try search("Search notes")
    try command("p", code: 35)
    #expect(window.firstResponder === editor)
    try command("k", code: 40)
    filter(try search("Search notes actions"), "Browse Notes")
    #expect(tool.handle(#selector(NSResponder.insertNewline(_:))))
    _ = try search("Search notes")
    window.sendEvent(try key("\u{1b}", code: 53))
    #expect(window.isVisible && window.firstResponder === editor)
    try command("k", code: 40)
    filter(try search("Search notes actions"), "New Note")
    #expect(tool.handle(#selector(NSResponder.insertNewline(_:))))
    #expect(editor.string.isEmpty)
    let actionCreatedID = defaults.string(forKey: "selectedNote")
    try command("n", code: 45)
    #expect(defaults.string(forKey: "selectedNote") != actionCreatedID)
    let editorCreatedID = defaults.string(forKey: "selectedNote")
    try command("p", code: 35)
    _ = try search("Search notes")
    try command("n", code: 45)
    #expect(defaults.string(forKey: "selectedNote") != editorCreatedID)
    #expect(window.firstResponder === editor)
    #expect(!tool.handle(#selector(NSResponder.moveDown(_:))))
    #expect(!tool.handleControlKey("k"))
    editor.insertText("Navigation", replacementRange: editor.selectedRange())
    editor.setSelectedRange(NSRange(location: 0, length: 0))
    window.sendEvent(try key("k", code: 40, flags: .control))
    #expect(editor.string.isEmpty)
    editor.insertText("Editable", replacementRange: editor.selectedRange())
    editor.keyDown(with: try key("\r", code: 36))
    #expect(editor.string == "Editable\n")
    try command("p", code: 35)
    #expect(tool.close())
    #expect(!descendants(content).compactMap { $0 as? NSSearchField }.contains { $0.accessibilityLabel() == "Search notes" })
    #expect(launcherSearch.isHidden == false)
}

@Test @MainActor
func markdownListReturnContinuesExitsAndUndoesAtArbitraryDepths() throws {
    _ = NSApplication.shared
    let suite = "NotesLists.\(UUID().uuidString)"
    let defaults = try #require(UserDefaults(suiteName: suite))
    let directory = FileManager.default.temporaryDirectory.appendingPathComponent(suite)
    defer {
        defaults.removePersistentDomain(forName: suite)
        try? FileManager.default.removeItem(at: directory)
    }
    let controller = NotesController(defaults: defaults, directory: directory)
    let window = NSWindow(contentRect: NSRect(x: 0, y: 0, width: 750, height: 390),
                          styleMask: .borderless, backing: .buffered, defer: false)
    window.contentViewController = controller
    defer { _ = controller.close(); window.orderOut(nil) }
    func descendants(_ view: NSView) -> [NSView] { [view] + view.subviews.flatMap(descendants) }
    let editor = try #require(descendants(controller.view).compactMap { $0 as? NotesTextView }.first)
    window.makeFirstResponder(editor)
    let enter = try #require(NSEvent.keyEvent(with: .keyDown, location: .zero, modifierFlags: [],
        timestamp: 1, windowNumber: window.windowNumber, context: nil, characters: "\r",
        charactersIgnoringModifiers: "\r", isARepeat: false, keyCode: 36))
    func reset(_ text: String) {
        editor.insertText(text, replacementRange: NSRange(location: 0, length: editor.string.utf16.count))
        editor.breakUndoCoalescing()
        editor.undoManager?.removeAllActions()
    }
    let examples = [
        ("- fox 🦊", "- fox 🦊\n- "),
        ("  * nested", "  * nested\n  * "),
        ("\t+ nested", "\t+ nested\n\t+ "),
        ("9. ninth", "9. ninth\n10. "),
        ("  12) nested", "  12) nested\n  13) "),
        ("- [x] finished", "- [x] finished\n- [ ] "),
        (" \t+  [X]\tfinished", " \t+  [X]\tfinished\n \t+  [ ]\t"),
        ("1. parent\n   - [X] ", "1. parent\n2. "),
        ("- [x] parent\n  - [ ] ", "- [x] parent\n- [ ] "),
        ("- ", ""), ("+ \t ", ""), ("4. ", ""), ("- [ ] ", ""), ("- [X]", ""),
        ("- parent\n  - ", "- parent\n- "),
        ("1. parent\n   * ", "1. parent\n2. "),
        ("- parent\n\t+ child\n\t\t3) ", "- parent\n\t+ child\n\t+ "),
        ("- first\n  - child\n  - ", "- first\n  - child\n- "),
        ("- parent\n  continuation\n  - ", "- parent\n  continuation\n- "),
        ("- parent\nparagraph\n  - ", "- parent\nparagraph\n"),
        ("- parent\n   + ", "- parent\n- "),
        ("- parent\r\n  - ", "- parent\r\n- "),
        ("prose", "prose\n"), ("* * *", "* * *\n"),
        ("```md\n- literal", "```md\n- literal\n"),
        ("~~~\n  1. literal", "~~~\n  1. literal\n"),
        ("```\n- literal\n```\n- real", "```\n- literal\n```\n- real\n- "),
    ]
    for (before, after) in examples {
        reset(before)
        editor.keyDown(with: enter)
        #expect(editor.markdownString == after, "Return in \(before.debugDescription)")
        #expect(editor.markdownContents.string == after)
        #expect(editor.selectedRange() == NSRange(location: editor.string.utf16.count, length: 0))
    }
    reset("- ab🦊cd")
    editor.setSelectedRange((editor.string as NSString).range(of: "🦊"))
    editor.keyDown(with: enter)
    #expect(editor.string == "- ab\n- cd")
    #expect(editor.selectedRange() == NSRange(location: 7, length: 0))
    reset("- [X] ab🦊cd")
    editor.setSelectedRange((editor.string as NSString).range(of: "🦊"))
    editor.keyDown(with: enter)
    #expect(editor.markdownString == "- [X] ab\n- [ ] cd")
    #expect(editor.string == "\u{fffc} ab\n\u{fffc} cd")
    #expect(editor.selectedRange() == NSRange(location: 7, length: 0))
    reset("- parent\n  - child\n    - leaf")
    editor.keyDown(with: enter)
    #expect(editor.string == "- parent\n  - child\n    - leaf\n    - ")
    editor.keyDown(with: enter)
    #expect(editor.string == "- parent\n  - child\n    - leaf\n  - ")
    editor.keyDown(with: enter)
    #expect(editor.string == "- parent\n  - child\n    - leaf\n- ")
    editor.keyDown(with: enter)
    #expect(editor.string == "- parent\n  - child\n    - leaf\n")
    // Nesting follows actual ancestor indentation, not a fixed depth or indent size.
    let ancestors = (0..<80).map { String(repeating: " ", count: $0 * 2) + "- level \($0)" }.joined(separator: "\n")
    let before = ancestors + "\n" + String(repeating: " ", count: 160) + "- leaf"
    reset(before)
    editor.keyDown(with: enter)
    #expect(editor.string == before + "\n" + String(repeating: " ", count: 160) + "- ")
    for depth in stride(from: 79, through: 0, by: -1) {
        editor.keyDown(with: enter)
        #expect(editor.string == before + "\n" + String(repeating: " ", count: depth * 2) + "- ")
    }
    editor.keyDown(with: enter)
    #expect(editor.string == before + "\n")
    reset("- [X] parent\n  - [ ] ")
    editor.keyDown(with: enter)
    editor.breakUndoCoalescing()
    #expect(editor.markdownString == "- [X] parent\n- [ ] ")
    #expect(editor.string == "\u{fffc} parent\n\u{fffc} ")
    editor.undoManager?.undo()
    #expect(editor.markdownString == "- [X] parent\n  - [ ] ")
    #expect(editor.string == "\u{fffc} parent\n  \u{fffc} ")
    #expect(editor.undoManager?.canUndo == false)
    editor.undoManager?.redo()
    #expect(editor.markdownString == "- [X] parent\n- [ ] ")
    reset("7. saved")
    editor.keyDown(with: enter)
    editor.breakUndoCoalescing()
    #expect(editor.string == "7. saved\n8. ")
    editor.undoManager?.undo()
    #expect(editor.string == "7. saved")
    editor.undoManager?.redo()
    #expect(editor.string == "7. saved\n8. ")
    let restored = try NotesStore(directory: directory)
    let id = try #require(defaults.string(forKey: "selectedNote").flatMap(UUID.init(uuidString:)))
    #expect(restored.notes.first { $0.id == id }?.contents.string == "7. saved\n8. ")
}

@Test @MainActor
func taskCheckboxesToggleMarkdownWithUndoPersistenceAndListContinuation() throws {
    _ = NSApplication.shared
    let suite = "NotesTasks.\(UUID().uuidString)"
    let defaults = try #require(UserDefaults(suiteName: suite))
    let directory = FileManager.default.temporaryDirectory.appendingPathComponent(suite)
    defer {
        defaults.removePersistentDomain(forName: suite)
        try? FileManager.default.removeItem(at: directory)
    }
    let controller = NotesController(defaults: defaults, directory: directory)
    let window = NSWindow(contentRect: NSRect(x: 0, y: 0, width: 750, height: 390),
                          styleMask: .borderless, backing: .buffered, defer: false)
    window.contentViewController = controller
    defer { _ = controller.close(); window.orderOut(nil) }
    func descendants(_ view: NSView) -> [NSView] { [view] + view.subviews.flatMap(descendants) }
    let editor = try #require(descendants(controller.view).compactMap { $0 as? NotesTextView }.first)
    window.makeFirstResponder(editor)
    let before = "- [ ] buy 🦊\n \t+  [X]\tnested\n```md\n- [ ] literal\n```\nprose - [ ] not a task"
    let rendered = "\u{fffc} buy 🦊\n \t\u{fffc}\tnested\n```md\n- [ ] literal\n```\nprose - [ ] not a task"
    editor.insertText(before, replacementRange: editor.selectedRange())
    editor.breakUndoCoalescing()
    editor.undoManager?.removeAllActions()
    #expect(editor.string == rendered)
    #expect(editor.markdownContents.string == before)
    #expect(editor.textStorage?.attribute(.attachment, at: 0, effectiveRange: nil) is NSTextAttachment)
    let boxes = editor.subviews.compactMap { $0 as? NSButton }
    #expect(boxes.map(\.state) == [.off, .on])
    #expect(boxes.first?.cell?.accessibilityRole() == .checkBox)
    #expect(boxes.first?.accessibilityLabel() == "buy 🦊")
    let selection = editor.selectedRange()
    let first = try #require(boxes.first)
    first.performClick(nil)
    let checked = before.replacingOccurrences(of: "- [ ] buy", with: "- [x] buy")
    #expect(editor.string == rendered)
    #expect(editor.markdownString == checked)
    #expect(first.state == .on)
    #expect(editor.selectedRange() == selection)
    let id = try #require(defaults.string(forKey: "selectedNote").flatMap(UUID.init(uuidString:)))
    let saved = try #require(NotesStore(directory: directory).notes.first { $0.id == id })
    #expect(saved.contents.string == checked)
    #expect(saved.contents.attribute(.attachment, at: 0, effectiveRange: nil) == nil)
    editor.undoManager?.undo()
    #expect(editor.markdownString == before)
    #expect(editor.string == rendered)
    #expect(editor.subviews.compactMap { $0 as? NSButton }.first?.state == .off)
    editor.undoManager?.redo()
    #expect(editor.markdownString == checked)
    #expect(editor.string == rendered)
    #expect(editor.subviews.compactMap { $0 as? NSButton }.first?.state == .on)
    editor.setSelectedRange(NSRange(location: 0, length: editor.string.utf16.count))
    let board = NSPasteboard.withUniqueName()
    defer { board.releaseGlobally() }
    #expect(editor.writeSelection(to: board, types: editor.writablePasteboardTypes))
    #expect(board.string(forType: .string) == checked)
    let reopened = NotesController(defaults: defaults, directory: directory)
    defer { _ = reopened.close() }
    let restoredEditor = try #require(descendants(reopened.view).compactMap { $0 as? NotesTextView }.first)
    #expect(restoredEditor.markdownString == checked)
    #expect(restoredEditor.string == rendered)
    #expect(restoredEditor.subviews.compactMap { $0 as? NSButton }.map(\.state) == [.on, .on])
    editor.insertText("- [x] finished", replacementRange: NSRange(location: 0, length: editor.string.utf16.count))
    let enter = try #require(NSEvent.keyEvent(with: .keyDown, location: .zero, modifierFlags: [],
        timestamp: 1, windowNumber: window.windowNumber, context: nil, characters: "\r",
        charactersIgnoringModifiers: "\r", isARepeat: false, keyCode: 36))
    editor.keyDown(with: enter)
    #expect(editor.markdownString == "- [x] finished\n- [ ] ")
    #expect(editor.string == "\u{fffc} finished\n\u{fffc} ")
    #expect(editor.subviews.compactMap { $0 as? NSButton }.map(\.state) == [.on, .off])
    editor.keyDown(with: enter)
    #expect(editor.markdownString == "- [x] finished\n")
    #expect(editor.string == "\u{fffc} finished\n")
    #expect(editor.subviews.compactMap { $0 as? NSButton }.map(\.state) == [.on])
}

@Test @MainActor
func atomicTasksExpandAtDeletionBoundariesAndNormalizeLineJoinsInOneUndo() throws {
    _ = NSApplication.shared
    let suite = "NotesTaskDeletion.\(UUID().uuidString)"
    let defaults = try #require(UserDefaults(suiteName: suite))
    let directory = FileManager.default.temporaryDirectory.appendingPathComponent(suite)
    defer {
        defaults.removePersistentDomain(forName: suite)
        try? FileManager.default.removeItem(at: directory)
    }
    let controller = NotesController(defaults: defaults, directory: directory)
    let window = NSWindow(contentRect: NSRect(x: 0, y: 0, width: 750, height: 390),
                          styleMask: .borderless, backing: .buffered, defer: false)
    window.contentViewController = controller
    defer { _ = controller.close(); window.orderOut(nil) }
    func descendants(_ view: NSView) -> [NSView] { [view] + view.subviews.flatMap(descendants) }
    let editor = try #require(descendants(controller.view).compactMap { $0 as? NotesTextView }.first)
    window.makeFirstResponder(editor)
    func reset(_ source: String) -> String {
        editor.insertText(source, replacementRange: NSRange(location: 0, length: editor.string.utf16.count))
        editor.breakUndoCoalescing()
        editor.undoManager?.removeAllActions()
        return editor.string
    }
    func delete(backward: Bool) {
        if backward { editor.deleteBackward(nil) }
        else { editor.deleteForward(nil) }
        editor.breakUndoCoalescing()
    }
    let boundaries = [
        ("- [ ] buy", true, "- [  buy"),
        ("\t+  [X]\t🦊", true, "\t+  [X\t🦊"),
        (" 12)\t[x] done", true, " 12)\t[x done"),
        ("- [ ] buy", false, " [ ] buy"),
        ("\t+  [X]\t🦊", false, "\t  [X]\t🦊"),
        (" 12)\t[x] done", false, " 2)\t[x] done"),
    ]
    for (source, backward, expanded) in boundaries {
        let rendered = reset(source)
        let token = (rendered as NSString).range(of: "\u{fffc}")
        #expect(token.length == 1)
        editor.setSelectedRange(NSRange(location: token.location + (backward ? 1 : 0), length: 0))
        delete(backward: backward)
        #expect(editor.string == expanded)
        #expect(editor.markdownString == expanded)
        let caret = backward ? (source as NSString).range(of: "]").location : token.location
        #expect(editor.selectedRange() == NSRange(location: caret, length: 0))
        editor.undoManager?.undo()
        #expect(editor.string == rendered)
        #expect(editor.markdownString == source)
        #expect(editor.undoManager?.canUndo == false)
        editor.undoManager?.redo()
        #expect(editor.string == expanded)
        #expect(editor.markdownString == expanded)
    }
    let joins = [
        ("prose\n- [ ] task", "prose- [ ] task", "prose- [ ] task"),
        ("prose\n  - [X] task", "prose  - [X] task", "prose  - [X] task"),
        ("🦊\n\t12) [x]\tfinish", "🦊\t12) [x]\tfinish", "🦊\t12) [x]\tfinish"),
        ("\n- [ ] task", "- [ ] task", "\u{fffc} task"),
        (" \t\n  + [X] task", " \t  + [X] task", " \t  \u{fffc} task"),
    ]
    for (source, joined, renderedJoin) in joins {
        for backward in [true, false] {
            let rendered = reset(source)
            let newline = (rendered as NSString).range(of: "\n")
            editor.setSelectedRange(NSRange(location: newline.location + (backward ? 1 : 0), length: 0))
            delete(backward: backward)
            #expect(editor.markdownString == joined)
            #expect(editor.string == renderedJoin)
            editor.undoManager?.undo()
            #expect(editor.markdownString == source)
            #expect(editor.string == rendered)
            #expect(editor.undoManager?.canUndo == false)
            editor.undoManager?.redo()
            #expect(editor.string == renderedJoin)
            #expect(editor.markdownString == joined)
        }
    }
}

@Test @MainActor
func atomicTasksCopySelectAndPersistMarkdownAlongsideUnicodeAndImages() throws {
    _ = NSApplication.shared
    let suite = "NotesTaskImages.\(UUID().uuidString)"
    let defaults = try #require(UserDefaults(suiteName: suite))
    let directory = FileManager.default.temporaryDirectory.appendingPathComponent(suite)
    defer {
        defaults.removePersistentDomain(forName: suite)
        try? FileManager.default.removeItem(at: directory)
    }
    let bitmap = try #require(NSBitmapImageRep(
        bitmapDataPlanes: nil, pixelsWide: 1, pixelsHigh: 1,
        bitsPerSample: 8, samplesPerPixel: 4, hasAlpha: true, isPlanar: false,
        colorSpaceName: .deviceRGB, bytesPerRow: 0, bitsPerPixel: 0))
    bitmap.setColor(.red, atX: 0, y: 0)
    let png = try #require(bitmap.representation(using: .png, properties: [:]))
    let imageFile = FileWrapper(regularFileWithContents: png)
    imageFile.preferredFilename = "pixel.png"
    let source = NSMutableAttributedString(string: "\t12)\t[X]\t🦊 ")
    let imageLocation = source.length
    source.append(NSAttributedString(attachment: NSTextAttachment(fileWrapper: imageFile)))
    source.append(NSAttributedString(string: "\n  - [ ] tail"))
    let store = try NotesStore(directory: directory)
    let id = try store.create()
    try store.update(id: id, contents: source)
    defaults.set(id.uuidString, forKey: "selectedNote")
    let controller = NotesController(defaults: defaults, directory: directory)
    let window = NSWindow(contentRect: NSRect(x: 0, y: 0, width: 750, height: 390),
                          styleMask: .borderless, backing: .buffered, defer: false)
    window.contentViewController = controller
    defer { _ = controller.close(); window.orderOut(nil) }
    func descendants(_ view: NSView) -> [NSView] { [view] + view.subviews.flatMap(descendants) }
    let editor = try #require(descendants(controller.view).compactMap { $0 as? NotesTextView }.first)
    window.makeFirstResponder(editor)
    let rendered = "\t\u{fffc}\t🦊 \u{fffc}\n  \u{fffc} tail"
    #expect(editor.string == rendered)
    #expect(editor.markdownString == source.string)
    let token = NSRange(location: 1, length: 1)
    let marker = (source.string as NSString).range(of: "12)\t[X]")
    #expect(editor.markdownRange(for: token) == marker)
    #expect(editor.renderedRange(for: (source.string as NSString).range(of: "[X]")) == token)
    #expect(editor.renderedRange(for: (source.string as NSString).range(of: "🦊")) == (rendered as NSString).range(of: "🦊"))
    editor.setSelectedRange(NSRange(location: token.location, length: 0))
    editor.moveRight(nil)
    #expect(editor.selectedRange() == NSRange(location: NSMaxRange(token), length: 0))
    editor.moveLeft(nil)
    #expect(editor.selectedRange() == NSRange(location: token.location, length: 0))
    editor.moveRightAndModifySelection(nil)
    #expect(editor.selectedRange() == token)
    let board = NSPasteboard.withUniqueName()
    defer { board.releaseGlobally() }
    editor.setSelectedRange(token)
    #expect(editor.writeSelection(to: board, types: editor.writablePasteboardTypes))
    #expect(board.string(forType: .string) == "12)\t[X]")
    editor.setSelectedRange(NSRange(location: 0, length: editor.string.utf16.count))
    board.clearContents()
    #expect(editor.writeSelection(to: board, types: editor.writablePasteboardTypes))
    #expect(board.string(forType: .string) == source.string)
    let copiedData = try #require(board.data(forType: .rtfd))
    let copied = try NSAttributedString(data: copiedData, options: [.documentType: NSAttributedString.DocumentType.rtfd], documentAttributes: nil)
    #expect(copied.string == source.string)
    #expect((copied.attribute(.attachment, at: imageLocation, effectiveRange: nil) as? NSTextAttachment)?.fileWrapper?.regularFileContents == png)
    editor.undoManager?.removeAllActions()
    editor.setSelectedRange(token)
    editor.deleteBackward(nil)
    editor.breakUndoCoalescing()
    #expect(editor.string == "\t\t🦊 \u{fffc}\n  \u{fffc} tail")
    #expect(editor.markdownString == (source.string as NSString).replacingCharacters(in: marker, with: ""))
    editor.undoManager?.undo()
    #expect(editor.string == rendered)
    #expect(editor.markdownString == source.string)
    #expect(editor.undoManager?.canUndo == false)
    #expect(controller.save())
    let saved = try #require(NotesStore(directory: directory).notes.first { $0.id == id })
    #expect(saved.contents.string == source.string)
    var savedAttachments: [NSTextAttachment] = []
    saved.contents.enumerateAttribute(.attachment, in: NSRange(location: 0, length: saved.contents.length)) { value, _, _ in
        if let attachment = value as? NSTextAttachment { savedAttachments.append(attachment) }
    }
    #expect(savedAttachments.count == 1)
    #expect(savedAttachments.first?.fileWrapper?.regularFileContents == png)
    let reopened = NotesController(defaults: defaults, directory: directory)
    defer { _ = reopened.close() }
    let reopenedEditor = try #require(descendants(reopened.view).compactMap { $0 as? NotesTextView }.first)
    #expect(reopenedEditor.string == rendered)
    #expect(reopenedEditor.markdownContents.string == source.string)
}