import SwiftUI

/// Landing screen modeled after the new prototype:
/// hero gauge + stats + quick actions + suggestion cards.
/// Replaces the old SmartScanView idle/completed states with a richer
/// at-a-glance view, and delegates active-scan progress to inline state UI.
struct DashboardView: View {
    @EnvironmentObject var appState: AppState
    @State private var showConfirmation = false
    @State private var fireCleanConfetti = false
    @State private var lastCleanedScanState: Bool = false
    @State private var hoveredSegment: String?
    /// Confetti burst origin as a fraction of the dashboard, derived from the
    /// SuccessMedal's real frame so the burst tracks it across window sizes
    /// and RTL layout instead of a hand-aimed constant.
    @State private var burstOrigin: UnitPoint = UnitPoint(x: 0.25, y: 0.28)
    @State private var dashboardSize: CGSize = .zero
    @Environment(\.accessibilityReduceMotion) private var reduceMotion

    private let dashboardSpace = "dashboard"

    /// Hero cards rise in with a slight settle and dissolve out; under
    /// Reduce Motion both directions collapse to a plain cross-fade.
    private var heroTransition: AnyTransition {
        reduceMotion
            ? .opacity
            : .asymmetric(
                insertion: .opacity
                    .combined(with: .offset(y: 12))
                    .combined(with: .scale(scale: 0.98, anchor: .top)),
                removal: .opacity
            )
    }

