import AppKit
import ConjureKit
import Testing
@testable import Conjure

@Test @MainActor
func notesActionPillKeepsWindowInsetsWhenResized() throws {
    _ = NSApplication.shared
    let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
    let suite = "NotesLayout.\(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 pill = try #require(descendants(controller.view).first { $0 is ActionPill })
    for size in [NSSize(width: 750, height: 390), NSSize(width: 570, height: 260)] {
        window.setContentSize(size)
        controller.view.layoutSubtreeIfNeeded()
        let frame = pill.convert(pill.bounds, to: controller.view)
        #expect(abs(frame.minY - controller.view.bounds.minY - 8) < 0.5)
        #expect(abs(controller.view.bounds.maxX - frame.maxX - 8) < 0.5)
        #expect(abs(frame.height - 36) < 0.5)
    }
}

@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? NotesTextView }.first)
    let browse = try #require(views.compactMap { $0 as? NSButton }.first { $0.title == "Browse Notes" })
    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(NoteDocument.importMarkdown(NSAttributedString(string: "# Second 🦊\n**bold** and `code`")),
                      replacementRange: editor.selectedRange())
    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)
    let second = try #require(restored.notes.first { $0.id == secondID })
    #expect(second.contents.string == "Second 🦊\nbold and code")
    #expect(second.contents.attribute(NoteAttributes.headingLevel, at: 0, effectiveRange: nil) as? Int == 1)
    #expect(second.contents.attribute(NoteAttributes.bold, at: "Second 🦊\n".utf16.count, effectiveRange: nil) as? Bool == true)
    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)
    // Replacing formatted content must not leave stale paragraph or inline styles.
    reopenedEditor.insertText("Plain text", replacementRange: NSRange(location: 0, length: reopenedEditor.string.utf16.count))
    #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.replaceDocument(NoteDocument.importMarkdown(NSAttributedString(string: "- [x] Unsaved")),
                                  range: 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 == "Unsaved")
    #expect(reopenedEditor.documentContents.attribute(NoteAttributes.checked, at: 0, effectiveRange: nil) as? Bool == true)
    #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())
    let recovered = try #require(NotesStore(directory: directory).notes.first { $0.id == firstID })
    #expect(recovered.contents.string == "Unsaved")
    #expect(recovered.contents.attribute(NoteAttributes.checked, at: 0, effectiveRange: nil) as? Bool == true)
    #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(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(arguments: [false, true]) @MainActor
func notesNativeClosePreservesUnsavedEditsAndRestoresBorderlessLauncher(_ blockSaving: Bool) throws {
    _ = NSApplication.shared
    let suite = "NotesNativeClose.\(UUID().uuidString)"
    let defaults = try #require(UserDefaults(suiteName: suite))
    let root = FileManager.default.temporaryDirectory.appendingPathComponent(suite)
    let directory = root.appendingPathComponent("Notes")
    let backup = root.appendingPathComponent("Backup")
    defer {
        defaults.removePersistentDomain(forName: suite)
        try? FileManager.default.removeItem(at: root)
    }
    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 originalSize = window.frame.size
    launcher.present(command: .notes)
    let content = try #require(window.contentView)
    content.layoutSubtreeIfNeeded()
    func descendants(_ view: NSView) -> [NSView] { [view] + view.subviews.flatMap(descendants) }
    let editor = try #require(descendants(content).compactMap { $0 as? NotesTextView }.first)
    let close = try #require(window.standardWindowButton(.closeButton))
    #expect(window.styleMask.contains(.titled))
    #expect(!close.isHidden && close.isEnabled)
    #expect(window.standardWindowButton(.miniaturizeButton)?.isHidden != false)
    #expect(window.standardWindowButton(.zoomButton)?.isHidden != false)
    if blockSaving {
        try FileManager.default.moveItem(at: directory, to: backup)
        try Data("Blocked storage".utf8).write(to: directory)
    }
    editor.insertText("Keep this note", replacementRange: editor.selectedRange())
    close.performClick(nil)
    if blockSaving {
        #expect(window.isVisible)
        #expect(editor.string == "Keep this note")
        #expect(window.styleMask.contains(.titled))
        try FileManager.default.removeItem(at: directory)
        try FileManager.default.moveItem(at: backup, to: directory)
        close.performClick(nil)
    }
    #expect(!window.isVisible)
    #expect(window.styleMask == .borderless)
    #expect(window.frame.size == originalSize)
    #expect(try NotesStore(directory: directory).notes.first?.contents.string == "Keep this note")
    launcher.present(command: .emoji)
    #expect(window.styleMask == .borderless)
    #expect(!descendants(content).contains { $0 is NotesTextView })
    launcher.present(command: .notes)
    #expect(window.standardWindowButton(.closeButton)?.isHidden == false)
    #expect(window.standardWindowButton(.miniaturizeButton)?.isHidden != false)
    #expect(window.standardWindowButton(.zoomButton)?.isHidden != false)
}

