import AppKit
import CoreGraphics
import Foundation
import SwiftUI
import MacToolsPluginKit

public final class DisplayBrightnessPluginFactory: NSObject, MacToolsPluginBundleFactory {
    public static func makeProvider(context: PluginRuntimeContext) throws -> any PluginProvider {
        DisplayBrightnessPluginProvider(context: context)
    }
}

@MainActor
private struct DisplayBrightnessPluginProvider: PluginProvider {
    let context: PluginRuntimeContext

    func makePlugins() -> [any MacToolsPlugin] {
        [
            DisplayBrightnessPlugin(
                localization: PluginLocalization(bundle: context.resourceBundle),
                shortcutPreferences: DisplayBrightnessShortcutPreferences(storage: context.storage)
            )
        ]
    }
}

enum DisplayBrightnessShortcutDirection: Equatable {
    case decrease
    case increase

    var actionID: String {
        switch self {
        case .decrease:
            return "display-brightness.decrease"
        case .increase:
            return "display-brightness.increase"
        }
    }

    func title(localization: PluginLocalization) -> String {
        switch self {
        case .decrease:
            return localization.string("shortcut.direction.decrease", defaultValue: "降低")
        case .increase:
            return localization.string("shortcut.direction.increase", defaultValue: "增加")
        }
    }

    var systemImage: String {
        switch self {
        case .decrease:
            return "sun.min.fill"
        case .increase:
            return "sun.max.fill"
        }
    }

    var multiplier: Double {
        switch self {
        case .decrease:
            return -1
        case .increase:
            return 1
        }
    }
}

struct DisplayBrightnessShortcutAction: Equatable {
    let id: String
    let direction: DisplayBrightnessShortcutDirection
    let targetDisplayIDs: [CGDirectDisplayID]
}

struct DisplayBrightnessShortcutAcceleration {
    private var lastPressDateByActionID: [String: Date] = [:]
    private var quickPressCountByActionID: [String: Int] = [:]

    mutating func stepForPress(actionID: String, now: Date, fastTapWindow: TimeInterval = 0.48) -> Int {
        let quickPressCount: Int
        if let lastPressDate = lastPressDateByActionID[actionID],
           now.timeIntervalSince(lastPressDate) <= fastTapWindow {
            quickPressCount = min((quickPressCountByActionID[actionID] ?? 0) + 1, 9)
        } else {
            quickPressCount = 0
        }

        quickPressCountByActionID[actionID] = quickPressCount
        lastPressDateByActionID[actionID] = now
        return min(10, 1 + quickPressCount)
    }

    static func stepForHold(elapsed: TimeInterval, baseline: Int) -> Int {
        let elapsedStep: Int
        switch elapsed {
        case ..<0.45:
            elapsedStep = 1
        case ..<0.9:
            elapsedStep = 2
        case ..<1.35:
            elapsedStep = 3
        case ..<1.8:
            elapsedStep = 4
        case ..<2.4:
            elapsedStep = 6
        case ..<3.2:
            elapsedStep = 8
        default:
            elapsedStep = 10
        }

        return min(10, max(baseline, elapsedStep))
    }
}

private struct DisplayBrightnessShortcutSession {
    let id: UUID
    let action: DisplayBrightnessShortcutAction
    let task: Task<Void, Never>
}

@MainActor
final class DisplayBrightnessPlugin: MacToolsPlugin, PluginPrimaryPanel, PluginShortcutEventHandling, DisplayTopologyRefreshing {
    private enum Constants {
        static let displayControlPrefix = "display."
        static let brightnessControlSuffix = ".brightness"
        static let disableBuiltInDisplayControlID = "built-in-display-disable"
        static let restoreBuiltInDisplayControlID = "built-in-display-restore"
        static let shortcutGroupID = "display-brightness.shortcuts"
    }

    let metadata: PluginMetadata

    let primaryPanelDescriptor = PluginPrimaryPanelDescriptor(
        controlStyle: .disclosure,
        menuActionBehavior: .keepPresented
    )

    var onStateChange: (() -> Void)?
    var requestPermissionGuidance: ((String) -> Void)?
    var shortcutBindingResolver: ((String) -> ShortcutBinding?)?