    var body: some View {
        ZStack {
            // Quiet tinted wash so the glass hero states have color to
            // refract. Static — no Reduce Motion concerns.
            LinearGradient(
                colors: [Tint.blue.opacity(0.08), Tint.purple.opacity(0.05), .clear],
                startPoint: .top, endPoint: .bottom
            )
            .ignoresSafeArea()

            ScrollView {
                VStack(alignment: .leading, spacing: 20) {
                    switch appState.scanState {
                    case .idle:
                        hero
                            .transition(heroTransition)
                        stats
                        if appState.diskInfo.totalSpace > 0 {
                            sectionHeader("Storage composition")
                            storageComposition
                        }
                        if !suggestionRows.isEmpty {
                            sectionHeader("Suggested for you")
                            suggestions
                        }
                    case .scanning:
                        scanningHero
                            .transition(heroTransition)
                        if !appState.allResults.isEmpty {
                            sectionHeader("Found so far")
                            liveResults
                        }
                    case .completed:
                        completedHero
                            .transition(heroTransition)
                        if appState.totalJunkSize > 0 {
                            sectionHeader("By category")
                            categoryChartCard
                            resultsList
                        }
                    case .cleaning:
                        cleaningHero
                            .transition(heroTransition)
                    case .cleaned:
                        cleanedHero
                            .transition(heroTransition)
                    }
                }
                .padding(.horizontal, 28)
                .padding(.vertical, 24)
                .frame(maxWidth: 920, alignment: .leading)
                .animation(reduceMotion ? nil : MotionTokens.gentle, value: appState.scanState)
            }

            // Celebratory burst when a clean cycle finishes with something
            // freed. Origin tracks the SuccessMedal's real frame (see
            // burstOrigin) so it explodes from the celebration on any window
            // size / layout direction.
            // allowsHitTesting=false keeps Done clickable through particles.
            ConfettiView(trigger: fireCleanConfetti, mode: .burst(origin: burstOrigin))
                .allowsHitTesting(false)
        }
        .coordinateSpace(name: dashboardSpace)
        .background(
            GeometryReader { geo in
                Color.clear.onAppear { dashboardSize = geo.size }
                    .onChange(of: geo.size) { dashboardSize = $0 }
            }
        )
        .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .top)
        .onChange(of: appState.scanState) { newState in
            // Fire only on the rising edge of .cleaned with freed > 0 so
            // the burst doesn't replay when the user navigates back to the
            // dashboard while .cleaned is still on screen.
            let isCleaned: Bool = {
                if case .cleaned = newState { return true }
                return false
            }()
            if isCleaned && !lastCleanedScanState && appState.totalFreedSpace > 0 {
                if reduceMotion {
                    // Confetti renders nothing under Reduce Motion; no need
                    // to wait for an entrance spring that isn't playing.
                    fireCleanConfetti.toggle()
                } else {
                    // Let the hero settle and the counter roll before the
                    // burst so the celebration lands as one beat.
                    DispatchQueue.main.asyncAfter(deadline: .now() + 0.55) {
                        fireCleanConfetti.toggle()
                    }
                }
            }
            lastCleanedScanState = isCleaned
        }
        .confirmationDialog(
            cleanConfirmationTitle,
            isPresented: $showConfirmation,
            titleVisibility: .visible
        ) {
            Button("Clean", role: .destructive) { appState.cleanAll() }
            Button("Cancel", role: .cancel) {}
        } message: {
            Text("This will permanently delete the selected files. This cannot be undone.")
        }
    }

    private var cleanConfirmationTitle: String {
        String(
            format: String(localized: "Clean %@?"),
            ByteCountFormatter.string(fromByteCount: appState.totalSelectedSize, countStyle: .file)
        )
    }

    // MARK: - Hero (idle)

    private var hero: some View {
        let total = appState.diskInfo.totalSpace
        let used = appState.diskInfo.usedSpace
        let free = appState.diskInfo.freeSpace
        let percentUsed = total > 0 ? Double(used) / Double(total) : 0
        let stress = percentUsed > 0.85
        // Below this width the side-by-side ring + storage column overflows the
        // card, so the hero stacks vertically and the ring shrinks.
        let compact = dashboardSize.width > 0 && dashboardSize.width < 660
        let ringSize: CGFloat = compact ? 132 : 180

        return CardSurface(padding: 24, accent: stress ? Tint.orange : Tint.blue, elevation: .raised) {
            AdaptiveStack(compact: compact, spacing: compact ? 18 : 28) {
                ZStack {
                    // Slow atmospheric drift behind the ring — barely-there
                    // ambient depth, frozen under Reduce Motion.
                    HeroDrift(tint: stress ? Tint.orange : Tint.blue)
                    HealthRing(percent: percentUsed)
                        .frame(width: ringSize, height: ringSize)
                }

                VStack(alignment: .leading, spacing: 14) {
                    HStack(alignment: .top) {
                        VStack(alignment: .leading, spacing: 4) {
                            HStack(spacing: 8) {
                                Text("Storage")
                                    .font(.system(size: 13, weight: .semibold))
                                    .foregroundStyle(.secondary)
                                    .textCase(.uppercase)
                                    .tracking(0.6)
                                if stress {
                                    StatusChip(label: String(localized: "Low space"),
                                               systemImage: "exclamationmark.triangle.fill",
                                               tint: Tint.orange)
                                }
                            }
                            CountUpBytes(bytes: free)
                                .font(.system(size: 34, weight: .semibold))
                                .foregroundStyle(stress ? Tint.orange : Color.primary)
                            Text(freeOfText(total: total))
                                .font(.system(size: 12))
                                .foregroundStyle(.secondary)
                        }
                        Spacer()
                        Button {
                            appState.startSmartScan()
                        } label: {
                            Label("Smart Scan", systemImage: "sparkles")
                                .padding(.horizontal, 4)
                        }
                        .buttonStyle(GlowProminentButtonStyle(breathes: true))
                    }

                    storageBreakdown(used: used, total: total)
                }
                .frame(maxWidth: .infinity, alignment: .leading)
            }
        }
    }

    private func freeOfText(total: Int64) -> String {
        String(
            format: String(localized: "free of %@"),
            ByteCountFormatter.string(fromByteCount: total, countStyle: .file)
        )
    }

    private func storageBreakdown(used: Int64, total: Int64) -> some View {
        let usedPct  = total > 0 ? Double(used) / Double(total) : 0
        let junkPct  = total > 0 ? min(0.4, Double(appState.totalJunkSize) / Double(total)) : 0

        return VStack(alignment: .leading, spacing: 8) {
            GeometryReader { geo in
                ZStack(alignment: .leading) {
                    Capsule()
                        .fill(Color.primary.opacity(0.08))
                    HStack(spacing: 0) {
                        Capsule()
                            .fill(LinearGradient(colors: [Tint.blue, Tint.purple], startPoint: .leading, endPoint: .trailing))
                            .frame(width: geo.size.width * CGFloat(usedPct))
                    }
                    if junkPct > 0 {
                        Capsule()
                            .fill(Tint.orange)
                            .frame(width: max(8, geo.size.width * CGFloat(junkPct)))
                            .offset(x: geo.size.width * CGFloat(usedPct - junkPct))
                            .opacity(0.85)
                    }
                }
            }
            .frame(height: 10)

            HStack(spacing: 16) {
                LegendDot(color: Tint.blue, label: "Used", value: ByteCountFormatter.string(fromByteCount: used, countStyle: .file))
                if appState.totalJunkSize > 0 {
                    LegendDot(color: Tint.orange, label: "Junk",
                              value: ByteCountFormatter.string(fromByteCount: appState.totalJunkSize, countStyle: .file))
                }
                if appState.diskInfo.purgeableSpace > 0 {
                    LegendDot(color: Tint.green, label: "Purgeable",
                              value: ByteCountFormatter.string(fromByteCount: appState.diskInfo.purgeableSpace, countStyle: .file))
                }
                Spacer()
                Text(percentUsedText(usedPct))
                    .font(.system(size: 11, weight: .medium))
                    .foregroundStyle(.secondary)
                    .monospacedDigit()
            }
        }
    }

    private func percentUsedText(_ usedPct: Double) -> String {
        String(format: String(localized: "%lld%% used"), Int64(usedPct * 100))
    }

    // MARK: - Stats

    private var stats: some View {
        let free = appState.diskInfo.freeSpace
        let total = appState.diskInfo.totalSpace
        let percentUsed = total > 0 ? Double(total - free) / Double(total) : 0

        // Four across when there's room, two when the dashboard is narrow so the
        // cards don't crush their values.
        let columnCount = dashboardSize.width > 0 && dashboardSize.width < 660 ? 2 : 4
        return LazyVGrid(columns: Array(repeating: GridItem(.flexible(), spacing: 12), count: columnCount), spacing: 12) {
            StatCard(
                icon: "internaldrive.fill",
                tint: Tint.blue,
                label: "Free Space",
                value: ByteCountFormatter.string(fromByteCount: free, countStyle: .file),
                delta: total > 0 ? freeSpaceDelta(total: total, percentUsed: percentUsed) : nil,
                byteValue: free
            )
            .staggered(0)
            StatCard(
                icon: "trash.circle.fill",
                tint: Tint.orange,
                label: "Junk Found",
                value: appState.totalJunkSize > 0
                    ? ByteCountFormatter.string(fromByteCount: appState.totalJunkSize, countStyle: .file)
                    : "—",
                delta: appState.allResults.isEmpty
                    ? String(localized: "Run a scan")
                    : junkFoundDelta(count: appState.allResults.count),
                byteValue: appState.totalJunkSize > 0 ? appState.totalJunkSize : nil
            )
            .staggered(1)
            StatCard(
                icon: "square.grid.2x2.fill",
                tint: Tint.purple,
                label: "Apps",
                value: "\(appState.installedApps.count)",
                delta: String(localized: "installed")
            )
            .staggered(2)
            StatCard(
                icon: "memorychip.fill",
                tint: Tint.green,
                label: "Purgeable",
                value: appState.diskInfo.purgeableSpace > 0
                    ? ByteCountFormatter.string(fromByteCount: appState.diskInfo.purgeableSpace, countStyle: .file)
                    : "—",
                delta: String(localized: "Managed by macOS"),
                byteValue: appState.diskInfo.purgeableSpace > 0 ? appState.diskInfo.purgeableSpace : nil
            )
            .staggered(3)
        }
    }

    private func freeSpaceDelta(total: Int64, percentUsed: Double) -> String {
        String(
            format: String(localized: "of %@ · %lld%% used"),
            ByteCountFormatter.string(fromByteCount: total, countStyle: .file),
            Int64(percentUsed * 100)
        )
    }

    private func junkFoundDelta(count: Int) -> String {
        String(format: String(localized: "across %lld categories"), Int64(count))
    }

    // MARK: - Storage composition

    private var storageComposition: some View {
        let total = appState.diskInfo.totalSpace
        let free = appState.diskInfo.freeSpace
        let purge = max(0, appState.diskInfo.purgeableSpace)
        let junk = max(0, min(appState.totalJunkSize, appState.diskInfo.usedSpace))
        // "Used" excludes the junk + purgeable slices so the four segments sum
        // to the whole disk without double-counting.
        let usedCore = max(0, appState.diskInfo.usedSpace - junk - purge)

        var segments: [StorageDonut.Segment] = []
        func add(_ id: String, _ value: Int64, _ color: Color, _ label: LocalizedStringKey) {
            guard value > 0 else { return }
            segments.append(.init(
                id: id,
                value: Double(value),
                color: color,
                label: label,
                display: ByteCountFormatter.string(fromByteCount: value, countStyle: .file)
            ))
        }
        add("used", usedCore, Tint.blue, "Used")
        add("junk", junk, Tint.orange, "Junk")
        add("purgeable", purge, Tint.green, "Purgeable")
        add("free", free, Color.primary.opacity(0.14), "Free")

        return CardSurface(padding: 18, elevation: .standard) {
            HStack(alignment: .center, spacing: 24) {
                ZStack {
                    StorageDonut(segments: segments, highlightedID: hoveredSegment)
                        .frame(width: 132, height: 132)
                    VStack(spacing: 1) {
                        Text(ByteCountFormatter.string(fromByteCount: total, countStyle: .file))
                            .font(.system(size: 17, weight: .bold))
                            .monospacedDigit()
                        Text("total")
                            .font(.system(size: 10))
                            .foregroundStyle(.secondary)
                    }
                }

                VStack(alignment: .leading, spacing: 12) {
                    ForEach(Array(segments.enumerated()), id: \.element.id) { idx, seg in
                        HoverableLegendChip(
                            color: seg.color, label: seg.label, value: seg.display
                        ) { hovering in
                            hoveredSegment = hovering ? seg.id : nil
                        }
                        .staggered(idx)
                    }
                }
                Spacer(minLength: 0)
            }
        }
    }

    // MARK: - Suggestions

    private var suggestions: some View {
        VStack(spacing: 10) {
            ForEach(Array(suggestionRows.enumerated()), id: \.offset) { idx, row in
                SuggestionRow(suggestion: row)
                    .staggered(idx)
            }
        }
    }

    private var suggestionRows: [Suggestion] {
        var out: [Suggestion] = []
        // Surface the largest pending category as a contextual nudge.
        if let biggest = appState.allResults.max(by: { $0.totalSize < $1.totalSize }), biggest.totalSize > 0 {
            let title = String(
                format: String(localized: "%@ is using %@"),
                String(localized: String.LocalizationValue(biggest.category.rawValue)),
                biggest.formattedSize
            )
            out.append(Suggestion(
                icon: biggest.category.icon,
                tint: biggest.category.color,
                title: title,
                subtitle: String(localized: String.LocalizationValue(biggest.category.description)),
                pill: biggest.formattedSize
            ))
        }
        if !appState.hasFullDiskAccess {
            out.append(Suggestion(
                icon: "lock.shield.fill",
                tint: Tint.orange,
                title: String(localized: "Grant Full Disk Access for full results"),
                subtitle: String(localized: "Without it, most caches and uninstall flows fail."),
                pill: String(localized: "Action")
            ))
        }
        return out
    }

    // MARK: - Scanning state

    private var scanningHero: some View {
        CardSurface(padding: 24, accent: Tint.blue, elevation: .raised, material: .ultraThinMaterial) {
            HStack(alignment: .center, spacing: 28) {
                ScanningGauge(progress: appState.scanProgress)
                    .frame(width: 180, height: 180)
                VStack(alignment: .leading, spacing: 10) {
                    HStack(spacing: 8) {
                        sparklesIcon
                        Text("Scanning your Mac")
                            .font(.system(size: 22, weight: .bold))
                    }

                    // Category line slides up as the scan advances.
                    Text(currentlyInText)
                        .font(.system(size: 13))
                        .foregroundStyle(.secondary)
                        .id(appState.currentScanCategory)
                        .transition(
                            reduceMotion
                                ? .opacity
                                : .asymmetric(
                                    insertion: .move(edge: .bottom).combined(with: .opacity),
                                    removal: .move(edge: .top).combined(with: .opacity)
                                )
                        )

                    ShimmerProgressBar(progress: appState.scanProgress)
                        .frame(maxWidth: 320)
                        .padding(.top, 2)

                    // Live file-path ticker — the "it's really working"
                    // signal. Observes the standalone ScanProgressTicker so the
                    // ~10Hz path churn re-renders only this label, not the whole
                    // dashboard (issues #119, #120).
                    ScanPathTicker(ticker: appState.scanTicker)
                }
                .animation(reduceMotion ? nil : .easeOut(duration: 0.18), value: appState.currentScanCategory)
                Spacer(minLength: 0)
            }
        }
    }

    private var currentlyInText: String {
        String(
            format: String(localized: "Currently in: %@"),
            String(localized: String.LocalizationValue(appState.currentScanCategory))
        )
    }

    private var liveResults: some View {
        CardSurface(padding: 0) {
            VStack(spacing: 0) {
                ForEach(appState.allResults.prefix(8)) { result in
                    HStack(spacing: 12) {
                        IconTile(systemName: result.category.icon, tint: result.category.color, size: 26)
                        Text(LocalizedStringKey(result.category.rawValue))
                            .font(.system(size: 13))
                        Spacer()
                        Text(result.formattedSize)
                            .font(.system(size: 13, weight: .semibold))
                            .monospacedDigit()
                            .foregroundStyle(.secondary)
                    }
                    .padding(.horizontal, 16)
                    .padding(.vertical, 12)
                    .transition(
                        reduceMotion
                            ? .opacity
                            : .move(edge: .bottom).combined(with: .opacity)
                    )
                    if result.id != appState.allResults.prefix(8).last?.id {
                        Divider().padding(.leading, 54)
                    }
                }
            }
            .animation(reduceMotion ? nil : .spring(response: 0.4, dampingFraction: 0.85),
                       value: appState.allResults.count)
        }
    }

    // MARK: - Completed state

    private var completedHero: some View {
        let isClean = appState.totalJunkSize <= 0
        return CardSurface(padding: 24, accent: isClean ? Tint.green : Tint.orange, elevation: .raised) {
            VStack(alignment: .leading, spacing: 14) {
                HStack(alignment: .firstTextBaseline) {
                    if !isClean {
                        CountUpBytes(bytes: appState.totalJunkSize)
                            .font(.system(size: 40, weight: .semibold))
                        Text("found")
                            .font(.system(size: 16))
                            .foregroundStyle(.secondary)
                    } else {
                        HStack(spacing: 10) {
                            cleanSealIcon
                            Text("Your Mac is clean")
                                .font(.system(size: 22, weight: .bold))
                                .foregroundStyle(Tint.green)
                        }
                    }
                    Spacer()
                    Button("Scan Again") { appState.startSmartScan() }
                        .controlSize(.large)
                }
                if !isClean {
                    HStack {
                        if appState.totalSelectedSize > 0 {
                            Button {
                                showConfirmation = true
                            } label: {
                                Label {
                                    Text(cleanSelectedLabel)
                                } icon: {
                                    Image(systemName: "sparkles")
                                }
                                .padding(.horizontal, 6)
                            }
                            .buttonStyle(GlowProminentButtonStyle())
                        }
                        Spacer()
                    }
                }
            }
        }
    }

    private var cleanSelectedLabel: String {
        String(
            format: String(localized: "Clean %@"),
            ByteCountFormatter.string(fromByteCount: appState.totalSelectedSize, countStyle: .file)
        )
    }

    private var categoryChartCard: some View {
        let bars = appState.allResults
            .filter { $0.totalSize > 0 }
            .sorted { $0.totalSize > $1.totalSize }
            .prefix(8)
            .map { CategoryBarChart.Bar(category: $0.category, size: $0.totalSize) }

        return CardSurface(padding: 18, elevation: .standard) {
            CategoryBarChart(bars: Array(bars))
        }
    }

    private var resultsList: some View {
        CardSurface(padding: 0) {
            VStack(spacing: 0) {
                ForEach(Array(appState.allResults.enumerated()), id: \.element.id) { idx, result in
                    CategoryToggleRow(result: result)
                        .staggered(idx)
                    if result.id != appState.allResults.last?.id {
                        Divider().padding(.leading, 54)
                    }
                }
            }
        }
    }

    @ViewBuilder
    private var cleanSealIcon: some View {
        let base = Image(systemName: "checkmark.seal.fill")
            .font(.system(size: 26, weight: .bold))
            .foregroundStyle(Tint.green)
        if #available(macOS 14.0, *) {
            base.symbolEffect(.bounce, value: appState.totalJunkSize)
        } else {
            base
        }
    }

    @ViewBuilder
    private var sparklesIcon: some View {
        let base = Image(systemName: "sparkles")
            .font(.system(size: 18, weight: .semibold))
            .foregroundStyle(
                LinearGradient(colors: [Tint.blue, Tint.purple],
                               startPoint: .topLeading, endPoint: .bottomTrailing)
            )
        if #available(macOS 14.0, *) {
            base.symbolEffect(.variableColor.iterative, options: .repeating)
        } else {
            base
        }
    }

    private var cleaningHero: some View {
        CardSurface(padding: 24, accent: Tint.orange, elevation: .raised, material: .ultraThinMaterial) {
            HStack(alignment: .center, spacing: 28) {
                ScanningGauge(progress: appState.cleanProgress, tint: Tint.orange, label: "CLEANING")
                    .frame(width: 180, height: 180)
                VStack(alignment: .leading, spacing: 8) {
                    Text("Cleaning…")
                        .font(.system(size: 22, weight: .bold))
                    Text(percentCompleteText)
                        .font(.system(size: 13))
                        .foregroundStyle(.secondary)
                    ShimmerProgressBar(progress: appState.cleanProgress, tint: Tint.orange)
                        .frame(maxWidth: 320)
                        .padding(.top, 2)
                }
                Spacer(minLength: 0)
            }
        }
    }

    private var percentCompleteText: String {
        String(format: String(localized: "%lld%% complete"), Int64(appState.cleanProgress * 100))
    }

    /// Convert the medal's frame (in dashboard coordinates) into a UnitPoint
    /// for the confetti emitter. Falls back to the existing value until the
    /// dashboard size is known.
    private func updateBurstOrigin(medalFrame: CGRect) {
        guard dashboardSize.width > 0, dashboardSize.height > 0 else { return }
        burstOrigin = UnitPoint(
            x: max(0, min(1, medalFrame.midX / dashboardSize.width)),
            y: max(0, min(1, medalFrame.midY / dashboardSize.height))
        )
    }

    private var cleanedHero: some View {
        CardSurface(padding: 24, accent: Tint.green, elevation: .raised, material: .ultraThinMaterial) {
            HStack(alignment: .center, spacing: 28) {
                SuccessMedal()
                    .background(
                        GeometryReader { geo in
                            Color.clear.onAppear { updateBurstOrigin(medalFrame: geo.frame(in: .named(dashboardSpace))) }
                        }
                    )

                VStack(alignment: .leading, spacing: 6) {
                    CountUpBytes(bytes: appState.totalFreedSpace)
                        .font(.system(size: 40, weight: .semibold))
                        .foregroundStyle(Tint.green)
                    Text("freed")
                        .font(.system(size: 14))
                        .foregroundStyle(.secondary)
                    Button("Done") { appState.scanState = .idle }
                        .buttonStyle(GlowProminentButtonStyle(tint: Tint.green, gradient: TintGradient.of(Tint.green)))
                        .padding(.top, 4)
                }
                Spacer(minLength: 0)
            }
        }
    }

    // MARK: - Helpers

    private func sectionHeader(_ text: LocalizedStringKey) -> some View {
        Text(text)
            .font(.system(size: 16, weight: .bold))
            .padding(.top, 4)
    }
}