@Test @MainActor
func notesRememberResizedDimensionsWithoutResizingOtherCommandsAndKeepTextMonospaced() throws {
    _ = NSApplication.shared
    let suite = "NotesWindowSize.\(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)
    }
    func makeLauncher() -> LauncherWindowController {
        LauncherWindowController(
            history: LaunchHistory(defaults: defaults, now: { Date(timeIntervalSinceReferenceDate: 12_000) }),
            defaults: defaults, notesDirectory: directory)
    }
    let launcher = makeLauncher()
    let window = try #require(launcher.window)
    defer { launcher.dismiss(restoringFocus: false) }
    let launcherSize = window.frame.size
    launcher.present(command: .notes)
    #expect(window.styleMask.contains(.resizable))
    func descendants(_ view: NSView) -> [NSView] { [view] + view.subviews.flatMap(descendants) }
    let content = try #require(window.contentView)
    let editor = try #require(descendants(content).compactMap { $0 as? NotesTextView }.first)
    editor.insertText(NoteDocument.importMarkdown(NSAttributedString(string: "Plain\n# Heading\n**bold** and *italic* and `code`")),
                      replacementRange: editor.selectedRange())
    let storage = try #require(editor.textStorage)
    storage.enumerateAttribute(.font, in: NSRange(location: 0, length: storage.length)) { value, _, _ in
        #expect((value as? NSFont)?.isFixedPitch == true)
    }
    #expect((editor.typingAttributes[.font] as? NSFont)?.isFixedPitch == true)
    let expanded = NSSize(width: 840, height: 620)
    var frame = window.frame
    frame.size = expanded
    window.setFrame(frame, display: true)
    window.contentView?.layoutSubtreeIfNeeded()
    #expect(editor.enclosingScrollView?.frame.width == expanded.width)
    #expect(editor.visibleRect.height > 400)
    launcher.present(command: .emoji)
    #expect(window.frame.size == launcherSize)
    #expect(!window.styleMask.contains(.resizable))
    launcher.present(command: .notes)
    #expect(window.frame.size == expanded)
    let compact = NSSize(width: 620, height: 330)
    frame = window.frame
    frame.size = compact
    window.setFrame(frame, display: true)
    launcher.dismiss(restoringFocus: false)

    // A fresh controller reads persisted dimensions, not an in-memory frame.
    let reopened = makeLauncher()
    defer { reopened.dismiss(restoringFocus: false) }
    reopened.present(command: .notes)
    #expect(reopened.window?.frame.size == compact)
    reopened.present(command: .translate)
    #expect(reopened.window?.frame.size == launcherSize)
}

