gramora/gramora/ViewModels/SpellCheckerViewModel.swift

import AppKit
import Combine
import Foundation

@MainActor
final class SpellCheckerViewModel: ObservableObject {
    static let maxWords = 1_000

    @Published var text: String = ""
    @Published private(set) var mistakes: [SpellingMistake] = []
    @Published private(set) var correctedText: String = ""
    @Published private(set) var hasResults = false
    @Published private(set) var isChecking = false
    @Published private(set) var errorMessage: String?

    private let spellCheckService: any SpellCheckServicing
    private let historyStorage: HistoryStoring
    private let textExtractionService: any TextExtracting

    init(
        spellCheckService: any SpellCheckServicing = SpellCheckService(),
        historyStorage: HistoryStoring = HistoryStorageService.shared,
        textExtractionService: any TextExtracting = TextExtractionService()
    ) {
        self.spellCheckService = spellCheckService
        self.historyStorage = historyStorage
        self.textExtractionService = textExtractionService
    }

    var wordCountLimitLabel: String {
        "\(text.wordCount)/\(Self.maxWords)"
    }

    var mistakeCountLabel: String {
        let count = mistakes.count
        return "\(count) Mistake\(count == 1 ? "" : "s")"
    }

    var canCheck: Bool {
        !text.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty && !isChecking
    }

    func pasteText() {
        guard let clipboard = NSPasteboard.general.string(forType: .string) else { return }
        text = WordLimit.applyImported(clipboard, maxWords: Self.maxWords, setError: { errorMessage = $0 })
        resetResults()
    }

    func uploadFile() {
        Task {
            do {
                guard let extracted = try await textExtractionService.pickAndExtractText() else { return }
                text = WordLimit.applyImported(extracted, maxWords: Self.maxWords, setError: { errorMessage = $0 })
                resetResults()
            } catch {
                errorMessage = error.localizedDescription
            }
        }
    }

    func notifyWordLimitReached() {
        errorMessage = WordLimit.message(maxWords: Self.maxWords)
    }

    func handleTextChange() {
        let (limited, exceeded) = WordLimit.apply(text, maxWords: Self.maxWords)
        if exceeded {
            text = limited
            errorMessage = WordLimit.message(maxWords: Self.maxWords)
        } else if errorMessage == WordLimit.message(maxWords: Self.maxWords) {
            errorMessage = nil
        }
        if hasResults {
            resetResults()
        }
    }

    func clearText() {
        text = ""
        resetResults()
    }

    func resetResults() {
        mistakes = []
        correctedText = ""
        hasResults = false
        errorMessage = nil
    }

    func checkSpelling() {
        let content = text.trimmingCharacters(in: .whitespacesAndNewlines)
        guard !content.isEmpty else {
            resetResults()
            return
        }

        isChecking = true
        errorMessage = nil

        Task {
            do {
                let result = try await spellCheckService.checkSpelling(in: content)
                mistakes = result.mistakes
                correctedText = result.correctedText
                hasResults = true
                saveToHistory(text: content, mistakes: result.mistakes, correctedText: result.correctedText)
            } catch {
                errorMessage = error.localizedDescription
            }

            isChecking = false
        }
    }

    func restore(from entry: HistoryEntry) {
        guard case .spellingChecker(let data) = entry.payload else { return }

        text = data.text
        mistakes = data.mistakes.map {
            SpellingMistake(original: $0.original, suggestion: $0.suggestion)
        }
        correctedText = data.correctedText
        hasResults = true
        errorMessage = nil
    }

    private func saveToHistory(text: String, mistakes: [SpellingMistake], correctedText: String) {
        let payload = HistoryPayload.spellingChecker(
            SpellCheckerHistoryData(
                text: text,
                mistakes: mistakes.map(\.stored),
                correctedText: correctedText
            )
        )

        let entry = HistoryEntry(
            tool: .spellingChecker,
            title: HistoryHelpers.title(from: text, fallback: "Spelling Check"),
            preview: HistoryHelpers.preview(from: correctedText),
            payload: payload
        )

        historyStorage.save(entry)
    }

    func copyCorrectedText() {
        guard !correctedText.isEmpty else { return }
        NSPasteboard.general.clearContents()
        NSPasteboard.general.setString(correctedText, forType: .string)
    }
}