// MARK: - Components

private struct StatCard: View {
    let icon: String
    let tint: Color
    let label: LocalizedStringKey
    let value: String
    let delta: String?
    /// When set, the headline renders as a rolling byte counter instead of
    /// the static `value` string.
    var byteValue: Int64? = nil

    var body: some View {
        CardSurface(padding: 14, accent: tint) {
            VStack(alignment: .leading, spacing: 6) {
                HStack(spacing: 8) {
                    IconTile(systemName: icon, tint: tint, size: 28, glow: true)
                    Text(label)
                        .font(.system(size: 12, weight: .medium))
                        .foregroundStyle(.secondary)
                        .textCase(.uppercase)
                        .tracking(0.4)
                }
                Group {
                    if let byteValue {
                        CountUpBytes(bytes: byteValue)
                    } else {
                        Text(value)
                            .monospacedDigit()
                            .contentTransition(.numericText())
                    }
                }
                .font(.system(size: 22, weight: .bold))
                .lineLimit(1)
                .minimumScaleFactor(0.6)
                if let delta {
                    Text(delta)
                        .font(.system(size: 11))
                        .foregroundStyle(.tertiary)
                }
            }
        }
        .pressable(hoverScale: 1.02, lift: true)
    }
}

private struct Suggestion: Identifiable {
    let id = UUID()
    let icon: String
    let tint: Color
    let title: String
    let subtitle: String
    let pill: String?
}