@Test @MainActor
func structuredListsContinueSplitOutdentAndUndoWithoutSourceMarkers() throws {
    _ = NSApplication.shared
    let editor = NotesTextView(frame: NSRect(x: 0, y: 0, width: 520, height: 300))
    editor.allowsUndo = true
    let window = NSWindow(contentRect: editor.frame, styleMask: .borderless, backing: .buffered, defer: false)
    window.contentView = editor
    window.makeFirstResponder(editor)
    defer { window.orderOut(nil) }
    func reset(_ source: String) {
        editor.setDocumentContents(NoteDocument.importMarkdown(NSAttributedString(string: source)))
        editor.setSelectedRange(NSRange(location: editor.string.utf16.count, length: 0))
        editor.undoManager?.removeAllActions()
    }
    for (source, block, number) in [
        ("- fox 🦊", "bullet", 0), ("9. ninth", "ordered", 10),
        ("- [x] finished", "task", 0),
    ] {
        reset(source)
        let before = editor.string
        editor.insertNewline(nil)
        editor.insertText("next", replacementRange: editor.selectedRange())
        #expect(editor.string == before + "\nnext")
        let index = before.utf16.count + 1
        #expect(editor.documentContents.attribute(NoteAttributes.block, at: index, effectiveRange: nil) as? String == block)
        if number > 0 {
            #expect(editor.documentContents.attribute(NoteAttributes.number, at: index, effectiveRange: nil) as? Int == number)
        }
        if block == "task" {
            #expect(editor.documentContents.attribute(NoteAttributes.checked, at: index, effectiveRange: nil) as? Bool == false)
        }
    }
    reset("- ab🦊cd")
    editor.setSelectedRange((editor.string as NSString).range(of: "🦊"))
    editor.insertNewline(nil)
    #expect(editor.string == "ab\ncd")
    #expect(editor.selectedRange() == NSRange(location: 3, length: 0))
    #expect(editor.documentContents.attribute(NoteAttributes.block, at: 3, effectiveRange: nil) as? String == "bullet")
    editor.undoManager?.undo()
    #expect(editor.string == "ab🦊cd")
    #expect(editor.selectedRange() == NSRange(location: 2, length: 2))
    editor.undoManager?.redo()
    #expect(editor.string == "ab\ncd")

    reset("- parent\n  - child\n    - leaf")
    editor.insertNewline(nil)
    editor.insertText("temporary", replacementRange: editor.selectedRange())
    let last = (editor.string as NSString).range(of: "temporary")
    #expect(editor.documentContents.attribute(NoteAttributes.depth, at: last.location, effectiveRange: nil) as? Int == 2)
    editor.insertText("", replacementRange: last)
    editor.insertNewline(nil)
    editor.insertText("sibling", replacementRange: editor.selectedRange())
    let sibling = (editor.string as NSString).range(of: "sibling")
    #expect(editor.documentContents.attribute(NoteAttributes.depth, at: sibling.location, effectiveRange: nil) as? Int == 1)
    editor.insertText("", replacementRange: sibling)
    editor.insertNewline(nil)
    editor.insertNewline(nil)
    editor.insertText("body", replacementRange: editor.selectedRange())
    let body = (editor.string as NSString).range(of: "body")
    #expect(editor.documentContents.attribute(NoteAttributes.block, at: body.location, effectiveRange: nil) == nil)

    reset("```md\n- literal\n```")
    editor.insertNewline(nil)
    editor.insertText("- still literal", replacementRange: editor.selectedRange())
    #expect(editor.string == "- literal\n- still literal")
    #expect(editor.documentContents.attribute(NoteAttributes.block, at: editor.string.utf16.count - 1, effectiveRange: nil) as? String == "code")
}

@Test @MainActor
func typedParagraphShortcutsConsumeMarkersWithoutCreatingAttachments() throws {
    _ = NSApplication.shared
    let editor = NotesTextView(frame: NSRect(x: 0, y: 0, width: 520, height: 300))
    for (marker, block) in [("- ", "bullet"), ("* ", "bullet"), ("+ ", "bullet"),
                             ("12) ", "ordered"), ("- [ ] ", "task"), ("- [] ", "task"),
                             ("- [x] ", "task"), ("> ", "quote")] {
        editor.setDocumentContents(NSAttributedString(string: ""))
        editor.setSelectedRange(NSRange(location: 0, length: 0))
        for character in marker + "🦊 body" {
            editor.insertText(String(character), replacementRange: editor.selectedRange())
        }
        #expect(editor.string == "🦊 body")
        #expect(editor.selectedRange() == NSRange(location: "🦊 body".utf16.count, length: 0))
        #expect(editor.documentContents.attribute(NoteAttributes.block, at: 0, effectiveRange: nil) as? String == block)
        #expect(editor.documentContents.attribute(.attachment, at: 0, effectiveRange: nil) == nil)
        if block == "task" {
            #expect(editor.documentContents.attribute(NoteAttributes.checked, at: 0, effectiveRange: nil) as? Bool == marker.contains("[x]"))
        }
        if block == "ordered" {
            #expect(editor.documentContents.attribute(NoteAttributes.number, at: 0, effectiveRange: nil) as? Int == 12)
        }
    }
    for literal in ["-word", "1.word", "prose - item", "unmatched *text", "\\*escaped*"] {
        editor.setDocumentContents(NSAttributedString(string: ""))
        editor.setSelectedRange(NSRange(location: 0, length: 0))
        for character in literal {
            editor.insertText(String(character), replacementRange: editor.selectedRange())
        }
        #expect(editor.string == literal)
        #expect(editor.documentContents.attribute(NoteAttributes.block, at: 0, effectiveRange: nil) == nil)
    }
}

