import AppKit
import Foundation
import QuartzCore
import AlignerCore

@MainActor
final class Round1PerformancePoCController {
    static let overlayTitle = "Aligner Round01 Performance PoC"

    private let view = Round1PerformancePoCView()
    private lazy var coordinator = WindowCoordinator(
        contentView: view,
        title: Self.overlayTitle
    )
    private var autoCycleTimer: Timer?
    private var lifecycleTargetCycles = 0
    private var lifecycleCompletedCycles = 0
    private var lifecycleMaximumOverlayWindows = 0
    private var lifecycleMaximumVisibleOverlayWindows = 0
    private var lifecycleResidualOverlayWindows = 0
    private var lifecycleResidualVisibleOverlayWindows = 0

    func show(autoCycle: Bool) {
        view.onEscape = { [weak self] in
            self?.hide(reason: .escape)
        }
        view.beginFirstFrameMeasurement()
        coordinator.openQuickSwitch()
        coordinator.promoteForTextInput()
        view.window?.makeFirstResponder(view)
        view.layoutSubtreeIfNeeded()
        DispatchQueue.main.async { [weak view] in
            view?.recordFirstFrameIfNeeded()
        }
        view.startSimulatedScreenshotRefill()
        updateLifecycleWindowHighWaterMark()

        if autoCycle {
            startAutoCycle()
        }
    }

    func hide() {
        hide(reason: .userClosed)
    }

    func reportDictionary() -> [String: Any] {
        var report = view.reportDictionary()
        report["overlayVisible"] = coordinator.isQuickSwitchVisible
        report["overlayWindowCount"] = overlayWindowCount()
        report["visibleOverlayWindowCount"] = visibleOverlayWindowCount()
        report["lifecycleTargetCycles"] = lifecycleTargetCycles
        report["lifecycleCompletedCycles"] = lifecycleCompletedCycles
        report["lifecycleMaximumOverlayWindows"] = lifecycleMaximumOverlayWindows
        report["lifecycleMaximumVisibleOverlayWindows"] = lifecycleMaximumVisibleOverlayWindows
        report["lifecycleResidualOverlayWindows"] = lifecycleResidualOverlayWindows
        report["lifecycleResidualVisibleOverlayWindows"] = lifecycleResidualVisibleOverlayWindows
        report["lifecycleGatePassed"] = lifecycleTargetCycles == 0
            || (
                lifecycleCompletedCycles == lifecycleTargetCycles
                    && lifecycleMaximumOverlayWindows <= 1
                    && lifecycleMaximumVisibleOverlayWindows <= 1
                    && lifecycleResidualOverlayWindows <= 1
                    && lifecycleResidualVisibleOverlayWindows == 0
            )
        return report
    }

    func prepareLifecycleRun(targetCycles: Int) {
        lifecycleTargetCycles = max(0, targetCycles)
        lifecycleCompletedCycles = 0
        lifecycleMaximumOverlayWindows = 0
        lifecycleMaximumVisibleOverlayWindows = 0
        lifecycleResidualOverlayWindows = 0
        lifecycleResidualVisibleOverlayWindows = 0
        view.resetPerformanceMeasurements()
    }

    func markLifecycleCycleCompleted() {
        lifecycleCompletedCycles += 1
        updateLifecycleWindowHighWaterMark()
    }

    func finalizeLifecycleRun() {
        lifecycleResidualOverlayWindows = overlayWindowCount()
        lifecycleResidualVisibleOverlayWindows = visibleOverlayWindowCount()
        updateLifecycleWindowHighWaterMark()
    }

    private func hide(reason: DismissReason) {
        stopAutoCycle()
        view.stopSimulatedScreenshotRefill()
        coordinator.closeQuickSwitch(reason: reason)
        lifecycleResidualOverlayWindows = overlayWindowCount()
        lifecycleResidualVisibleOverlayWindows = visibleOverlayWindowCount()
    }

    private func startAutoCycle() {
        stopAutoCycle()
        autoCycleTimer = Timer.scheduledTimer(withTimeInterval: 0.05, repeats: true) { [weak self] _ in
            Task { @MainActor in
                guard let self else { return }
                self.view.moveSelection(delta: 1)
                self.view.simulateHoverStep(delta: 7)
            }
        }
    }

    private func stopAutoCycle() {
        autoCycleTimer?.invalidate()
        autoCycleTimer = nil
    }