private struct SuggestionRow: View {
    let suggestion: Suggestion
    var body: some View {
        CardSurface(padding: 14, accent: suggestion.tint) {
            HStack(spacing: 14) {
                IconTile(systemName: suggestion.icon, tint: suggestion.tint,
                         size: 38, corner: 10, glow: true)
                VStack(alignment: .leading, spacing: 2) {
                    Text(suggestion.title)
                        .font(.system(size: 14, weight: .semibold))
                    Text(suggestion.subtitle)
                        .font(.system(size: 12))
                        .foregroundStyle(.secondary)
                }
                Spacer()
                if let pill = suggestion.pill {
                    StatusChip(label: pill, tint: suggestion.tint)
                }
                Image(systemName: "chevron.right")
                    .font(.system(size: 11, weight: .semibold))
                    .foregroundStyle(.tertiary)
            }
        }
        .pressable(hoverScale: 1.01, lift: true)
    }
}

/// Live file-path ticker. Observes the standalone `ScanProgressTicker` directly
/// so the scan engine's ~10Hz path updates re-render only this one label rather
/// than the whole AppState-observing view tree (issues #119, #120).
private struct ScanPathTicker: View {
    @ObservedObject var ticker: ScanProgressTicker

    private var display: String {
        guard !ticker.path.isEmpty else { return "" }
        return (ticker.path as NSString).abbreviatingWithTildeInPath
    }