    private let controller: DisplayBrightnessControlling
    private let displayDisableCoordinator: any DisplayDisableCoordinating
    private let showsDisplayDisableControls: Bool
    private let shortcutPreferences: DisplayBrightnessShortcutPreferences
    private let mouseDisplayIDProvider: @MainActor () -> CGDirectDisplayID?
    private let localization: PluginLocalization
    private var isExpanded = false
    private var displayDisableActionTask: Task<Void, Never>?
    private var displayTopologyTask: Task<Void, Never>?
    private var shortcutAcceleration = DisplayBrightnessShortcutAcceleration()
    private var shortcutSessions: [String: DisplayBrightnessShortcutSession] = [:]

    init(
        controller: DisplayBrightnessControlling? = nil,
        localization: PluginLocalization = PluginLocalization(bundle: .main),
        displayDisableCoordinator: (any DisplayDisableCoordinating)? = nil,
        showsDisplayDisableControls: Bool = true,
        shortcutPreferences: DisplayBrightnessShortcutPreferences? = nil,
        mouseDisplayIDProvider: @escaping @MainActor () -> CGDirectDisplayID? = DisplayBrightnessPlugin.currentMouseDisplayID
    ) {
        self.localization = localization
        self.controller = controller ?? DisplayBrightnessController(localization: localization)
        self.displayDisableCoordinator = displayDisableCoordinator ?? DisplayDisableCoordinator(
            service: Self.defaultDisplayDisableService(),
            store: UserDefaultsDisplayDisableStateStore(),
            localization: localization
        )
        self.showsDisplayDisableControls = showsDisplayDisableControls
        self.shortcutPreferences = shortcutPreferences ?? DisplayBrightnessShortcutPreferences(
            storage: UserDefaultsPluginStorage(pluginID: "display-brightness")
        )
        self.mouseDisplayIDProvider = mouseDisplayIDProvider
        self.metadata = PluginMetadata(
            id: "display-brightness",
            title: localization.string("metadata.title", defaultValue: "显示器亮度"),
            iconName: "sun.max",
            iconTint: Color(nsColor: .systemYellow),
            order: 20,
            defaultDescription: localization.string(
                "metadata.description",
                defaultValue: "快速调节每个显示器的亮度"
            )
        )
        self.controller.onStateChange = { [weak self] in
            self?.onStateChange?()
        }
    }

    var primaryPanelState: PluginPanelState {
        let snapshot = controller.snapshot()

        guard !snapshot.displays.isEmpty else {
            isExpanded = false
            return PluginPanelState(
                subtitle: localization.string(
                    "panel.subtitle.noDisplays",
                    defaultValue: "未检测到可调节亮度的显示器"
                ),
                isOn: false,
                isExpanded: false,
                isEnabled: false,
                isVisible: true,
                detail: nil,
                errorMessage: snapshot.errorMessage
            )
        }

        return PluginPanelState(
            subtitle: subtitle(for: snapshot.displays),
            isOn: false,
            isExpanded: isExpanded,
            isEnabled: true,
            isVisible: true,
            detail: isExpanded ? buildDetail(for: snapshot.displays) : nil,
            errorMessage: snapshot.errorMessage
        )
    }

    var permissionRequirements: [PluginPermissionRequirement] { [] }
    var settingsSections: [PluginSettingsSection] { [] }
    var configuration: PluginConfiguration? {
        PluginConfiguration(description: metadata.defaultDescription) { [shortcutPreferences, localization] _ in
            DisplayBrightnessSettingsView(
                preferences: shortcutPreferences,
                localization: localization
            )
        }
    }

    var shortcutDefinitions: [PluginShortcutDefinition] {
        [
            shortcutDefinition(direction: .decrease),
            shortcutDefinition(direction: .increase)
        ]
    }

    func refresh() {
        controller.refresh()
        displayDisableCoordinator.refreshSnapshot()
    }

    func refreshDisplayTopology() {
        controller.refresh()
        let coordinator = displayDisableCoordinator
        displayTopologyTask?.cancel()
        displayTopologyTask = Task { @MainActor [weak self, coordinator] in
            await coordinator.reconcileTopology()
            self?.onStateChange?()
        }
    }

    func handleAction(_ action: PluginPanelAction) {
        switch action {
        case let .setDisclosureExpanded(value):
            isExpanded = value
            onStateChange?()
        case let .setSlider(controlID, value, phase):
            guard let displayID = Self.parseDisplayID(from: controlID) else {
                DisplayBrightnessLog.plugin.error(
                    "invalid slider control id \(controlID, privacy: .public)"
                )
                return
            }

            controller.setBrightness(value, for: displayID, phase: phase)
            onStateChange?()
        case let .invokeAction(controlID):
            handleInvokeAction(controlID: controlID)
        case .setSwitch,
             .setSelection,
             .setNavigationSelection,
             .clearNavigationSelection,
             .setDate:
            return
        }
    }

