Frontend Components: Unit 4 — Image & Media

class ShoechooTextView: NSTextView {
    override func awakeFromNib() {
        super.awakeFromNib()
        registerForDraggedTypes([.fileURL])
    }
}

extension ShoechooTextView {
    override func draggingEntered(_ sender: NSDraggingInfo) -> NSDragOperation {
        // 1. Read file URLs from pasteboard
        // 2. Filter to supported image extensions (png, jpeg, jpg, gif)
        // 3. Return .copy if at least one valid image URL, .none otherwise
        guard hasValidImageURLs(sender.draggingPasteboard) else {
            return .none
        }
        return .copy
    }

    override func draggingUpdated(_ sender: NSDraggingInfo) -> NSDragOperation {
        // Show insertion cursor at drop point
        let point = convert(sender.draggingLocation, from: nil)
        let charIndex = characterIndexForInsertion(at: point)
        setSelectedRange(NSRange(location: charIndex, length: 0))
        return .copy
    }

    private func hasValidImageURLs(_ pasteboard: NSPasteboard) -> Bool {
        guard let urls = pasteboard.readObjects(
            forClasses: [NSURL.self],
            options: [.urlReadingFileURLsOnly: true]
        ) as? [URL] else { return false }

        let supported: Set<String> = ["png", "jpeg", "jpg", "gif"]
        return urls.contains { supported.contains($0.pathExtension.lowercased()) }
    }
}

extension ShoechooTextView {
    override func performDragOperation(_ sender: NSDraggingInfo) -> Bool {
        // 1. Extract valid image URLs from pasteboard
        guard let urls = sender.draggingPasteboard.readObjects(
            forClasses: [NSURL.self],
            options: [.urlReadingFileURLsOnly: true]
        ) as? [URL] else { return false }

        let supported: Set<String> = ["png", "jpeg", "jpg", "gif"]
        let imageURLs = urls.filter { supported.contains($0.pathExtension.lowercased()) }
        guard !imageURLs.isEmpty else { return false }

        // 2. Determine drop position
        let point = convert(sender.draggingLocation, from: nil)
        let dropPosition = characterIndexForInsertion(at: point)

        // 3. Forward to delegate (Coordinator → EditorViewModel)
        imageDropDelegate?.handleImageDrop(
            fileURLs: imageURLs,
            at: dropPosition
        )

        return true
    }
}

extension ShoechooTextView {
    override func paste(_ sender: Any?) {
        let pb = NSPasteboard.general

        // 1. If pasteboard has text, use standard paste (BR-02.2)
        if pb.string(forType: .string) != nil {
            super.paste(sender)
            return
        }

        // 2. If pasteboard has image data (no text), intercept for image import
        if let image = NSImage(pasteboard: pb) {
            let cursorPosition = selectedRange().location
            imageDropDelegate?.handleImagePaste(
                image: image,
                at: cursorPosition
            )
            return
        }

        // 3. Fallback: standard paste
        super.paste(sender)
    }
}

protocol ImageDropDelegate: AnyObject {
    func handleImageDrop(fileURLs: [URL], at position: Int)
    func handleImagePaste(image: NSImage, at position: Int)
}

extension WYSIWYGTextView.Coordinator: ImageDropDelegate {
    func handleImageDrop(fileURLs: [URL], at position: Int) {
        Task { @MainActor in
            await parent.viewModel.handleDroppedImages(fileURLs: fileURLs, at: position)
        }
    }

    func handleImagePaste(image: NSImage, at position: Int) {
        Task { @MainActor in
            await parent.viewModel.handlePastedImage(image: image, at: position)
        }
    }
}

extension EditorViewModel {
    // Pending import (held while save dialog is active)
    var pendingImageImport: PendingImageImport?
    var showSaveBeforeImageInsert: Bool = false

    enum PendingImageImport {
        case drop(fileURLs: [URL], position: Int)
        case paste(image: NSImage, position: Int)
    }
}

extension EditorViewModel {
    func handleDroppedImages(fileURLs: [URL], at position: Int) async {
        // 1. Check document readiness
        guard let assetsDir = document.assetsDirectoryURL else {
            pendingImageImport = .drop(fileURLs: fileURLs, position: position)
            showSaveBeforeImageInsert = true
            return
        }

        // 2. Import each image sequentially
        var insertionOffset = position
        for url in fileURLs {
            do {
                let result = try await imageService.importDroppedImage(url, to: assetsDir)
                insertImage(at: insertionOffset, relativePath: result.relativePath)
                insertionOffset += result.relativePath.count + 6 // ![alt](path)\n overhead
            } catch {
                presentError(error)
            }
        }
    }
}

extension EditorViewModel {
    func handlePastedImage(image: NSImage, at position: Int) async {
        // 1. Check document readiness
        guard let assetsDir = document.assetsDirectoryURL else {
            pendingImageImport = .paste(image: image, position: position)
            showSaveBeforeImageInsert = true
            return
        }

        // 2. Import pasted image
        do {
            let result = try await imageService.importPastedImage(
                from: NSPasteboard.general,
                to: assetsDir
            )
            insertImage(at: position, relativePath: result.relativePath)
        } catch {
            presentError(error)
        }
    }
}

extension EditorViewModel {
    func insertImage(at position: Int, relativePath: String) {
        // 1. Derive alt text from filename
        let filename = URL(string: relativePath)?.lastPathComponent ?? relativePath
        let altText = filename
            .replacingOccurrences(of: ".\(filename.split(separator: ".").last ?? "")", with: "")
            .replacingOccurrences(of: "-", with: " ")
            .replacingOccurrences(of: "_", with: " ")

        // 2. Build Markdown snippet
        let snippet = "![\(altText)](\(relativePath))"

        // 3. Determine line context
        let index = sourceText.index(sourceText.startIndex, offsetBy: min(position, sourceText.count))
        let isStartOfLine = index == sourceText.startIndex
            || sourceText[sourceText.index(before: index)] == "\n"

        // 4. Insert with appropriate newlines
        var insertion = ""
        if !isStartOfLine { insertion += "\n" }
        insertion += snippet + "\n"

        sourceText.insert(contentsOf: insertion, at: index)
        // Normal text change flow triggers parse/render
    }
}

// In EditorView
.alert("Save Document", isPresented: $viewModel.showSaveBeforeImageInsert) {
    Button("Save") {
        Task {
            if await viewModel.saveDocument() {
                await viewModel.resumePendingImageImport()
            }
        }
    }
    Button("Cancel", role: .cancel) {
        viewModel.pendingImageImport = nil
    }
} message: {
    Text("Please save the document before inserting images. Images are stored in a folder next to the document file.")
}

// In EditorView
.alert("Image Import Error", isPresented: $viewModel.showImageImportError) {
    Button("OK", role: .cancel) {}
} message: {
    Text(viewModel.imageImportErrorMessage ?? "An unknown error occurred.")
}