    var body: some View {
        Text(display)
            .font(.system(size: 11, design: .monospaced))
            .foregroundStyle(.tertiary)
            .lineLimit(1)
            .truncationMode(.middle)
            .frame(maxWidth: 360, alignment: .leading)
            .frame(height: 14)
            .opacity(display.isEmpty ? 0 : 1)
    }
}

// MARK: - Gauges

private struct LegendDot: View {
    let color: Color
    let label: LocalizedStringKey
    let value: String

    var body: some View {
        HStack(spacing: 6) {
            Circle().fill(color).frame(width: 8, height: 8)
            VStack(alignment: .leading, spacing: 0) {
                Text(label)
                    .font(.system(size: 10.5))
                    .foregroundStyle(.secondary)
                Text(value)
                    .font(.system(size: 11.5, weight: .semibold))
                    .monospacedDigit()
            }
        }
    }
}

// ScanningGauge now lives in Components/DashboardCharts.swift (radar sweep +
// halo rings + Reduce Motion compliance).

/// Legend chip wrapper that reports hover for donut cross-highlighting and
/// scales slightly while hovered.
private struct HoverableLegendChip: View {
    let color: Color
    let label: LocalizedStringKey
    let value: String
    let onHoverChange: (Bool) -> Void

    @State private var hovering = false
    @Environment(\.accessibilityReduceMotion) private var reduceMotion