    func permissionState(for permissionID: String) -> PluginPermissionState {
        PluginPermissionState(isGranted: true, footnote: nil)
    }

    func handlePermissionAction(id: String) {}
    func handleSettingsAction(id: String) {}
    func handleShortcutAction(id: String) {
        handleShortcutEvent(id: id, phase: .pressed)
    }

    func handleShortcutEvent(id: String, phase: PluginShortcutEventPhase) {
        switch phase {
        case .pressed:
            startShortcutAction(id: id)
        case .released:
            stopShortcutAction(id: id)
        }
    }

    func deactivate(reason: PluginDeactivationReason) {
        displayDisableActionTask?.cancel()
        displayTopologyTask?.cancel()
        stopAllShortcutActions()
        guard reason.requiresStateCleanup else { return }
        displayDisableCoordinator.restoreBuiltInDisplay()
    }

    static func parseDisplayID(from controlID: String) -> CGDirectDisplayID? {
        guard
            controlID.hasPrefix(Constants.displayControlPrefix),
            controlID.hasSuffix(Constants.brightnessControlSuffix)
        else {
            return nil
        }

        let startIndex = controlID.index(
            controlID.startIndex,
            offsetBy: Constants.displayControlPrefix.count
        )
        let endIndex = controlID.index(
            controlID.endIndex,
            offsetBy: -Constants.brightnessControlSuffix.count
        )
        return CGDirectDisplayID(controlID[startIndex..<endIndex])
    }

    private func subtitle(for displays: [DisplayBrightnessDisplay]) -> String {
        if displays.count == 1, let display = displays.first {
            return "\(display.display.name) \(Self.percentText(for: display.brightness))"
        }

        return localization.format("panel.subtitle.displayCountFormat", defaultValue: "%d 个显示器", displays.count)
    }

    private func buildDetail(for displays: [DisplayBrightnessDisplay]) -> PluginPanelDetail {
        let brightnessControls = displays.map { display in
            PluginPanelControl(
                id: "\(Constants.displayControlPrefix)\(display.display.id)\(Constants.brightnessControlSuffix)",
                kind: .slider,
                options: [],
                selectedOptionID: nil,
                dateValue: nil,
                minimumDate: nil,
                displayedComponents: nil,
                datePickerStyle: nil,
                sectionTitle: display.display.name,
                sliderValue: display.brightness,
                sliderBounds: 0...1,
                sliderStep: 0.01,
                valueLabel: Self.percentText(for: display.brightness),
                isEnabled: true
            )
        }

        return PluginPanelDetail(
            primaryControls: brightnessControls + displayDisableControls(),
            secondaryPanel: nil
        )
    }

    private func displayDisableControls() -> [PluginPanelControl] {
        guard showsDisplayDisableControls else {
            return []
        }

        let snapshot = displayDisableCoordinator.snapshot
        switch snapshot.status {
        case .unsupported:
            return [displayDisableActionControl(
                id: Constants.disableBuiltInDisplayControlID,
                title: localization.string(
                    "displayDisable.action.disable",
                    defaultValue: "关闭内建显示屏"
                ),
                iconName: "display",
                isEnabled: false
            )]
        case .unavailable:
            var controls = [displayDisableActionControl(
                id: Constants.disableBuiltInDisplayControlID,
                title: localization.string(
                    "displayDisable.action.disable",
                    defaultValue: "关闭内建显示屏"
                ),
                iconName: "display",
                isEnabled: false
            )]
            if snapshot.isRestoreAllowed {
                controls.append(displayDisableActionControl(
                    id: Constants.restoreBuiltInDisplayControlID,
                    title: localization.string(
                        "displayDisable.action.restore",
                        defaultValue: "恢复内建显示屏"
                    ),
                    iconName: "display",
                    isEnabled: true
                ))
            }
            return controls
        case .disabled:
            return [displayDisableActionControl(
                id: Constants.restoreBuiltInDisplayControlID,
                title: localization.string(
                    "displayDisable.action.restore",
                    defaultValue: "恢复内建显示屏"
                ),
                iconName: "display",
                isEnabled: snapshot.isRestoreAllowed
            )]
        case .available, .failed, .busy:
            var controls: [PluginPanelControl] = []
            controls.append(displayDisableActionControl(
                id: Constants.disableBuiltInDisplayControlID,
                title: localization.string(
                    "displayDisable.action.disable",
                    defaultValue: "关闭内建显示屏"
                ),
                iconName: "display",
                isEnabled: snapshot.isDisableAllowed
            ))
            if snapshot.isRestoreAllowed {
                controls.append(displayDisableActionControl(
                    id: Constants.restoreBuiltInDisplayControlID,
                    title: localization.string(
                        "displayDisable.action.restore",
                        defaultValue: "恢复内建显示屏"
                    ),
                    iconName: "display",
                    isEnabled: true
                ))
            }
            return controls
        }
    }

