// AppGroupStore.swift
// OSGKeyboard · Shared
//
// Thin read/write facade over `AppGroupConfiguration` for the keyboard
// extension (no SwiftUI) and other non-ObservableObject call sites.
//
// `apiKey` is NOT stored in UserDefaults — see `Keychain.swift`.

import Foundation

/// Sendable facade over thread-safe UserDefaults, hence `@unchecked`; callers
/// must still serialize compound read-modify-write mutations. iOS requires the
/// App Group (except unsigned tests), while macOS may use `.standard`. API keys
/// are resolved from Keychain and never saved here.
public struct AppGroupStore: @unchecked Sendable {
    public let defaults: UserDefaults

    public init(defaults: UserDefaults? = nil) {
        if let defaults {
            self.defaults = defaults
            return
        }
        if let available = AppGroup.defaultsIfAvailable {
            self.defaults = available
            return
        }
        #if os(iOS)
        // iOS app + keyboard extension MUST share the App Group suite; a
        // silent `.standard` fallback would desync them. Keep this a hard
        // failure so a provisioning mistake is impossible to miss.
        //
        // Exception: unsigned XCTest hosts (`CODE_SIGNING_ALLOWED=NO`) often
        // lack the App Group container. `fatalError` here aborts the whole
        // test process (SIGTRAP) and masks real assertion failures — use an
        // isolated suite only while XCTest is loaded.
        #if DEBUG
        if NSClassFromString("XCTestCase") != nil {
            let suiteName = "\(AppGroup.identifier).xctest-fallback"
            self.defaults = UserDefaults(suiteName: suiteName) ?? .standard
            return
        }
        fatalError("App Group unavailable — inject UserDefaults in tests or fix entitlements.")
        #else
        fatalError("App Group unavailable.")
        #endif
        #else
        // macOS is a standalone menu-bar app with no keyboard extension to
        // stay in sync with, so a missing App Group container is expected;
        // fall back to the app's standard defaults.
        self.defaults = .standard
        #endif
    }

    private var configuration: AppGroupConfiguration {
        AppGroupConfiguration.load(fromAvailable: defaults)
    }

    private func mutateConfiguration(_ transform: (inout AppGroupConfiguration) -> Void) {
        var config = AppGroupConfiguration.load(fromAvailable: defaults)
        transform(&config)
        config.save(to: defaults)
    }

    // MARK: - Reads

    public var providerId: String { configuration.providerId }
    public var baseURL: String { configuration.baseURL }
    public var apiKey: String { configuration.apiKey }
    public var model: String { configuration.model }
    public var asrProviderId: String { configuration.asrProviderId }
    public var asrBaseURL: String { configuration.resolvedASRBaseURL }
    public var asrApiKey: String { configuration.asrApiKey }
    public var asrModel: String { configuration.resolvedASRModel }
    public var modeId: String { configuration.modeId }
    public var localeId: String { configuration.localeId }
    public var engineMode: String { configuration.engineMode }
    public var uiLanguage: AppUILanguage { configuration.uiLanguage }
    public var translationEnabled: Bool { configuration.translationEnabled }
    public var translationTargetLocaleId: String { configuration.translationTargetLocaleId }
    public var handednessPreference: HandednessPreference { configuration.handednessPreference }
    public var cursorDragNavigationEnabled: Bool { configuration.cursorDragNavigationEnabled }
    public var keyboardHapticIntensity: KeyboardHapticIntensity { configuration.keyboardHapticIntensity }
    public var polishIntensity: PolishIntensity { configuration.polishIntensity }
    public var aiResponseLength: AIResponseLength { configuration.aiResponseLength }
    public var polishStyleCatalog: PolishStyleCatalog { configuration.polishStyleCatalog }
    public var activePolishStyleId: String { configuration.activePolishStyleId }
    public var activePolishStyle: PolishStylePack {
        PolishStylePackCatalog.resolve(id: activePolishStyleId, userCatalog: polishStyleCatalog)
    }
    public var llmThinkingEnabled: Bool { configuration.llmThinkingEnabled }
    public var clipboardHistoryEnabled: Bool { configuration.clipboardHistoryEnabled }
    public var clipboardCandidateBarEnabled: Bool { configuration.clipboardCandidateBarEnabled }
    public var isPolishKeyMissing: Bool { configuration.isPolishKeyMissing }
    public var isTranslationEffective: Bool { configuration.isTranslationEffective }
    public var isLocalEngine: Bool { configuration.isLocalEngine }
    public var polishModeForPipeline: PolishingService.PolishMode { configuration.polishModeForPipeline }
    public var polishProviderIdOverride: String? { configuration.polishProviderIdOverride }
    public var isCloudAPIKeyMissingForVoiceInput: Bool { configuration.isCloudAPIKeyMissingForVoiceInput }
    public var localASRCustomLanguageModelEnabled: Bool { configuration.localASRCustomLanguageModelEnabled }
    /// Kept off `AppGroupConfiguration.save()` so other settings writes cannot clobber it.
    public var agentSkillLayout: AIAgentSkillLayout {
        Self.decodeAgentSkillLayout(from: defaults, userCatalog: agentUserSkillCatalog)
    }