    private func updateLifecycleWindowHighWaterMark() {
        lifecycleMaximumOverlayWindows = max(
            lifecycleMaximumOverlayWindows,
            overlayWindowCount()
        )
        lifecycleMaximumVisibleOverlayWindows = max(
            lifecycleMaximumVisibleOverlayWindows,
            visibleOverlayWindowCount()
        )
    }

    private func overlayWindowCount() -> Int {
        NSApp.windows.filter { window in
            window.title == Self.overlayTitle
        }.count
    }

    private func visibleOverlayWindowCount() -> Int {
        NSApp.windows.filter { window in
            window.title == Self.overlayTitle && window.isVisible
        }.count
    }
}

struct Round1PerformancePoCOptions {
    let showPerformancePoC: Bool
    let autoCycle: Bool
    let autoHideAfter: TimeInterval?
    let quitAfter: TimeInterval?
    let reportPath: String?
    let lifecycleCycles: Int?
    let lifecycleInterval: TimeInterval
    let lifecycleVisibleDuration: TimeInterval

    static func parse(arguments: [String]) -> Round1PerformancePoCOptions {
        Round1PerformancePoCOptions(
            showPerformancePoC: arguments.contains("--round01-performance-poc")
                || arguments.contains("--round1-performance-poc"),
            autoCycle: arguments.contains("--round01-poc-auto-cycle")
                || arguments.contains("--round1-poc-auto-cycle"),
            autoHideAfter: timeInterval(for: "--round01-poc-auto-hide-after", in: arguments)
                ?? timeInterval(for: "--round1-poc-auto-hide-after", in: arguments),
            quitAfter: timeInterval(for: "--round01-poc-quit-after", in: arguments)
                ?? timeInterval(for: "--round1-poc-quit-after", in: arguments),
            reportPath: stringValue(for: "--round01-poc-report", in: arguments)
                ?? stringValue(for: "--round1-poc-report", in: arguments),
            lifecycleCycles: intValue(for: "--round01-poc-lifecycle-cycles", in: arguments)
                ?? intValue(for: "--round1-poc-lifecycle-cycles", in: arguments),
            lifecycleInterval: timeInterval(for: "--round01-poc-lifecycle-interval", in: arguments)
                ?? timeInterval(for: "--round1-poc-lifecycle-interval", in: arguments)
                ?? 0.03,
            lifecycleVisibleDuration: timeInterval(for: "--round01-poc-lifecycle-visible-duration", in: arguments)
                ?? timeInterval(for: "--round1-poc-lifecycle-visible-duration", in: arguments)
                ?? 0.24
        )
    }

    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))
    }

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

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

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

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

@MainActor
private final class Round1PerformancePoCView: NSView {
    private static let cardCount = 200
    private static let appCount = 20

    private let backgroundLayer = CAGradientLayer()
    private let appShelfLayer = CALayer()
    private let waterfallLayer = CALayer()
    private let spotlightLayer = CAGradientLayer()
    private var cardLayers: [CALayer] = []
    private var thumbnailLayers: [CALayer] = []
    private var appLayers: [CALayer] = []
    private var trackingArea: NSTrackingArea?
    private var selectedIndex = 0
    private var hoveredIndex: Int?
    private var scrollOffset: CGFloat = 0
    private var scrollAdjustmentCount = 0
    private var simulatedScreenshotRefillCount = 0
    private var firstFrameMeasurementStart: CFTimeInterval?
    private var firstFrameLatencyMilliseconds: [Double] = []
    private var keyboardResponseLatencyMilliseconds: [Double] = []
    private var hoverResponseLatencyMilliseconds: [Double] = []
    private var screenshotRefillTask: Task<Void, Never>?
    var onEscape: (() -> Void)?

    override init(frame frameRect: NSRect) {
        super.init(frame: frameRect)
        wantsLayer = true
        setupLayers()
    }

    required init?(coder: NSCoder) {
        super.init(coder: coder)
        wantsLayer = true
        setupLayers()
    }

    override var acceptsFirstResponder: Bool {
        true
    }

    override func updateTrackingAreas() {
        super.updateTrackingAreas()

        if let trackingArea {
            removeTrackingArea(trackingArea)
        }

        let area = NSTrackingArea(
            rect: bounds,
            options: [.mouseMoved, .activeAlways, .inVisibleRect],
            owner: self
        )
        addTrackingArea(area)
        trackingArea = area
    }

    override func layout() {
        super.layout()
        layoutLayers()
    }