    private func displayDisableActionControl(
        id: String,
        title: String,
        iconName: String,
        isEnabled: Bool
    ) -> PluginPanelControl {
        PluginPanelControl(
            id: id,
            kind: .actionRow,
            options: [],
            selectedOptionID: nil,
            dateValue: nil,
            minimumDate: nil,
            displayedComponents: nil,
            datePickerStyle: nil,
            sectionTitle: nil,
            actionTitle: title,
            actionIconSystemName: iconName,
            showsLeadingDivider: true,
            isEnabled: isEnabled
        )
    }

    private func handleInvokeAction(controlID: String) {
        switch controlID {
        case Constants.disableBuiltInDisplayControlID:
            displayDisableActionTask?.cancel()
            let coordinator = displayDisableCoordinator
            displayDisableActionTask = Task { @MainActor [weak self, coordinator] in
                await coordinator.disableBuiltInDisplay()
                self?.onStateChange?()
            }
        case Constants.restoreBuiltInDisplayControlID:
            displayDisableActionTask?.cancel()
            displayDisableCoordinator.restoreBuiltInDisplay()
            onStateChange?()
        default:
            return
        }
    }

    private static func percentText(for brightness: Double) -> String {
        "\(Int((brightness * 100).rounded()))%"
    }

    private static func defaultDisplayDisableService() -> any DisplayDisableServicing {
        SystemDisplayDisableService()
    }

    private func shortcutDefinition(direction: DisplayBrightnessShortcutDirection) -> PluginShortcutDefinition {
        let actionID = direction.actionID
        let directionTitle = direction.title(localization: localization)

        return PluginShortcutDefinition(
            id: actionID,
            title: localization.format("shortcut.titleFormat", defaultValue: "%@亮度", directionTitle),
            description: localization.format("shortcut.descriptionFormat", defaultValue: "%@显示器亮度。", directionTitle),
            actionID: actionID,
            scope: .global,
            defaultBinding: nil,
            isRequired: false,
            settingsGroupID: Constants.shortcutGroupID,
            settingsGroupTitle: localization.string(
                "shortcut.settingsGroupTitle",
                defaultValue: "亮度快捷键"
            ),
            settingsGroupDescription: localization.string(
                "shortcut.settingsGroupDescription",
                defaultValue: "按所选作用范围调整显示器亮度。"
            ),
            settingsControlTitle: directionTitle,
            settingsControlSystemImage: direction.systemImage
        )
    }

    private func startShortcutAction(id: String) {
        guard shortcutSessions[id] == nil,
              let direction = Self.shortcutDirection(for: id)
        else {
            return
        }

        var snapshot = controller.snapshot()
        if snapshot.displays.isEmpty {
            controller.refresh()
            snapshot = controller.snapshot()
        }

        let targetDisplayIDs = shortcutTargetDisplayIDs(in: snapshot)
        guard !targetDisplayIDs.isEmpty else {
            return
        }

        let action = DisplayBrightnessShortcutAction(
            id: id,
            direction: direction,
            targetDisplayIDs: targetDisplayIDs
        )
        let now = Date()
        let initialStep = shortcutAcceleration.stepForPress(actionID: id, now: now)
        applyShortcutAction(action, step: initialStep, phase: .changed)
        scheduleShortcutRepeats(for: action, initialStep: initialStep, startDate: now)
    }

    private func stopShortcutAction(id: String) {
        guard let session = shortcutSessions.removeValue(forKey: id) else {
            return
        }

        session.task.cancel()
        commitShortcutAction(session.action)
    }

    private func stopAllShortcutActions() {
        for session in shortcutSessions.values {
            session.task.cancel()
        }
        shortcutSessions.removeAll()
    }