    public var agentUserSkillCatalog: AIUserSkillCatalog {
        Self.decodeUserSkillCatalog(from: defaults)
    }

    // MARK: - Writes

    public func setModeId(_ id: String) {
        mutateConfiguration { $0.modeId = id }
    }

    public func setLocaleId(_ id: String) {
        mutateConfiguration { $0.localeId = id }
    }

    public func setEngineMode(_ mode: String) {
        mutateConfiguration { $0.engineMode = mode }
        AppGroupConfigDarwin.postConfigChanged()
    }

    public func setUILanguage(_ language: AppUILanguage) {
        mutateConfiguration { $0.uiLanguage = language }
    }

    public func setTranslationEnabled(_ enabled: Bool) {
        setTranslationTargetLocaleId(
            enabled ? TranslationLanguageCatalog.defaultLocaleId : TranslationLanguageCatalog.offLocaleId
        )
    }

    public func setTranslationTargetLocaleId(_ id: String) {
        mutateConfiguration { $0.translationTargetLocaleId = id }
        AppGroupConfigDarwin.postConfigChanged()
    }

    public func setHandednessPreference(_ preference: HandednessPreference) {
        mutateConfiguration { $0.handednessPreference = preference }
        AppGroupConfigDarwin.postConfigChanged()
    }

    public func setCursorDragNavigationEnabled(_ enabled: Bool) {
        mutateConfiguration { $0.cursorDragNavigationEnabled = enabled }
        AppGroupConfigDarwin.postConfigChanged()
    }

    public func setKeyboardHapticIntensity(_ intensity: KeyboardHapticIntensity) {
        mutateConfiguration { $0.keyboardHapticIntensity = intensity }
        AppGroupConfigDarwin.postConfigChanged()
    }

    public func setPolishIntensity(_ intensity: PolishIntensity) {
        mutateConfiguration { $0.polishIntensity = intensity }
        AppGroupConfigDarwin.postConfigChanged()
    }

    public func setAIResponseLength(_ length: AIResponseLength) {
        mutateConfiguration { $0.aiResponseLength = length }
        AppGroupConfigDarwin.postConfigChanged()
    }

    // MARK: - Polish styles

    public func setPolishStyleCatalog(_ catalog: PolishStyleCatalog) {
        mutateConfiguration { $0.polishStyleCatalog = catalog }
        AppGroupConfigDarwin.postConfigChanged()
    }

    public func setActivePolishStyleId(_ id: String) {
        mutateConfiguration { config in
            config.activePolishStyleId = PolishStylePackCatalog.isValidActiveID(
                id,
                userCatalog: config.polishStyleCatalog
            ) ? id : PolishStylePackCatalog.defaultID
        }
        AppGroupConfigDarwin.postConfigChanged()
    }