    override func mouseMoved(with event: NSEvent) {
        let point = convert(event.locationInWindow, from: nil)
        guard let index = cardLayers.firstIndex(where: { $0.frame.offsetBy(dx: 0, dy: scrollOffset).contains(point) }) else { return }
        hoverCard(at: index, animated: true)
        selectCard(at: index)
    }

    override func keyDown(with event: NSEvent) {
        switch event.keyCode {
        case 48, 124, 125:
            moveSelection(delta: 1)
        case 123, 126:
            moveSelection(delta: -1)
        case 53:
            onEscape?()
        default:
            super.keyDown(with: event)
        }
    }

    override func scrollWheel(with event: NSEvent) {
        setScrollOffset(scrollOffset - event.scrollingDeltaY, animated: true)
    }

    func moveSelection(delta: Int) {
        guard !cardLayers.isEmpty else { return }
        let measurementStart = CACurrentMediaTime()
        let nextIndex = min(max(selectedIndex + delta, 0), cardLayers.count - 1)
        selectCard(at: nextIndex)
        CATransaction.flush()
        keyboardResponseLatencyMilliseconds.append(milliseconds(since: measurementStart))
    }

    func simulateHoverStep(delta: Int) {
        guard !cardLayers.isEmpty else { return }
        let baseIndex = hoveredIndex ?? selectedIndex
        let nextIndex = (baseIndex + delta) % cardLayers.count
        let measurementStart = CACurrentMediaTime()
        hoverCard(at: nextIndex, animated: true)
        selectCard(at: nextIndex)
        CATransaction.flush()
        hoverResponseLatencyMilliseconds.append(milliseconds(since: measurementStart))
    }

    func startSimulatedScreenshotRefill() {
        stopSimulatedScreenshotRefill()
        simulatedScreenshotRefillCount = 0
        screenshotRefillTask = Task { @MainActor [weak self] in
            guard let self else { return }
            let batchSize = 20
            for startIndex in stride(from: 0, to: self.thumbnailLayers.count, by: batchSize) {
                if Task.isCancelled { return }
                let endIndex = min(startIndex + batchSize, self.thumbnailLayers.count)
                self.refillSimulatedScreenshots(in: startIndex..<endIndex)
                try? await Task.sleep(nanoseconds: 20_000_000)
            }
        }
    }

    func stopSimulatedScreenshotRefill() {
        screenshotRefillTask?.cancel()
        screenshotRefillTask = nil
    }

    func beginFirstFrameMeasurement() {
        firstFrameMeasurementStart = CACurrentMediaTime()
    }

    func recordFirstFrameIfNeeded() {
        guard let firstFrameMeasurementStart else { return }

        CATransaction.flush()
        firstFrameLatencyMilliseconds.append(milliseconds(since: firstFrameMeasurementStart))
        self.firstFrameMeasurementStart = nil
    }

    func resetPerformanceMeasurements() {
        firstFrameMeasurementStart = nil
        firstFrameLatencyMilliseconds = []
        keyboardResponseLatencyMilliseconds = []
        hoverResponseLatencyMilliseconds = []
    }