    private func scheduleShortcutRepeats(
        for action: DisplayBrightnessShortcutAction,
        initialStep: Int,
        startDate: Date
    ) {
        let sessionID = UUID()
        let task = Task { @MainActor [weak self] in
            await Self.sleep(seconds: Self.initialHoldDelay)
            var repeatCount = 0

            while !Task.isCancelled {
                guard let self,
                      self.shortcutSessions[action.id]?.id == sessionID
                else {
                    return
                }

                guard repeatCount < Self.maximumHoldRepeatCount else {
                    self.stopShortcutAction(id: action.id)
                    return
                }

                let elapsed = Date().timeIntervalSince(startDate)
                let step = DisplayBrightnessShortcutAcceleration.stepForHold(
                    elapsed: elapsed,
                    baseline: initialStep
                )
                self.applyShortcutAction(action, step: step, phase: .changed)
                repeatCount += 1
                await Self.sleep(seconds: Self.repeatDelay)
            }
        }

        shortcutSessions[action.id] = DisplayBrightnessShortcutSession(
            id: sessionID,
            action: action,
            task: task
        )
    }

    private func applyShortcutAction(
        _ action: DisplayBrightnessShortcutAction,
        step: Int,
        phase: PluginPanelAction.SliderPhase
    ) {
        let delta = Double(step) / 100 * action.direction.multiplier
        for display in displays(for: action.targetDisplayIDs) {
            controller.setBrightness(display.brightness + delta, for: display.id, phase: phase)
        }
    }

    private func commitShortcutAction(_ action: DisplayBrightnessShortcutAction) {
        for display in displays(for: action.targetDisplayIDs) {
            controller.setBrightness(display.brightness, for: display.id, phase: .ended)
        }
    }

    private func displays(for displayIDs: [CGDirectDisplayID]) -> [DisplayBrightnessDisplay] {
        let displaysByID = Dictionary(uniqueKeysWithValues: controller.snapshot().displays.map { ($0.id, $0) })
        return displayIDs.compactMap { displaysByID[$0] }
    }

    private func shortcutTargetDisplayIDs(in snapshot: DisplayBrightnessSnapshot) -> [CGDirectDisplayID] {
        switch shortcutPreferences.targetMode {
        case .followsMouse:
            if let mouseDisplayID = mouseDisplayIDProvider(),
               snapshot.displays.contains(where: { $0.id == mouseDisplayID }) {
                return [mouseDisplayID]
            }

            if let mainDisplay = snapshot.displays.first(where: { $0.display.isMain }) {
                return [mainDisplay.id]
            }

            return snapshot.displays.first.map { [$0.id] } ?? []
        case .allDisplays:
            return snapshot.displays.map(\.id)
        }
    }

    private static var initialHoldDelay: TimeInterval {
        systemKeyboardTiming(
            key: "InitialKeyRepeat",
            fallback: 25,
            minimum: 0.22,
            maximum: 0.55
        )
    }

    private static var repeatDelay: TimeInterval {
        systemKeyboardTiming(
            key: "KeyRepeat",
            fallback: 6,
            minimum: 0.075,
            maximum: 0.16
        )
    }

    private static var maximumHoldRepeatCount: Int { 100 }

    private static func systemKeyboardTiming(
        key: String,
        fallback: Double,
        minimum: TimeInterval,
        maximum: TimeInterval
    ) -> TimeInterval {
        let rawValue = UserDefaults.standard.object(forKey: key) as? Double ?? fallback
        return min(max(rawValue * 0.014, minimum), maximum)
    }

    private static func sleep(seconds: TimeInterval) async {
        let nanoseconds = UInt64(max(0, seconds) * 1_000_000_000)
        try? await Task.sleep(nanoseconds: nanoseconds)
    }

    static func shortcutDirection(for actionID: String) -> DisplayBrightnessShortcutDirection? {
        switch actionID {
        case DisplayBrightnessShortcutDirection.decrease.actionID:
            return .decrease
        case DisplayBrightnessShortcutDirection.increase.actionID:
            return .increase
        default:
            return nil
        }
    }

    private static func currentMouseDisplayID() -> CGDirectDisplayID? {
        let mouseLocation = NSEvent.mouseLocation
        guard let screen = NSScreen.screens.first(where: { $0.frame.contains(mouseLocation) }) else {
            return nil
        }

        return displayID(for: screen)
    }

    private static func displayID(for screen: NSScreen) -> CGDirectDisplayID? {
        guard let screenNumber = screen.deviceDescription[NSDeviceDescriptionKey("NSScreenNumber")] as? NSNumber else {
            return nil
        }

        return screenNumber.uint32Value
    }
}