    var body: some View {
        LegendChip(color: color, label: label, value: value)
            .scaleEffect(hovering && !reduceMotion ? 1.05 : 1, anchor: .leading)
            .animation(reduceMotion ? nil : MotionTokens.snappy, value: hovering)
            .onHover { h in
                hovering = h
                onHoverChange(h)
            }
    }
}

/// Barely-there radial wash that drifts behind the idle hero ring. Static at
/// rest size under Reduce Motion.
private struct HeroDrift: View {
    let tint: Color

    @State private var drift = false
    @Environment(\.accessibilityReduceMotion) private var reduceMotion

    var body: some View {
        RadialGradient(
            colors: [tint.opacity(0.16), .clear],
            center: .center, startRadius: 10, endRadius: 130
        )
        .blur(radius: 24)
        .scaleEffect(drift ? 1.12 : 0.96)
        .offset(x: drift ? 8 : -8)
        .onAppear {
            guard !reduceMotion else { return }
            withAnimation(.easeInOut(duration: 3.0).repeatForever(autoreverses: true)) {
                drift = true
            }
        }
    }
}

/// Gradient progress capsule with a traveling shimmer band, replacing the
/// stock linear ProgressView during scans/cleans. Shimmer is masked to the
/// filled portion and removed entirely under Reduce Motion.
private struct ShimmerProgressBar: View {
    let progress: Double
    var tint: Color = Tint.blue