    func reportDictionary() -> [String: Any] {
        let firstFrameP95 = percentile95(firstFrameLatencyMilliseconds)
        let keyboardP95 = percentile95(keyboardResponseLatencyMilliseconds)
        let hoverP95 = percentile95(hoverResponseLatencyMilliseconds)
        let firstFrameGatePassed = firstFrameP95.map { $0 < 150 } ?? false
        let keyboardGatePassed = keyboardP95.map { $0 < 50 } ?? false
        let hoverGatePassed = hoverP95.map { $0 <= 32 } ?? false
        let interactionPerformanceGatePassed = firstFrameGatePassed && keyboardGatePassed && hoverGatePassed

        return [
            "cardCount": Self.cardCount,
            "appCount": Self.appCount,
            "cardLayerCount": cardLayers.count,
            "appLayerCount": appLayers.count,
            "thumbnailLayerCount": thumbnailLayers.count,
            "simulatedScreenshotRefillCount": simulatedScreenshotRefillCount,
            "selectedIndex": selectedIndex,
            "scrollOffset": Double(scrollOffset),
            "maximumScrollOffset": Double(maximumScrollOffset()),
            "scrollAdjustmentCount": scrollAdjustmentCount,
            "waterfallScrollable": maximumScrollOffset() > 0,
            "spotlightVisible": spotlightLayer.opacity > 0,
            "spotlightAlignedWithSelectedCard": spotlightLayer.frame.equalTo(
                cardLayers[selectedIndex].frame.insetBy(dx: -10, dy: -8)
            ),
            "firstFrameLatencySampleCount": firstFrameLatencyMilliseconds.count,
            "firstFrameLatencyP95Milliseconds": jsonNumber(firstFrameP95),
            "firstFrameLatencyMaxMilliseconds": jsonNumber(firstFrameLatencyMilliseconds.max()),
            "keyboardResponseSampleCount": keyboardResponseLatencyMilliseconds.count,
            "keyboardResponseP95Milliseconds": jsonNumber(keyboardP95),
            "keyboardResponseMaxMilliseconds": jsonNumber(keyboardResponseLatencyMilliseconds.max()),
            "hoverResponseSampleCount": hoverResponseLatencyMilliseconds.count,
            "hoverResponseP95Milliseconds": jsonNumber(hoverP95),
            "hoverResponseMaxMilliseconds": jsonNumber(hoverResponseLatencyMilliseconds.max()),
            "performanceThresholds": [
                "firstFrameMilliseconds": 150,
                "keyboardP95Milliseconds": 50,
                "hoverP95Milliseconds": 32
            ],
            "interactionPerformanceGatePassed": interactionPerformanceGatePassed,
            "performanceGatePassed": interactionPerformanceGatePassed
        ]
    }

    private func setupLayers() {
        guard let rootLayer = layer else { return }

        rootLayer.masksToBounds = true
        backgroundLayer.colors = [
            NSColor.windowBackgroundColor.withAlphaComponent(0.92).cgColor,
            NSColor.controlBackgroundColor.withAlphaComponent(0.84).cgColor
        ]
        backgroundLayer.startPoint = CGPoint(x: 0.5, y: 1.0)
        backgroundLayer.endPoint = CGPoint(x: 0.5, y: 0.0)
        rootLayer.addSublayer(backgroundLayer)

        rootLayer.addSublayer(appShelfLayer)
        rootLayer.addSublayer(waterfallLayer)

        appLayers = (0..<Self.appCount).map { index in
            let appLayer = CALayer()
            appLayer.cornerRadius = 12
            appLayer.backgroundColor = appColor(index: index).cgColor
            appLayer.shadowColor = NSColor.black.cgColor
            appLayer.shadowOpacity = 0.18
            appLayer.shadowRadius = 8
            appLayer.shadowOffset = CGSize(width: 0, height: -1)
            appShelfLayer.addSublayer(appLayer)
            return appLayer
        }

        let cardsAndThumbnails: [(CALayer, CALayer)] = (0..<Self.cardCount).map { index in
            let cardLayer = CALayer()
            cardLayer.cornerRadius = 14
            cardLayer.backgroundColor = cardColor(index: index).cgColor
            cardLayer.borderColor = NSColor.separatorColor.withAlphaComponent(0.3).cgColor
            cardLayer.borderWidth = 1
            cardLayer.shadowColor = NSColor.black.cgColor
            cardLayer.shadowOpacity = 0.0
            cardLayer.shadowRadius = 0
            cardLayer.shadowOffset = CGSize(width: 0, height: -2)

            let thumbnailLayer = CALayer()
            thumbnailLayer.cornerRadius = 9
            thumbnailLayer.backgroundColor = NSColor.quaternaryLabelColor.withAlphaComponent(0.28).cgColor
            thumbnailLayer.borderColor = NSColor.separatorColor.withAlphaComponent(0.2).cgColor
            thumbnailLayer.borderWidth = 1
            cardLayer.addSublayer(thumbnailLayer)

            waterfallLayer.addSublayer(cardLayer)
            return (cardLayer, thumbnailLayer)
        }
        cardLayers = cardsAndThumbnails.map(\.0)
        thumbnailLayers = cardsAndThumbnails.map(\.1)

        spotlightLayer.colors = [
            NSColor.clear.cgColor,
            NSColor.white.withAlphaComponent(0.28).cgColor,
            NSColor.clear.cgColor
        ]
        spotlightLayer.locations = [0, 0.5, 1]
        spotlightLayer.startPoint = CGPoint(x: 0, y: 0.5)
        spotlightLayer.endPoint = CGPoint(x: 1, y: 0.5)
        spotlightLayer.opacity = 0
        waterfallLayer.addSublayer(spotlightLayer)
        selectCard(at: 0, animated: false)
    }