@Test @MainActor
func listIndentationPreservesActualUnicodeSelectionsAndUndo() throws {
    _ = NSApplication.shared
    let editor = NotesTextView(frame: NSRect(x: 0, y: 0, width: 520, height: 300))
    editor.allowsUndo = true
    let window = NSWindow(contentRect: editor.frame, styleMask: .borderless, backing: .buffered, defer: false)
    window.contentView = editor
    window.makeFirstResponder(editor)
    defer { window.orderOut(nil) }
    for source in ["- parent\n- 🦊 café", "1. parent\n2. 🦊 café\n3. tail", "- [ ] parent\n- [x] 🦊 café"] {
        editor.setDocumentContents(NoteDocument.importMarkdown(NSAttributedString(string: source)))
        let selection = (editor.string as NSString).range(of: "🦊 café")
        editor.setSelectedRange(selection)
        editor.undoManager?.removeAllActions()
        let before = editor.string
        editor.insertTab(nil)
        #expect(editor.string == before)
        #expect(editor.selectedRange() == selection)
        #expect(editor.documentContents.attribute(NoteAttributes.depth, at: selection.location, effectiveRange: nil) as? Int == 1)
        if source.hasPrefix("1.") {
            let tail = (editor.string as NSString).range(of: "tail").location
            #expect(editor.documentContents.attribute(NoteAttributes.number, at: selection.location, effectiveRange: nil) as? Int == 1)
            #expect(editor.documentContents.attribute(NoteAttributes.number, at: tail, effectiveRange: nil) as? Int == 2)
        }
        editor.undoManager?.undo()
        #expect(editor.selectedRange() == selection)
        #expect((editor.documentContents.attribute(NoteAttributes.depth, at: selection.location, effectiveRange: nil) as? Int ?? 0) == 0)
        editor.undoManager?.redo()
        #expect(editor.documentContents.attribute(NoteAttributes.depth, at: selection.location, effectiveRange: nil) as? Int == 1)
        editor.insertBacktab(nil)
        #expect(editor.string == before)
        #expect(editor.selectedRange() == selection)
        #expect((editor.documentContents.attribute(NoteAttributes.depth, at: selection.location, effectiveRange: nil) as? Int ?? 0) == 0)
        if source.hasPrefix("1.") {
            let tail = (editor.string as NSString).range(of: "tail").location
            #expect(editor.documentContents.attribute(NoteAttributes.number, at: selection.location, effectiveRange: nil) as? Int == 2)
            #expect(editor.documentContents.attribute(NoteAttributes.number, at: tail, effectiveRange: nil) as? Int == 3)
        }
    }
}

@Test @MainActor
func taskCheckboxesToggleSemanticStateWithUndoAndPersistence() 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 store = try NotesStore(directory: directory)
    let id = try store.create()
    try store.update(id: id, contents: NoteDocument.importMarkdown(NSAttributedString(string:
        "- [ ] buy 🦊\n  - [x] nested\n```md\n- [ ] literal\n```\nprose - [ ] not a task")))
    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 before = editor.string
    #expect(before == "buy 🦊\nnested\n- [ ] literal\nprose - [ ] not a task")
    let boxes = editor.subviews.compactMap { $0 as? NSButton }
    #expect(boxes.map(\.state) == [.off, .on])
    let first = try #require(boxes.first)
    #expect(first.cell?.accessibilityRole() == .checkBox)
    #expect(first.accessibilityLabel() == "buy 🦊")
    let selection = NSRange(location: 2, length: 2)
    editor.setSelectedRange(selection)
    editor.undoManager?.removeAllActions()
    first.performClick(nil)
    #expect(editor.string == before)
    #expect(editor.selectedRange() == selection)
    #expect(editor.documentContents.attribute(NoteAttributes.checked, at: 0, effectiveRange: nil) as? Bool == true)
    #expect(controller.save())
    let saved = try #require(NotesStore(directory: directory).notes.first { $0.id == id })
    #expect(saved.contents.string == before)
    #expect(saved.contents.attribute(NoteAttributes.checked, at: 0, effectiveRange: nil) as? Bool == true)
    editor.undoManager?.undo()
    #expect(editor.documentContents.attribute(NoteAttributes.checked, at: 0, effectiveRange: nil) as? Bool == false)
    #expect(editor.subviews.compactMap { $0 as? NSButton }.first?.state == .off)
    editor.undoManager?.redo()
    #expect(editor.subviews.compactMap { $0 as? NSButton }.first?.state == .on)
    #expect(controller.save())
    let reopened = NotesController(defaults: defaults, directory: directory)
    defer { _ = reopened.close() }
    let restored = try #require(descendants(reopened.view).compactMap { $0 as? NotesTextView }.first)
    #expect(restored.string == before)
    #expect(restored.subviews.compactMap { $0 as? NSButton }.map(\.state) == [.on, .on])
}