    @Environment(\.accessibilityReduceMotion) private var reduceMotion

    private var clamped: Double { max(0, min(1, progress)) }

    var body: some View {
        GeometryReader { geo in
            let fillWidth = geo.size.width * CGFloat(clamped)
            ZStack(alignment: .leading) {
                Capsule()
                    .fill(Color.primary.opacity(0.08))

                Capsule()
                    .fill(
                        LinearGradient(colors: [tint, tint.opacity(0.7)],
                                       startPoint: .leading, endPoint: .trailing)
                    )
                    .frame(width: max(8, fillWidth))
                    .animation(reduceMotion ? nil : .easeOut(duration: 0.35), value: clamped)

                if !reduceMotion {
                    TimelineView(.animation) { timeline in
                        let t = timeline.date.timeIntervalSinceReferenceDate
                        let cycle = (t.truncatingRemainder(dividingBy: 1.8)) / 1.8
                        let bandWidth: CGFloat = 56
                        LinearGradient(
                            colors: [.clear, .white.opacity(0.35), .clear],
                            startPoint: .leading, endPoint: .trailing
                        )
                        .frame(width: bandWidth)
                        .offset(x: CGFloat(cycle) * (geo.size.width + bandWidth) - bandWidth)
                    }
                    .mask(
                        Capsule()
                            .frame(width: max(8, fillWidth))
                            .frame(maxWidth: .infinity, alignment: .leading)
                    )
                }
            }
        }
        .frame(height: 9)
    }
}

