import AppKit
import CoreGraphics
import Darwin
import Foundation
import AlignerCore

final class CGEventTapTriggerProbe {
    enum ProbeError: Error, CustomStringConvertible {
        case eventTapUnavailable

        var description: String {
            switch self {
            case .eventTapUnavailable:
                return "CGEventTapCreate returned nil. Accessibility may be missing, or macOS may require a different trigger route."
            }
        }
    }

    private let shortcut: KeyboardShortcut
    private var eventTap: CFMachPort?
    private var runLoopSource: CFRunLoopSource?
    private(set) var capturedQuickSwitchCount = 0

    init(shortcut: KeyboardShortcut = TriggerDefaults.quickSwitchShortcut) {
        self.shortcut = shortcut
    }

    func start() throws {
        guard eventTap == nil else { return }

        let eventMask = CGEventMask(1 << CGEventType.keyDown.rawValue)
        guard let tap = CGEvent.tapCreate(
            tap: .cgSessionEventTap,
            place: .headInsertEventTap,
            options: .defaultTap,
            eventsOfInterest: eventMask,
            callback: Self.eventCallback,
            userInfo: Unmanaged.passUnretained(self).toOpaque()
        ) else {
            throw ProbeError.eventTapUnavailable
        }

        let source = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, tap, 0)
        CFRunLoopAddSource(CFRunLoopGetMain(), source, .commonModes)
        CGEvent.tapEnable(tap: tap, enable: true)

        eventTap = tap
        runLoopSource = source
    }

    func stop() {
        if let eventTap {
            CGEvent.tapEnable(tap: eventTap, enable: false)
        }
        if let runLoopSource {
            CFRunLoopRemoveSource(CFRunLoopGetMain(), runLoopSource, .commonModes)
        }

        runLoopSource = nil
        eventTap = nil
    }

    deinit {
        stop()
    }

    private func handle(event: CGEvent, type: CGEventType) -> Unmanaged<CGEvent>? {
        guard type == .keyDown else {
            return Unmanaged.passUnretained(event)
        }

        let receivedShortcut = KeyboardShortcut(
            keyCode: UInt16(event.getIntegerValueField(.keyboardEventKeycode)),
            modifiers: Self.shortcutModifiers(from: event.flags)
        )
        let decision = TriggerEventPolicy.decision(
            for: receivedShortcut,
            configuredQuickSwitch: shortcut,
            overlayVisible: false,
            consumeInitialQuickSwitch: true
        )

        switch decision {
        case .quickSwitch(let consumeEvent):
            capturedQuickSwitchCount += 1
            print("Round01 trigger probe captured Alt+Tab")
            fflush(stdout)
            return consumeEvent ? nil : Unmanaged.passUnretained(event)
        case .passThrough:
            return Unmanaged.passUnretained(event)
        }
    }

    private static let eventCallback: CGEventTapCallBack = { _, type, event, userInfo in
        guard let userInfo else {
            return Unmanaged.passUnretained(event)
        }

        let probe = Unmanaged<CGEventTapTriggerProbe>.fromOpaque(userInfo).takeUnretainedValue()
        return probe.handle(event: event, type: type)
    }

    private static func shortcutModifiers(from flags: CGEventFlags) -> ShortcutModifiers {
        var modifiers = ShortcutModifiers()

        if flags.contains(.maskAlternate) {
            modifiers.insert(.option)
        }
        if flags.contains(.maskCommand) {
            modifiers.insert(.command)
        }
        if flags.contains(.maskShift) {
            modifiers.insert(.shift)
        }
        if flags.contains(.maskControl) {
            modifiers.insert(.control)
        }

        return modifiers
    }
}

struct Round1TriggerProbeOptions {
    let enabled: Bool
    let quitAfter: TimeInterval?

    static func parse(arguments: [String]) -> Round1TriggerProbeOptions {
        Round1TriggerProbeOptions(
            enabled: arguments.contains("--round01-trigger-probe"),
            quitAfter: timeInterval(for: "--round01-trigger-probe-quit-after", in: arguments)
        )
    }

    private static func timeInterval(for key: String, in arguments: [String]) -> TimeInterval? {
        let prefix = "\(key)="
        guard let argument = arguments.first(where: { $0.hasPrefix(prefix) }) else {
            return nil
        }

        return TimeInterval(argument.dropFirst(prefix.count))
    }
}