import Foundation

public struct QuickSwitchWindowItem: Equatable, Sendable {
    public let window: AlignerWindow
    public let primarySpaceID: UInt64?

    public init(window: AlignerWindow, primarySpaceID: UInt64?) {
        self.window = window
        self.primarySpaceID = primarySpaceID
    }
}

public struct QuickSwitchAppGroup: Equatable, Sendable {
    public let app: AlignerApp
    public let windows: [QuickSwitchWindowItem]

    public init(app: AlignerApp, windows: [QuickSwitchWindowItem]) {
        self.app = app
        self.windows = windows
    }
}

public struct QuickSwitchSnapshot: Equatable, Sendable {
    public let displays: [AlignerDisplay]
    public let appGroups: [QuickSwitchAppGroup]

    public init(displays: [AlignerDisplay], appGroups: [QuickSwitchAppGroup]) {
        self.displays = displays
        self.appGroups = appGroups
    }
}

public enum QuickSwitchSnapshotBuilder {
    public static func snapshot(
        displays: [AlignerDisplay],
        windows: [AlignerWindow]
    ) -> QuickSwitchSnapshot {
        let displayOrder = spaceOrder(from: displays)
        let candidateWindows = windows.filter(WindowDisplayPolicy.shouldDisplay)
        let groupedWindows = Dictionary(grouping: candidateWindows) {
            AppIdentity(app: $0.app)
        }

        let appGroups = groupedWindows.values.compactMap { windows -> QuickSwitchAppGroup? in
            guard let firstWindow = windows.first else { return nil }
            let sortedWindows = windows
                .sorted { lhs, rhs in
                    compareWindows(lhs, rhs, displayOrder: displayOrder)
                }
                .map { window in
                    QuickSwitchWindowItem(
                        window: window,
                        primarySpaceID: primarySpaceID(for: window, displayOrder: displayOrder)
                    )
                }

            return QuickSwitchAppGroup(app: firstWindow.app, windows: sortedWindows)
        }
        .sorted { lhs, rhs in
            compareApps(lhs.app, rhs.app)
        }

        return QuickSwitchSnapshot(displays: displays, appGroups: appGroups)
    }

    private static func spaceOrder(from displays: [AlignerDisplay]) -> [UInt64: Int] {
        var order: [UInt64: Int] = [:]
        var nextIndex = 0

        for display in displays.sorted(by: { $0.uuid.localizedStandardCompare($1.uuid) == .orderedAscending }) {
            for space in display.spaces.sorted(by: { $0.index < $1.index }) {
                order[space.id] = nextIndex
                nextIndex += 1
            }
        }

        return order
    }

    private static func compareApps(_ lhs: AlignerApp, _ rhs: AlignerApp) -> Bool {
        let nameOrder = lhs.name.localizedCaseInsensitiveCompare(rhs.name)
        if nameOrder != .orderedSame {
            return nameOrder == .orderedAscending
        }

        let bundleOrder = normalized(lhs.bundleIdentifier)
            .localizedCaseInsensitiveCompare(normalized(rhs.bundleIdentifier))
        if bundleOrder != .orderedSame {
            return bundleOrder == .orderedAscending
        }

        let pathOrder = normalized(lhs.executablePath)
            .localizedCaseInsensitiveCompare(normalized(rhs.executablePath))
        if pathOrder != .orderedSame {
            return pathOrder == .orderedAscending
        }

        return (lhs.processIdentifier ?? Int32.max) < (rhs.processIdentifier ?? Int32.max)
    }

    private static func compareWindows(
        _ lhs: AlignerWindow,
        _ rhs: AlignerWindow,
        displayOrder: [UInt64: Int]
    ) -> Bool {
        let lhsSpaceOrder = primarySpaceOrder(for: lhs, displayOrder: displayOrder)
        let rhsSpaceOrder = primarySpaceOrder(for: rhs, displayOrder: displayOrder)
        if lhsSpaceOrder != rhsSpaceOrder {
            return lhsSpaceOrder < rhsSpaceOrder
        }

        let titleOrder = lhs.title.localizedCaseInsensitiveCompare(rhs.title)
        if titleOrder != .orderedSame {
            return titleOrder == .orderedAscending
        }

        return lhs.id < rhs.id
    }

    private static func primarySpaceID(
        for window: AlignerWindow,
        displayOrder: [UInt64: Int]
    ) -> UInt64? {
        window.spaceIDs.min { lhs, rhs in
            (displayOrder[lhs] ?? Int.max) < (displayOrder[rhs] ?? Int.max)
        }
    }

    private static func primarySpaceOrder(
        for window: AlignerWindow,
        displayOrder: [UInt64: Int]
    ) -> Int {
        guard let primarySpaceID = primarySpaceID(for: window, displayOrder: displayOrder) else {
            return Int.max
        }

        return displayOrder[primarySpaceID] ?? Int.max
    }

    private static func normalized(_ value: String?) -> String {
        guard let value, !value.isEmpty else { return "\u{10FFFF}" }
        return value
    }
}

private struct AppIdentity: Hashable {
    let bundleIdentifier: String?
    let executablePath: String?
    let processIdentifier: Int32?
    let fallbackName: String

    init(app: AlignerApp) {
        self.bundleIdentifier = app.bundleIdentifier.isEmpty ? nil : app.bundleIdentifier
        self.executablePath = app.executablePath?.isEmpty == false ? app.executablePath : nil
        self.processIdentifier = app.processIdentifier
        self.fallbackName = app.name
    }
}