    private func layoutLayers() {
        CATransaction.begin()
        CATransaction.setDisableActions(true)

        backgroundLayer.frame = bounds
        appShelfLayer.frame = CGRect(x: 0, y: bounds.height - 108, width: bounds.width, height: 92)
        waterfallLayer.frame = bounds

        layoutAppShelf()
        layoutCards()
        applyScrollOffset(animated: false)
        positionSpotlight(animated: false)

        CATransaction.commit()
    }

    private func layoutAppShelf() {
        let iconSize: CGFloat = 48
        let gap: CGFloat = 14
        let totalWidth = CGFloat(appLayers.count) * iconSize + CGFloat(max(0, appLayers.count - 1)) * gap
        let startX = max(24, (bounds.width - totalWidth) / 2)

        for (index, layer) in appLayers.enumerated() {
            layer.frame = CGRect(
                x: startX + CGFloat(index) * (iconSize + gap),
                y: 20,
                width: iconSize,
                height: iconSize
            )
        }
    }

    private func layoutCards() {
        let columns = max(1, min(10, Int(bounds.width / 180)))
        let gap: CGFloat = 16
        let sideInset: CGFloat = max(32, (bounds.width - CGFloat(columns) * 156 - CGFloat(columns - 1) * gap) / 2)
        let topY = bounds.height - 204

        for (index, layer) in cardLayers.enumerated() {
            let column = index % columns
            let row = index / columns
            layer.frame = CGRect(
                x: sideInset + CGFloat(column) * (156 + gap),
                y: topY - CGFloat(row) * 104,
                width: 156,
                height: 86
            )
            thumbnailLayers[index].frame = CGRect(x: 12, y: 16, width: 132, height: 52)
        }
        setScrollOffset(scrollOffset, animated: false)
        updateCardVisual(at: selectedIndex, animated: false)
        if let hoveredIndex {
            updateCardVisual(at: hoveredIndex, animated: false)
        }
    }

    private func selectCard(at index: Int, animated: Bool = true) {
        guard cardLayers.indices.contains(index) else { return }
        let oldIndex = selectedIndex
        selectedIndex = index

        updateCardVisual(at: oldIndex, animated: animated)
        updateCardVisual(at: selectedIndex, animated: animated)
        scrollSelectedCardIntoView(animated: animated)
        positionSpotlight(animated: animated)
    }

    private func hoverCard(at index: Int, animated: Bool) {
        guard cardLayers.indices.contains(index) else { return }

        let oldIndex = hoveredIndex
        hoveredIndex = index

        if let oldIndex {
            updateCardVisual(at: oldIndex, animated: animated)
        }
        updateCardVisual(at: index, animated: animated)
    }

    private func updateCardVisual(at index: Int, animated: Bool) {
        guard cardLayers.indices.contains(index) else { return }
        let layer = cardLayers[index]
        let isSelected = index == selectedIndex
        let isHovered = index == hoveredIndex
        let scale: CGFloat
        let shadowOpacity: Float
        let shadowRadius: CGFloat
        let borderColor: CGColor

        if isSelected {
            scale = 1.045
            shadowOpacity = 0.32
            shadowRadius = 18
            borderColor = NSColor.keyboardFocusIndicatorColor.withAlphaComponent(0.72).cgColor
        } else if isHovered {
            scale = 1.025
            shadowOpacity = 0.22
            shadowRadius = 12
            borderColor = NSColor.controlAccentColor.withAlphaComponent(0.48).cgColor
        } else {
            scale = 1
            shadowOpacity = 0
            shadowRadius = 0
            borderColor = NSColor.separatorColor.withAlphaComponent(0.3).cgColor
        }

        CATransaction.begin()
        CATransaction.setAnimationDuration(animated ? 0.16 : 0)
        CATransaction.setAnimationTimingFunction(CAMediaTimingFunction(name: .easeOut))
        layer.transform = scale == 1 ? CATransform3DIdentity : CATransform3DMakeScale(scale, scale, 1)
        layer.shadowOpacity = shadowOpacity
        layer.shadowRadius = shadowRadius
        layer.borderColor = borderColor
        CATransaction.commit()
    }