@Test @MainActor
func listBodiesUseActualTextOffsetsForTypingPasteReplacementAndDeletion() throws {
    _ = NSApplication.shared
    let editor = NotesTextView(frame: NSRect(x: 0, y: 0, width: 520, height: 300))
    editor.allowsUndo = true
    let window = NSWindow(contentRect: editor.frame, styleMask: .borderless, backing: .buffered, defer: false)
    window.contentView = editor
    window.makeFirstResponder(editor)
    defer { window.orderOut(nil) }
    let board = NSPasteboard.withUniqueName()
    defer { board.releaseGlobally() }
    board.setString("**literal paste**", forType: .string)
    for source in ["- ab🦊cd", "12. ab🦊cd", "- [x] ab🦊cd"] {
        editor.setDocumentContents(NoteDocument.importMarkdown(NSAttributedString(string: source)))
        #expect(editor.string == "ab🦊cd")
        editor.setSelectedRange(NSRange(location: 0, length: 0))
        editor.moveRight(nil)
        #expect(editor.selectedRange().location == 1)
        editor.setSelectedRange((editor.string as NSString).range(of: "🦊"))
        editor.undoManager?.removeAllActions()
        editor.insertText("X", replacementRange: editor.selectedRange())
        #expect(editor.string == "abXcd")
        editor.undoManager?.undo()
        #expect(editor.string == "ab🦊cd")
        #expect(editor.selectedRange() == NSRange(location: 2, length: 2))
        editor.undoManager?.redo()
        #expect(editor.string == "abXcd")
        editor.setSelectedRange(NSRange(location: 0, length: 0))
        #expect(editor.readSelection(from: board))
        #expect(editor.string == "**literal paste**abXcd")
        #expect(editor.documentContents.attribute(NoteAttributes.bold, at: 2, effectiveRange: nil) as? Bool != true)
        editor.insertText("  ", replacementRange: NSRange(location: 0, length: 0))
        editor.setSelectedRange(NSRange(location: 0, length: 0))
        editor.moveRight(nil)
        #expect(editor.selectedRange().location == 1)
        editor.moveRight(nil)
        #expect(editor.selectedRange().location == 2)
    }
    editor.setDocumentContents(NoteDocument.importMarkdown(NSAttributedString(string: "prose\n- item")))
    editor.setSelectedRange(NSRange(location: "prose\n".utf16.count, length: 0))
    editor.undoManager?.removeAllActions()
    editor.deleteBackward(nil)
    #expect(editor.string == "proseitem")
    editor.undoManager?.undo()
    #expect(editor.string == "prose\nitem")
    #expect(editor.documentContents.attribute(NoteAttributes.block, at: 6, effectiveRange: nil) as? String == "bullet")
}