// MARK: - Toggle row

private struct CategoryToggleRow: View {
    @EnvironmentObject var appState: AppState
    let result: CategoryResult

    private var isFullySelected: Bool {
        appState.selectedCountInCategory(result.category) == result.itemCount
    }

    var body: some View {
        Toggle(isOn: Binding(
            get: { isFullySelected },
            set: { newValue in
                if newValue {
                    appState.selectAllInCategory(result.category)
                } else {
                    appState.deselectAllInCategory(result.category)
                }
            }
        )) {
            HStack(spacing: 12) {
                IconTile(systemName: result.category.icon, tint: result.category.color, size: 28)
                VStack(alignment: .leading, spacing: 1) {
                    Text(LocalizedStringKey(result.category.rawValue))
                        .font(.system(size: 13.5, weight: .semibold))
                    Text(itemsCountText)
                        .font(.system(size: 11.5))
                        .foregroundStyle(.secondary)
                }
                Spacer()
                Text(result.formattedSize)
                    .font(.system(size: 13, weight: .semibold))
                    .monospacedDigit()
                    .foregroundStyle(.secondary)
            }
        }
        .toggleStyle(.checkbox)
        .padding(.horizontal, 16)
        .padding(.vertical, 10)
    }

    private var itemsCountText: String {
        String(format: String(localized: "%lld items"), Int64(result.itemCount))
    }
}

/// Lays its content out horizontally at full width and vertically when the
/// container is too narrow for the row to fit, so wide hero rows reflow into a
/// stacked layout instead of overflowing.
struct AdaptiveStack<Content: View>: View {
    let compact: Bool
    var spacing: CGFloat = 28
    @ViewBuilder var content: Content

    var body: some View {
        if compact {
            VStack(alignment: .leading, spacing: spacing) { content }
        } else {
            HStack(alignment: .center, spacing: spacing) { content }
        }
    }
}