    public func deletePolishStylePack(id: String, at date: Date = Date()) {
        mutateConfiguration { config in
            config.polishStyleCatalog.recordDeletion(of: id, at: date)
            if config.activePolishStyleId == id {
                config.activePolishStyleId = PolishStylePackCatalog.defaultID
            }
        }
        AppGroupConfigDarwin.postConfigChanged()
    }

    public func setLLMThinkingEnabled(_ enabled: Bool) {
        mutateConfiguration { $0.llmThinkingEnabled = enabled }
        AppGroupConfigDarwin.postConfigChanged()
    }

    public func setClipboardHistoryEnabled(_ enabled: Bool) {
        mutateConfiguration { $0.clipboardHistoryEnabled = enabled }
        AppGroupConfigDarwin.postConfigChanged()
    }

    public func setClipboardCandidateBarEnabled(_ enabled: Bool) {
        mutateConfiguration { $0.clipboardCandidateBarEnabled = enabled }
        AppGroupConfigDarwin.postConfigChanged()
    }

    public func setLocalASRCustomLanguageModelEnabled(_ enabled: Bool) {
        mutateConfiguration { $0.localASRCustomLanguageModelEnabled = enabled }
    }

    public func setAgentSkillLayout(_ layout: AIAgentSkillLayout) {
        do {
            let data = try JSONEncoder().encode(
                layout.sanitized(catalog: AIClipboardSkillCatalog.all(userCatalog: agentUserSkillCatalog))
            )
            defaults.set(data, forKey: AppGroupConfiguration.Keys.agentSkillLayout)
        } catch {
            OSGLog.config.warning("agentSkillLayout encode failed: \(error.localizedDescription, privacy: .public)")
        }
        AppGroupConfigDarwin.postConfigChanged()
    }

    public func setAgentUserSkillCatalog(_ catalog: AIUserSkillCatalog) {
        do {
            defaults.set(
                try JSONEncoder().encode(catalog),
                forKey: AppGroupConfiguration.Keys.agentUserSkillCatalog
            )
        } catch {
            OSGLog.config.warning(
                "agentUserSkillCatalog encode failed: \(error.localizedDescription, privacy: .public)"
            )
        }
        AppGroupConfigDarwin.postConfigChanged()
    }

    public func setPendingShortcutRun(skillID: String, titles: [String]) {
        let payload = AIAgentShortcutRunPayload(skillID: skillID, titles: titles)
        if let data = AIAgentShortcutRun.encode(payload) {
            defaults.set(data, forKey: AIAgentShortcutRun.pendingKey)
            AIAgentShortcutRun.trace(
                "appGroup.writePending skill=\(skillID) items=\(titles.count) bytes=\(data.count)"
            )
        } else {
            AIAgentShortcutRun.trace("appGroup.writePending FAILED encode skill=\(skillID)")
        }
    }

    public func consumePendingShortcutRun(now: Date = Date()) -> AIAgentShortcutRunPayload? {
        let data = defaults.data(forKey: AIAgentShortcutRun.pendingKey)
        defaults.removeObject(forKey: AIAgentShortcutRun.pendingKey)
        guard let data else {
            AIAgentShortcutRun.trace("appGroup.consumePending missing")
            return nil
        }
        guard let payload = AIAgentShortcutRun.decode(data, now: now) else {
            AIAgentShortcutRun.trace(
                "appGroup.consumePending dropped bytes=\(data.count) (expired or empty titles)"
            )
            return nil
        }
        AIAgentShortcutRun.trace(
            "appGroup.consumePending ok skill=\(payload.skillID) items=\(payload.titles.count)"
        )
        return payload
    }

    private static func decodeAgentSkillLayout(
        from defaults: UserDefaults,
        userCatalog: AIUserSkillCatalog
    ) -> AIAgentSkillLayout {
        let catalog = AIClipboardSkillCatalog.all(userCatalog: userCatalog)
        guard let data = defaults.data(forKey: AppGroupConfiguration.Keys.agentSkillLayout) else {
            return .default
        }
        do {
            return try JSONDecoder().decode(AIAgentSkillLayout.self, from: data)
                .sanitized(catalog: catalog)
        } catch {
            OSGLog.config.warning("agentSkillLayout decode failed: \(error.localizedDescription, privacy: .public)")
            return .default
        }
    }