@Test @MainActor
func mixedListBodiesAndWrappedLinesShareColumnsAtEachDepth() throws {
    _ = NSApplication.shared
    let editor = NotesTextView(frame: NSRect(x: 0, y: 0, width: 400, height: 800))
    let continuation = String(repeating: " wrapped words", count: 15)
    let rows = [("- ", "bullet"), ("1. ", "ordered"), ("123456789. ", "wide"),
                ("- [ ] ", "task"), ("  - ", "nested"), ("  - [x] ", "nestedTask")]
    let source = rows.map { $0.0 + $0.1 + continuation }.joined(separator: "\n")
    editor.setDocumentContents(NoteDocument.importMarkdown(NSAttributedString(string: source)))
    let layout = try #require(editor.layoutManager)
    let container = try #require(editor.textContainer)
    layout.ensureLayout(for: container)
    func position(_ glyph: Int) -> NSPoint {
        let fragment = layout.lineFragmentRect(forGlyphAt: glyph, effectiveRange: nil)
        let location = layout.location(forGlyphAt: glyph)
        return NSPoint(x: fragment.minX + location.x, y: fragment.minY + location.y)
    }
    var columns: [CGFloat] = []
    for row in rows {
        let body = (editor.string as NSString).range(of: row.1 + continuation)
        let glyphs = layout.glyphRange(forCharacterRange: body, actualCharacterRange: nil)
        let column = position(glyphs.location).x
        columns.append(column)
        var lines = 0
        layout.enumerateLineFragments(forGlyphRange: glyphs) { _, _, _, lineGlyphs, _ in
            #expect(abs(position(lineGlyphs.location).x - column) < 0.5)
            lines += 1
        }
        #expect(lines > 1)
    }
    for column in columns.prefix(4) { #expect(abs(column - columns[0]) < 0.5) }
    #expect(abs(columns[4] - columns[5]) < 0.5)
    #expect(columns[4] > columns[0])
    #expect(!editor.string.contains("\u{fffc}"))
}

@Test @MainActor
func notesToolbarFormattingPreservesAttachmentsSelectionAndUndo() throws {
    _ = NSApplication.shared
    let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
    let suite = "NotesFormatting.\(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: 570, height: 404),
                          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? NotesTextView }.first)
    func click(_ label: String) throws {
        try #require(views.compactMap { $0 as? NSButton }.first { $0.accessibilityLabel() == label }).performClick(nil)
    }
    window.makeFirstResponder(editor)
    editor.insertText("🦊 first\nsecond\nuntouched", replacementRange: editor.selectedRange())
    let selection = NSRange(location: 0, length: "🦊 first\nsecond\n".utf16.count)
    editor.setSelectedRange(selection)
    for (label, block) in [("Bullet list", "bullet"), ("Ordered list", "ordered"), ("Checklist", "task")] {
        try click(label)
        #expect(editor.string == "🦊 first\nsecond\nuntouched")
        #expect(editor.selectedRange() == selection)
        #expect(editor.documentContents.attribute(NoteAttributes.block, at: 0, effectiveRange: nil) as? String == block)
        #expect(editor.documentContents.attribute(NoteAttributes.block, at: "🦊 first\n".utf16.count, effectiveRange: nil) as? String == block)
        #expect(editor.documentContents.attribute(NoteAttributes.block, at: "🦊 first\nsecond\n".utf16.count, effectiveRange: nil) == nil)
    }
    try click("Checklist")
    #expect(editor.documentContents.attribute(NoteAttributes.block, at: 0, effectiveRange: nil) == nil)
    try click("Bold")
    #expect(editor.documentContents.attribute(NoteAttributes.bold, at: 0, effectiveRange: nil) as? Bool == true)
    try click("Bold")
    #expect(editor.documentContents.attribute(NoteAttributes.bold, at: 0, effectiveRange: nil) as? Bool != true)
    #expect(editor.selectedRange() == selection)
    editor.setSelectedRange(NSRange(location: 3, length: 0))
    try click("Code block")
    #expect(editor.documentContents.attribute(NoteAttributes.block, at: 0, effectiveRange: nil) as? String == "code")
    try click("Code block")
    #expect(editor.documentContents.attribute(NoteAttributes.block, at: 0, effectiveRange: nil) == nil)
    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 file = FileWrapper(regularFileWithContents: png)
    file.preferredFilename = "pixel.png"
    editor.insertText(NSAttributedString(attachment: NSTextAttachment(fileWrapper: file)),
                      replacementRange: NSRange(location: editor.string.utf16.count, length: 0))
    let before = editor.string
    editor.setSelectedRange(NSRange(location: 0, length: editor.string.utf16.count))
    editor.undoManager?.removeAllActions()
    try click("Quote")
    #expect(editor.string == before)
    #expect(editor.documentContents.attribute(NoteAttributes.block, at: 0, effectiveRange: nil) as? String == "quote")
    editor.undoManager?.undo()
    #expect(editor.string == before)
    #expect(editor.documentContents.attribute(NoteAttributes.block, at: 0, effectiveRange: nil) == nil)
    #expect(controller.save())
    let saved = try #require(NotesStore(directory: directory).notes.first)
    #expect(saved.contents.string == before)
    let attachment = try #require(saved.contents.attribute(.attachment, at: saved.contents.length - 1, effectiveRange: nil) as? NSTextAttachment)
    #expect(attachment.fileWrapper?.regularFileContents == png)
}

