import AppKit
import Carbon
import Foundation

enum LauncherHotkeyValidationError: Equatable {
    case modifierRequired
    case unsupportedKey
    case reservedBySystem
    case duplicate

    var messageKey: String {
        switch self {
        case .modifierRequired:
            return "hotkeys.error.modifierRequired"
        case .unsupportedKey:
            return "hotkeys.error.unsupportedKey"
        case .reservedBySystem:
            return "hotkeys.error.reserved"
        case .duplicate:
            return "hotkeys.error.duplicate"
        }
    }
}

enum LauncherHotkeyCustomizationResult: Equatable {
    case saved
    case restored
    case locked
    case invalid(LauncherHotkeyValidationError)
    case registrationFailed(OSStatus)

    var messageKey: String {
        switch self {
        case .saved:
            return "hotkeys.saved"
        case .restored:
            return "hotkeys.restored"
        case .locked:
            return "hotkeys.proRequired"
        case .invalid(let error):
            return error.messageKey
        case .registrationFailed:
            return "hotkeys.error.registrationFailed"
        }
    }
}

enum LauncherHotkeySettings {
    private static let namespace = "customHotkeys.v1"
    private static let allowedModifierMask = UInt32(
        controlKey | optionKey | shiftKey | cmdKey | kEventKeyModifierFnMask
    )
    private static let functionKeyCodes: Set<Int> = [
        kVK_F1, kVK_F2, kVK_F3, kVK_F4, kVK_F5, kVK_F6,
        kVK_F7, kVK_F8, kVK_F9, kVK_F10, kVK_F11, kVK_F12
    ]

    static func defaultHotkey(for kind: LauncherHotkeyKind) -> LauncherHotkey {
        kind.hotkey
    }

    static func effectiveHotkey(for kind: LauncherHotkeyKind) -> LauncherHotkey {
        guard ProEntitlementPolicy.isUnlocked(.customHotkeys),
              let saved = savedHotkey(for: kind),
              structuralValidationError(for: saved) == nil,
              !duplicatesOtherEffectiveHotkey(saved, kind: kind)
        else {
            return defaultHotkey(for: kind)
        }
        return normalized(saved)
    }

    static func hasCustomHotkey(for kind: LauncherHotkeyKind) -> Bool {
        savedHotkey(for: kind) != nil
    }

    static func savedHotkey(for kind: LauncherHotkeyKind) -> LauncherHotkey? {
        let defaults = UserDefaults.standard
        guard defaults.object(forKey: keyCodeKey(for: kind)) != nil,
              defaults.object(forKey: modifiersKey(for: kind)) != nil
        else {
            return nil
        }
        let keyCode = defaults.integer(forKey: keyCodeKey(for: kind))
        let modifiers = defaults.integer(forKey: modifiersKey(for: kind))
        guard keyCode >= 0, modifiers >= 0 else { return nil }
        return LauncherHotkey(
            keyCode: UInt32(keyCode),
            modifiers: UInt32(modifiers) & allowedModifierMask
        )
    }

    static func save(_ hotkey: LauncherHotkey, for kind: LauncherHotkeyKind) {
        let defaults = UserDefaults.standard
        defaults.set(Int(hotkey.keyCode), forKey: keyCodeKey(for: kind))
        defaults.set(Int(hotkey.modifiers & allowedModifierMask), forKey: modifiersKey(for: kind))
        NotificationCenter.default.post(name: .tagLauncherHotkeyRegistrationChanged, object: nil)
    }

    static func clearCustomHotkey(for kind: LauncherHotkeyKind) {
        let defaults = UserDefaults.standard
        defaults.removeObject(forKey: keyCodeKey(for: kind))
        defaults.removeObject(forKey: modifiersKey(for: kind))
        NotificationCenter.default.post(name: .tagLauncherHotkeyRegistrationChanged, object: nil)
    }

    static func candidate(from event: NSEvent) -> LauncherHotkey {
        LauncherHotkey(
            keyCode: UInt32(event.keyCode),
            modifiers: carbonModifiers(from: event.modifierFlags)
        )
    }

    static func validationError(for hotkey: LauncherHotkey, kind: LauncherHotkeyKind) -> LauncherHotkeyValidationError? {
        let normalizedHotkey = normalized(hotkey)
        if let structuralError = structuralValidationError(for: normalizedHotkey) {
            return structuralError
        }
        if duplicatesOtherEffectiveHotkey(normalizedHotkey, kind: kind) {
            return .duplicate
        }
        return nil
    }