    private func positionSpotlight(animated: Bool) {
        guard cardLayers.indices.contains(selectedIndex) else { return }
        let selectedFrame = cardLayers[selectedIndex].frame.insetBy(dx: -10, dy: -8)

        CATransaction.begin()
        CATransaction.setAnimationDuration(animated ? 0.16 : 0)
        CATransaction.setAnimationTimingFunction(CAMediaTimingFunction(name: .easeOut))
        spotlightLayer.frame = selectedFrame
        spotlightLayer.cornerRadius = 16
        spotlightLayer.opacity = 1
        CATransaction.commit()

        guard animated else { return }
        let animation = CABasicAnimation(keyPath: "locations")
        animation.fromValue = [-0.6, -0.2, 0.2]
        animation.toValue = [0.8, 1.2, 1.6]
        animation.duration = 0.8
        animation.timingFunction = CAMediaTimingFunction(name: .easeInEaseOut)
        spotlightLayer.add(animation, forKey: "aligner.round1.spotlight")
    }

    private func refillSimulatedScreenshots(in range: Range<Int>) {
        CATransaction.begin()
        CATransaction.setAnimationDuration(0.12)
        for index in range where thumbnailLayers.indices.contains(index) {
            thumbnailLayers[index].backgroundColor = simulatedScreenshotColor(index: index).cgColor
            thumbnailLayers[index].borderColor = NSColor.white.withAlphaComponent(0.36).cgColor
            simulatedScreenshotRefillCount += 1
        }
        CATransaction.commit()
    }

    private func scrollSelectedCardIntoView(animated: Bool) {
        guard cardLayers.indices.contains(selectedIndex) else { return }

        let visibleMinY: CGFloat = 24
        let visibleMaxY = max(visibleMinY, bounds.height - 128)
        let selectedFrame = cardLayers[selectedIndex].frame.offsetBy(dx: 0, dy: scrollOffset)
        var nextOffset = scrollOffset

        if selectedFrame.minY < visibleMinY {
            nextOffset += visibleMinY - selectedFrame.minY
        } else if selectedFrame.maxY > visibleMaxY {
            nextOffset -= selectedFrame.maxY - visibleMaxY
        }

        let clampedOffset = min(max(nextOffset, 0), maximumScrollOffset())
        if clampedOffset != scrollOffset {
            scrollAdjustmentCount += 1
            setScrollOffset(clampedOffset, animated: animated)
        }
    }

    private func setScrollOffset(_ offset: CGFloat, animated: Bool) {
        let clampedOffset = min(max(offset, 0), maximumScrollOffset())
        guard clampedOffset != scrollOffset || waterfallLayer.sublayerTransform.m42 != clampedOffset else { return }
        scrollOffset = clampedOffset
        applyScrollOffset(animated: animated)
        positionSpotlight(animated: animated)
    }

    private func applyScrollOffset(animated: Bool) {
        CATransaction.begin()
        CATransaction.setAnimationDuration(animated ? 0.12 : 0)
        CATransaction.setAnimationTimingFunction(CAMediaTimingFunction(name: .easeOut))
        waterfallLayer.sublayerTransform = CATransform3DMakeTranslation(0, scrollOffset, 0)
        CATransaction.commit()
    }

    private func maximumScrollOffset() -> CGFloat {
        guard let minY = cardLayers.map(\.frame.minY).min() else { return 0 }
        return max(0, 24 - minY)
    }

    private func appColor(index: Int) -> NSColor {
        let hue = CGFloat(index) / CGFloat(Self.appCount)
        return NSColor(calibratedHue: hue, saturation: 0.56, brightness: 0.88, alpha: 1)
    }

    private func cardColor(index: Int) -> NSColor {
        let hue = CGFloat(index % Self.appCount) / CGFloat(Self.appCount)
        return NSColor(calibratedHue: hue, saturation: 0.18, brightness: 0.96, alpha: 0.92)
    }

    private func simulatedScreenshotColor(index: Int) -> NSColor {
        let hue = CGFloat((index * 7) % Self.cardCount) / CGFloat(Self.cardCount)
        return NSColor(calibratedHue: hue, saturation: 0.36, brightness: 0.78, alpha: 0.9)
    }

    private func milliseconds(since start: CFTimeInterval) -> Double {
        (CACurrentMediaTime() - start) * 1_000
    }

    private func percentile95(_ values: [Double]) -> Double? {
        guard !values.isEmpty else { return nil }

        let sortedValues = values.sorted()
        let index = min(
            sortedValues.count - 1,
            Int(ceil(Double(sortedValues.count) * 0.95)) - 1
        )
        return sortedValues[index]
    }

    private func jsonNumber(_ value: Double?) -> Any {
        value ?? NSNull()
    }
}