@Test @MainActor
func notesDeletionRequiresConfirmationPreservesFailuresAndReplacesTheLastNote() async throws {
    _ = NSApplication.shared
    let suite = "NotesDeletion.\(UUID().uuidString)"
    let defaults = try #require(UserDefaults(suiteName: suite))
    let directory = FileManager.default.temporaryDirectory.appendingPathComponent(suite)
    let backup = directory.appendingPathExtension("backup")
    defer {
        defaults.removePersistentDomain(forName: suite)
        try? FileManager.default.removeItem(at: directory)
        try? FileManager.default.removeItem(at: backup)
    }
    let store = try NotesStore(directory: directory)
    let first = try store.create()
    let second = try store.create()
    try store.update(id: first, contents: NSAttributedString(string: "Delete this note"))
    try store.update(id: second, contents: NSAttributedString(string: "Keep this note"))
    defaults.set(first.uuidString, forKey: "selectedNote")
    let controller = NotesController(defaults: defaults, directory: directory)
    let window = NSWindow(contentRect: NSRect(x: 0, y: 0, width: 570, height: 404),
        styleMask: [.titled], backing: .buffered, defer: false)
    window.contentViewController = controller
    defer { _ = controller.close(); window.orderOut(nil) }
    window.orderFront(nil)
    func descendants(_ view: NSView) -> [NSView] { [view] + view.subviews.flatMap(descendants) }
    let editor = try #require(descendants(controller.view).compactMap { $0 as? NotesTextView }.first)
    func delete(confirm: Bool) async throws {
        controller.showActions()
        let search = try #require(descendants(controller.view).compactMap { $0 as? NSSearchField }.first)
        search.stringValue = "delete"
        search.delegate?.controlTextDidChange?(Notification(name: NSControl.textDidChangeNotification, object: search))
        #expect(controller.handle(#selector(NSResponder.insertNewline(_:))))
        let sheet = try #require(window.attachedSheet)
        let content = try #require(sheet.contentView)
        let buttons = descendants(content).compactMap { $0 as? NSButton }
        let delete = try #require(buttons.first { $0.title == "Delete Note" })
        #expect(sheet.firstResponder === delete)
        let button = try #require(buttons.first { $0.title == (confirm ? "Delete Note" : "Cancel") })
        button.performClick(nil)
        // Scheduling deadline only; deletion does not depend on wall-clock time.
        for _ in 0..<1_000 {
            if window.attachedSheet == nil, window.firstResponder === editor { return }
            try await Task.sleep(for: .milliseconds(1))
        }
        try #require(window.attachedSheet == nil && window.firstResponder === editor)
    }
    try await delete(confirm: false)
    #expect(defaults.string(forKey: "selectedNote") == first.uuidString)
    #expect(editor.string == "Delete this note")
    #expect(Set(try NotesStore(directory: directory).notes.map(\.id)) == Set([first, second]))

    // A failed save must not let confirmation discard an unsaved buffer.
    try FileManager.default.moveItem(at: directory, to: backup)
    try Data("Blocked storage".utf8).write(to: directory)
    editor.insertText("Unsaved changes", replacementRange: NSRange(location: 0, length: editor.string.utf16.count))
    try await delete(confirm: true)
    #expect(defaults.string(forKey: "selectedNote") == first.uuidString)
    #expect(editor.string == "Unsaved changes")
    #expect(!controller.save())
    try FileManager.default.removeItem(at: directory)
    try FileManager.default.moveItem(at: backup, to: directory)
    #expect(try NotesStore(directory: directory).notes.first { $0.id == first }?.contents.string == "Delete this note")

    try await delete(confirm: true)
    #expect(try NotesStore(directory: directory).notes.map(\.id) == [second])
    #expect(defaults.string(forKey: "selectedNote") == second.uuidString)
    #expect(editor.string == "Keep this note")
    #expect(editor.undoManager?.canUndo != true)
    try await delete(confirm: true)
    let replacement = try #require(NotesStore(directory: directory).notes.first)
    #expect(replacement.id != first && replacement.id != second)
    #expect(replacement.contents.string.isEmpty)
    #expect(defaults.string(forKey: "selectedNote") == replacement.id.uuidString)
    #expect(editor.string.isEmpty)
    #expect(editor.isEditable)
    #expect(editor.undoManager?.canUndo != true)
    let reopened = NotesController(defaults: defaults, directory: directory)
    #expect(descendants(reopened.view).compactMap { $0 as? NotesTextView }.first?.string == "")
    #expect(defaults.string(forKey: "selectedNote") == replacement.id.uuidString)
}