    private static func normalized(_ hotkey: LauncherHotkey) -> LauncherHotkey {
        LauncherHotkey(
            keyCode: hotkey.keyCode,
            modifiers: hotkey.modifiers & allowedModifierMask
        )
    }

    private static func structuralValidationError(for hotkey: LauncherHotkey) -> LauncherHotkeyValidationError? {
        guard isSupportedKey(hotkey.keyCode) else {
            return .unsupportedKey
        }
        guard hasSupportedModifierCombination(hotkey) else {
            return .modifierRequired
        }
        guard !isReservedBySystem(hotkey) else {
            return .reservedBySystem
        }
        return nil
    }

    private static func duplicatesOtherEffectiveHotkey(_ hotkey: LauncherHotkey, kind: LauncherHotkeyKind) -> Bool {
        let otherKind: LauncherHotkeyKind = kind == .main ? .quickSearch : .main
        return hotkey == effectiveHotkeyIgnoringDuplicateCheck(for: otherKind)
    }

    private static func effectiveHotkeyIgnoringDuplicateCheck(for kind: LauncherHotkeyKind) -> LauncherHotkey {
        guard ProEntitlementPolicy.isUnlocked(.customHotkeys),
              let saved = savedHotkey(for: kind),
              structuralValidationError(for: saved) == nil
        else {
            return defaultHotkey(for: kind)
        }
        return normalized(saved)
    }

    private static func keyCodeKey(for kind: LauncherHotkeyKind) -> String {
        "\(namespace).\(kind.rawValue).keyCode"
    }

    private static func modifiersKey(for kind: LauncherHotkeyKind) -> String {
        "\(namespace).\(kind.rawValue).modifiers"
    }

    private static func carbonModifiers(from flags: NSEvent.ModifierFlags) -> UInt32 {
        let normalized = flags.intersection(.deviceIndependentFlagsMask)
        var modifiers: UInt32 = 0
        if normalized.contains(.control) {
            modifiers |= UInt32(controlKey)
        }
        if normalized.contains(.option) {
            modifiers |= UInt32(optionKey)
        }
        if normalized.contains(.shift) {
            modifiers |= UInt32(shiftKey)
        }
        if normalized.contains(.command) {
            modifiers |= UInt32(cmdKey)
        }
        if normalized.contains(.function) {
            modifiers |= UInt32(kEventKeyModifierFnMask)
        }
        return modifiers & allowedModifierMask
    }

    private static func hasSupportedModifierCombination(_ hotkey: LauncherHotkey) -> Bool {
        let modifiers = hotkey.modifiers & allowedModifierMask
        guard modifiers != 0 else { return false }
        if modifiers == UInt32(shiftKey) {
            return false
        }
        if modifiers == UInt32(kEventKeyModifierFnMask) {
            return hotkey.keyCode == UInt32(kVK_Space)
        }
        return true
    }

    private static func isSupportedKey(_ keyCode: UInt32) -> Bool {
        switch Int(keyCode) {
        case kVK_Space, kVK_Return, kVK_Tab, kVK_Delete:
            return true
        case kVK_LeftArrow, kVK_RightArrow, kVK_UpArrow, kVK_DownArrow:
            return true
        default:
            let key = Int(keyCode)
            return functionKeyCodes.contains(key) || LauncherHotkey.printableKeyCodes.contains(key)
        }
    }

    private static func isReservedBySystem(_ hotkey: LauncherHotkey) -> Bool {
        let key = Int(hotkey.keyCode)
        let modifiers = hotkey.modifiers & allowedModifierMask
        let hasCommand = modifiers & UInt32(cmdKey) != 0
        let hasOption = modifiers & UInt32(optionKey) != 0
        let hasControl = modifiers & UInt32(controlKey) != 0

        if key == kVK_Space, hasCommand {
            return true
        }
        if key == kVK_Tab, hasCommand {
            return true
        }
        if key == kVK_Escape, hasCommand && hasOption {
            return true
        }
        if [kVK_ANSI_Q, kVK_ANSI_W, kVK_ANSI_H, kVK_ANSI_M].contains(key), hasCommand {
            return true
        }
        if [kVK_LeftArrow, kVK_RightArrow, kVK_UpArrow, kVK_DownArrow].contains(key), hasControl {
            return true
        }
        return false
    }
}