    private static func decodeUserSkillCatalog(from defaults: UserDefaults) -> AIUserSkillCatalog {
        guard let data = defaults.data(forKey: AppGroupConfiguration.Keys.agentUserSkillCatalog) else {
            return .empty
        }
        do {
            return try JSONDecoder().decode(AIUserSkillCatalog.self, from: data)
        } catch {
            OSGLog.config.warning(
                "agentUserSkillCatalog decode failed: \(error.localizedDescription, privacy: .public)"
            )
            return .empty
        }
    }

    public var hasCompletedOnboarding: Bool {
        get { configuration.hasCompletedOnboarding }
        set { setHasCompletedOnboarding(newValue) }
    }

    public var onboardingPage: Int {
        get { configuration.onboardingPage }
        set { setOnboardingPage(newValue) }
    }

    /// Commits onboarding to both the App Group and the reboot-durable
    /// Keychain marker; callers must preserve this dual-write invariant.
    public func setHasCompletedOnboarding(_ completed: Bool) {
        mutateConfiguration { config in
            config.hasCompletedOnboarding = completed
            if completed {
                config.onboardingPage = 0
            }
        }
        // Mirror to the reboot-durable Keychain marker (keyboard-side completion).
        Keychain.setOnboardingCompleted(completed)
    }

    public func setOnboardingPage(_ page: Int) {
        mutateConfiguration { $0.onboardingPage = page }
    }

    // MARK: - Detected app context

    public var detectedAppContext: (context: AppContext, observedAt: Date)? {
        configuration.detectedAppContext(from: defaults)
    }

    public func setDetectedAppContext(_ context: AppContext, at date: Date = Date()) {
        var config = configuration
        config.setDetectedAppContext(context, at: date, to: defaults)
    }

    // MARK: - Personal dictionary

    public var personalDictionary: PersonalDictionary {
        get { configuration.personalDictionary }
        set { setPersonalDictionary(newValue) }
    }

    public func setPersonalDictionary(_ dictionary: PersonalDictionary) {
        mutateConfiguration { $0.personalDictionary = dictionary }
        AppGroupConfigDarwin.postConfigChanged()
        #if os(iOS)
        // Host redeploys Rime sidecar; extension picks it up next typing open.
        PersonalDictionaryRimeSync.scheduleAfterDictionaryChange()
        #endif
    }

    public func deletePersonalDictionaryEntry(id: UUID, at date: Date = Date()) {
        mutateConfiguration { config in
            config.personalDictionary.entries.removeAll { $0.id == id }
            config.personalDictionary.deletedEntryIDs[id] = date
        }
        AppGroupConfigDarwin.postConfigChanged()
        #if os(iOS)
        PersonalDictionaryRimeSync.scheduleAfterDictionaryChange()
        #endif
    }

    public var personalDictionaryICloudSyncEnabled: Bool {
        get { configuration.personalDictionaryICloudSyncEnabled }
        set { setPersonalDictionaryICloudSyncEnabled(newValue) }
    }

    public func setPersonalDictionaryICloudSyncEnabled(_ enabled: Bool) {
        mutateConfiguration { $0.personalDictionaryICloudSyncEnabled = enabled }
    }

    public var settingsICloudSyncEnabled: Bool {
        get { configuration.settingsICloudSyncEnabled }
        set { setSettingsICloudSyncEnabled(newValue) }
    }

    public func setSettingsICloudSyncEnabled(_ enabled: Bool) {
        mutateConfiguration { $0.settingsICloudSyncEnabled = enabled }
    }

    /// Timestamp of the last settings blob applied from iCloud KVS.
    public var settingsCloudUpdatedAt: Date? {
        let raw = defaults.double(forKey: AppGroupConfiguration.Keys.settingsCloudUpdatedAt)
        guard raw > 0 else { return nil }
        return Date(timeIntervalSince1970: raw)
    }

    // MARK: - Client

    public func makeClient() -> LLMClient {
        configuration.makeClient()
    }
}