import AppKit
import CodexBarCore
import SwiftUI

/// SwiftUI card used inside the NSMenu to mirror Apple's rich menu panels.
struct UsageMenuCardView: View {
    struct Model {
        enum PercentStyle: String {
            case left
            case used

            var labelSuffix: String {
                switch self {
                case .left: L("usage_percent_suffix_left")
                case .used: L("usage_percent_suffix_used")
                }
            }

            var accessibilityLabel: String {
                switch self {
                case .left: L("Usage remaining")
                case .used: L("Usage used")
                }
            }
        }

        struct Metric: Identifiable {
            let id: String
            let title: String
            let percent: Double
            let percentStyle: PercentStyle
            let statusText: String?
            let resetText: String?
            let detailText: String?
            let detailLeftText: String?
            let detailRightText: String?
            let pacePercent: Double?
            let paceOnTop: Bool
            let warningMarkerPercents: [Double]
            let workdayMarkerPercents: [Double]
            let cardStyle: Bool

            init(
                id: String,
                title: String,
                percent: Double,
                percentStyle: PercentStyle,
                statusText: String? = nil,
                resetText: String?,
                detailText: String?,
                detailLeftText: String?,
                detailRightText: String?,
                pacePercent: Double?,
                paceOnTop: Bool,
                warningMarkerPercents: [Double] = [],
                workdayMarkerPercents: [Double] = [],
                cardStyle: Bool = false)
            {
                self.id = id
                self.title = title
                self.percent = percent
                self.percentStyle = percentStyle
                self.statusText = statusText
                self.resetText = resetText
                self.detailText = detailText
                self.detailLeftText = detailLeftText
                self.detailRightText = detailRightText
                self.pacePercent = pacePercent
                self.paceOnTop = paceOnTop
                self.warningMarkerPercents = warningMarkerPercents
                self.workdayMarkerPercents = workdayMarkerPercents
                self.cardStyle = cardStyle
            }

            var percentLabel: String {
                UsageFormatter.percentText(self.percent, suffix: self.percentStyle.labelSuffix)
            }
        }

        enum SubtitleStyle {
            case info
            case loading
            case error
        }

        struct TokenUsageSection {
            let sessionLine: String
            let monthLine: String
            let comparisonLines: [String]
            let hintLine: String?
            let errorLine: String?
            let errorCopyText: String?

            init(
                sessionLine: String,
                monthLine: String,
                comparisonLines: [String] = [],
                hintLine: String?,
                errorLine: String?,
                errorCopyText: String?)
            {
                self.sessionLine = sessionLine
                self.monthLine = monthLine
                self.comparisonLines = comparisonLines
                self.hintLine = hintLine
                self.errorLine = errorLine
                self.errorCopyText = errorCopyText
            }
        }

        struct ProviderCostSection {
            let title: String
            let percentUsed: Double?
            let spendLine: String
            let percentLine: String?
            var personalSpendLine: String?
        }

        let provider: UsageProvider
        let providerName: String
        let email: String
        let subtitleText: String
        let subtitleStyle: SubtitleStyle
        var usesLiveSubtitle: Bool = false
        let planText: String?
        let metrics: [Metric]
        let usageNotes: [String]
        let openAIAPIUsage: OpenAIAPIUsageSnapshot?
        let inlineUsageDashboard: InlineUsageDashboardModel?
        let creditsText: String?
        let creditsRemaining: Double?
        var creditsProgressPercent: Double?, creditsScaleText: String?
        let creditsHintText: String?
        let creditsHintCopyText: String?
        var codexResetCredits: CodexResetCreditsPresentation?
        let providerCost: ProviderCostSection?
        let tokenUsage: TokenUsageSection?
        let placeholder: String?
        let progressColor: Color
    }

    let model: Model
    var layoutModel: Model?
    let width: CGFloat
    var planAction: (() -> Void)?
    @Environment(\.menuItemHighlighted) private var isHighlighted
    @Environment(\.menuCardRefreshMonitor) private var refreshMonitor

    static func popupMetricTitle(provider: UsageProvider, metric: Model.Metric) -> String {
        if provider == .openrouter, metric.id == "primary" {
            return L("API key limit")
        }
        return metric.title
    }

    var body: some View {
        let liveModel = self.liveModel
        VStack(alignment: .leading, spacing: 0) {
            UsageMenuCardHeaderView(
                model: self.layoutModel ?? self.model,
                planAction: self.planAction)

            if Self.hasDetails(for: liveModel) {
                Divider()
                    .padding(.top, UsageMenuCardLayout.headerContentSpacing)
                    .padding(.bottom, Self.dividerBottomPadding(for: liveModel))
            }

            if !liveModel.usesStackedDetailLayout {
                if let dashboard = liveModel.inlineUsageDashboard {
                    InlineUsageDashboardContent(model: dashboard)
                } else if !liveModel.usageNotes.isEmpty {
                    UsageNotesContent(notes: liveModel.usageNotes)
                } else if let placeholder = liveModel.placeholder {
                    // Non-stacked placeholders are standalone detail rows; stacked usage placeholders are gated below.
                    Text(placeholder)
                        .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
                        .font(.subheadline)
                }
            } else {
                let hasUsage = liveModel.hasUsageContent
                let hasCredits = liveModel.creditsText != nil
                let hasProviderCost = liveModel.providerCost != nil
                let hasCost = liveModel.tokenUsage != nil || hasProviderCost

                VStack(alignment: .leading, spacing: 12) {
                    if hasUsage {
                        UsageMenuCardUsageContentView(model: liveModel, showBottomDivider: false)
                    }
                    if hasUsage, hasCredits || hasCost {
                        Divider()
                    }
                    if let credits = liveModel.creditsText {
                        CreditsBarContent(
                            creditsText: credits,
                            creditsRemaining: liveModel.creditsRemaining,
                            progressPercent: liveModel.creditsProgressPercent,
                            scaleText: liveModel.creditsScaleText,
                            hintText: liveModel.creditsHintText,
                            hintCopyText: liveModel.creditsHintCopyText,
                            progressColor: liveModel.progressColor)
                    }
                    if hasCredits, hasCost {
                        Divider()
                    }
                    if let providerCost = liveModel.providerCost {
                        ProviderCostContent(
                            section: providerCost,
                            progressColor: liveModel.progressColor)
                    }
                    if hasProviderCost, liveModel.tokenUsage != nil {
                        Divider()
                    }
                    if let tokenUsage = liveModel.tokenUsage {
                        VStack(alignment: .leading, spacing: 6) {
                            Text(L("cost_header_estimated"))
                                .font(.body)
                                .fontWeight(.medium)
                            Text(tokenUsage.sessionLine)
                                .font(.footnote)
                                .lineLimit(1)
                            Text(tokenUsage.monthLine)
                                .font(.footnote)
                                .lineLimit(1)
                            ForEach(tokenUsage.comparisonLines, id: \.self) { line in
                                Text(line)
                                    .font(.footnote)
                                    .lineLimit(1)
                            }
                            if let hint = tokenUsage.hintLine, !hint.isEmpty {
                                Text(hint)
                                    .font(.footnote)
                                    .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
                                    .lineLimit(4)
                                    .fixedSize(horizontal: false, vertical: true)
                            }
                            if let error = tokenUsage.errorLine, !error.isEmpty {
                                Text(error)
                                    .font(.footnote)
                                    .foregroundStyle(MenuHighlightStyle.error(self.isHighlighted))
                                    .lineLimit(4)
                                    .fixedSize(horizontal: false, vertical: true)
                                    .overlay {
                                        ClickToCopyOverlay(copyText: tokenUsage.errorCopyText ?? error)
                                    }
                            }
                        }
                    }
                }
            }
        }
        .padding(.horizontal, UsageMenuCardLayout.horizontalPadding)
        .padding(
            .top,
            Self.hasDetails(for: liveModel)
                ? UsageMenuCardLayout.sectionTopPadding
                : UsageMenuCardLayout.headerOnlyVerticalPadding)
        // AppKit's following separator row adds visual bottom space, so detail cards keep this inset tight.
        .padding(
            .bottom,
            Self.hasDetails(for: liveModel)
                ? UsageMenuCardLayout.sectionBottomPadding
                : UsageMenuCardLayout.headerOnlyVerticalPadding)
        .frame(width: self.width, alignment: .leading)
    }

    private var liveModel: Model {
        guard self.model.usesLiveSubtitle else { return self.model }
        return self.refreshMonitor?.model(for: self.model.provider, fallback: self.model) ?? self.model
    }

    private static func hasDetails(for model: Model) -> Bool {
        model.hasUsageContent || model.usesStackedDetailLayout
    }

    static func dividerBottomPadding(for model: Model) -> CGFloat {
        if model.usesStackedDetailLayout, model.hasUsageContent {
            return UsageMenuCardLayout.postHeaderDividerContentSpacing
        }
        return UsageMenuCardLayout.sectionBottomPadding
    }
}

private struct UsageMenuCardHeaderView: View {
    let model: UsageMenuCardView.Model
    var planAction: (() -> Void)?
    @Environment(\.menuItemHighlighted) private var isHighlighted
    @Environment(\.menuCardRefreshMonitor) private var refreshMonitor

    var body: some View {
        VStack(alignment: .leading, spacing: UsageMenuCardLayout.headerLineSpacing) {
            HStack(alignment: .firstTextBaseline, spacing: UsageMenuCardLayout.headerColumnSpacing) {
                Text(self.model.providerName).font(.headline)
                    .fontWeight(.semibold)
                    .lineLimit(1).truncationMode(.tail).layoutPriority(1)
                Spacer()
                Text(self.model.email).font(.subheadline)
                    .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
                    .lineLimit(1).truncationMode(.middle)
            }
            let liveSubtitle = self.liveSubtitle
            // Keep the geometry AppKit measured for this hosted row. A new error stays one line
            // until the next rebuild; a recovered error keeps its reserved height until then.
            let usesErrorLayout = self.model.subtitleStyle == .error
            let subtitleAlignment: VerticalAlignment = usesErrorLayout ? .top : .firstTextBaseline
            HStack(alignment: subtitleAlignment, spacing: UsageMenuCardLayout.headerColumnSpacing) {
                if usesErrorLayout {
                    Text(self.model.subtitleText)
                        .font(.footnote)
                        .lineLimit(4)
                        .multilineTextAlignment(.leading)
                        .fixedSize(horizontal: false, vertical: true)
                        .padding(.bottom, 4)
                        .hidden()
                        .overlay(alignment: .topLeading) {
                            Text(liveSubtitle.text)
                                .font(.footnote)
                                .foregroundStyle(self.subtitleColor(for: liveSubtitle.style))
                                .lineLimit(4)
                                .multilineTextAlignment(.leading)
                                .fixedSize(horizontal: false, vertical: true)
                        }
                        .clipped()
                        .layoutPriority(1)
                } else {
                    Text(liveSubtitle.text)
                        .font(.footnote)
                        .foregroundStyle(self.subtitleColor(for: liveSubtitle.style))
                        .lineLimit(1)
                        .multilineTextAlignment(.leading)
                        .fixedSize(horizontal: false, vertical: true)
                        .layoutPriority(1)
                }
                Spacer()
                if usesErrorLayout {
                    let showsCopyButton = liveSubtitle.style == .error && !liveSubtitle.text.isEmpty
                    CopyIconButton(
                        copyText: liveSubtitle.text,
                        isHighlighted: self.isHighlighted,
                        isInteractive: showsCopyButton)
                        .opacity(showsCopyButton ? 1 : 0)
                        .allowsHitTesting(showsCopyButton)
                        .accessibilityHidden(!showsCopyButton)
                }
                if let plan = self.model.planText {
                    Group {
                        if let planAction {
                            Button(action: planAction) {
                                Text(plan)
                            }
                            .buttonStyle(.plain)
                            .menuCardInteractiveControl()
                            .accessibilityLabel(plan)
                        } else {
                            Text(plan)
                        }
                    }
                    .font(.footnote)
                    .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
                    .lineLimit(1)
                }
            }
        }
    }

    private var liveSubtitle: MenuCardLiveSubtitle {
        let fallback = MenuCardLiveSubtitle(text: self.model.subtitleText, style: self.model.subtitleStyle)
        guard self.model.usesLiveSubtitle else { return fallback }
        return self.refreshMonitor?.subtitle(for: self.model.provider, fallback: fallback) ?? fallback
    }

    private func subtitleColor(for style: UsageMenuCardView.Model.SubtitleStyle) -> Color {
        switch style {
        case .info: MenuHighlightStyle.secondary(self.isHighlighted)
        case .loading: MenuHighlightStyle.secondary(self.isHighlighted)
        case .error: MenuHighlightStyle.error(self.isHighlighted)
        }
    }
}

private struct CopyIconButtonStyle: ButtonStyle {
    let isHighlighted: Bool

    func makeBody(configuration: Configuration) -> some View {
        configuration.label
            .padding(4)
            .background {
                RoundedRectangle(cornerRadius: 4, style: .continuous)
                    .fill(MenuHighlightStyle.secondary(self.isHighlighted).opacity(configuration.isPressed ? 0.18 : 0))
            }
            .scaleEffect(configuration.isPressed ? 0.94 : 1)
            .animation(.easeOut(duration: 0.12), value: configuration.isPressed)
    }
}

private struct CopyIconButton: View {
    let copyText: String
    let isHighlighted: Bool
    let isInteractive: Bool

    @State private var didCopy = false
    @State private var resetTask: Task<Void, Never>?

    var body: some View {
        Button {
            self.handleCopy()
        } label: {
            Image(systemName: self.didCopy ? "checkmark" : "doc.on.doc")
                .font(.caption2.weight(.semibold))
                .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
                .frame(width: 18, height: 18)
        }
        .buttonStyle(CopyIconButtonStyle(isHighlighted: self.isHighlighted))
        .menuCardInteractiveControl(isEnabled: self.isInteractive)
        .accessibilityLabel(self.didCopy ? L("Copied") : L("Copy error"))
    }

    private func handleCopy() {
        let text = self.copyText
        self.resetTask?.cancel()
        MenuPasteboardCopy.perform(text, completion: {
            self.didCopy = true
            self.resetTask = Task { @MainActor in
                try? await Task.sleep(for: .seconds(0.9))
                self.didCopy = false
            }
        })
    }
}

private struct ProviderCostContent: View {
    let section: UsageMenuCardView.Model.ProviderCostSection
    let progressColor: Color
    @Environment(\.menuItemHighlighted) private var isHighlighted

    var body: some View {
        VStack(alignment: .leading, spacing: 6) {
            Text(self.section.title)
                .font(.body)
                .fontWeight(.medium)
            if let percentUsed = self.section.percentUsed {
                UsageProgressBar(
                    percent: percentUsed,
                    tint: self.progressColor,
                    accessibilityLabel: L("Extra usage spent"))
            }
            HStack(alignment: .firstTextBaseline) {
                Text(self.section.spendLine).font(.footnote).lineLimit(1)
                Spacer()
                if let percentLine = self.section.percentLine {
                    Text(percentLine)
                        .font(.footnote)
                        .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
                        .lineLimit(1)
                }
            }
            if let personalSpendLine = self.section.personalSpendLine {
                Text(personalSpendLine)
                    .font(.footnote).foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted)).lineLimit(1)
            }
        }
    }
}

private struct MetricRow: View {
    let metric: UsageMenuCardView.Model.Metric
    let title: String
    let progressColor: Color
    @Environment(\.menuItemHighlighted) private var isHighlighted

    var body: some View {
        VStack(alignment: .leading, spacing: 6) {
            Text(self.title)
                .font(.body)
                .fontWeight(.medium)
            if let statusText = self.metric.statusText {
                Text(statusText)
                    .font(.footnote)
                    .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
                    .lineLimit(1)
            } else {
                UsageProgressBar(
                    percent: self.metric.percent,
                    tint: self.progressColor,
                    accessibilityLabel: self.metric.percentStyle.accessibilityLabel,
                    pacePercent: self.metric.pacePercent,
                    paceOnTop: self.metric.paceOnTop,
                    warningMarkerPercents: self.metric.warningMarkerPercents,
                    workdayMarkerPercents: self.metric.workdayMarkerPercents)
                VStack(alignment: .leading, spacing: 2) {
                    HStack(alignment: .firstTextBaseline) {
                        Text(self.metric.percentLabel)
                            .font(.footnote)
                            .lineLimit(1)
                        Spacer()
                        if let rightLabel = self.metric.resetText {
                            Text(rightLabel)
                                .font(.footnote)
                                .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
                                .lineLimit(1)
                        }
                    }
                    if self.metric.detailLeftText != nil || self.metric.detailRightText != nil {
                        HStack(alignment: .firstTextBaseline) {
                            if let detailLeft = self.metric.detailLeftText {
                                Text(detailLeft)
                                    .font(.footnote)
                                    .foregroundStyle(MenuHighlightStyle.primary(self.isHighlighted))
                                    .lineLimit(1)
                            }
                            Spacer()
                            if let detailRight = self.metric.detailRightText {
                                Text(detailRight)
                                    .font(.footnote)
                                    .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
                                    .lineLimit(1)
                            }
                        }
                    }
                }
                .frame(maxWidth: .infinity, alignment: .leading)
                if let detail = self.metric.detailText {
                    Text(detail)
                        .font(.footnote)
                        .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
                        .lineLimit(1)
                }
            }
        }
        .frame(maxWidth: .infinity, alignment: .leading)
        .padding(self.metric.cardStyle ? 10 : 0)
        .background(self.metric.cardStyle ? Color.secondary.opacity(self.isHighlighted ? 0.2 : 0.08) : Color.clear)
        .clipShape(RoundedRectangle(cornerRadius: self.metric.cardStyle ? 10 : 0))
    }
}

private struct UsageNotesContent: View {
    let notes: [String]
    @Environment(\.menuItemHighlighted) private var isHighlighted

    var body: some View {
        VStack(alignment: .leading, spacing: 4) {
            ForEach(Array(self.notes.enumerated()), id: \.offset) { _, note in
                Text(note)
                    .font(.footnote)
                    .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
                    .lineLimit(2)
                    .fixedSize(horizontal: false, vertical: true)
            }
        }
        .frame(maxWidth: .infinity, alignment: .leading)
    }
}

struct UsageMenuCardHeaderSectionView: View {
    let model: UsageMenuCardView.Model
    let showDivider: Bool
    let width: CGFloat

    var body: some View {
        VStack(alignment: .leading, spacing: UsageMenuCardLayout.headerContentSpacing) {
            UsageMenuCardHeaderView(model: self.model, planAction: nil)

            if self.showDivider {
                Divider()
            }
        }
        .padding(.horizontal, UsageMenuCardLayout.horizontalPadding)
        .padding(.top, UsageMenuCardLayout.headerOnlyVerticalPadding)
        .padding(.bottom, self.headerBottomPadding)
        .frame(width: self.width, alignment: .leading)
    }

    private var headerBottomPadding: CGFloat {
        if self.model.subtitleStyle == .error {
            return UsageMenuCardLayout.sectionBottomPadding
        }
        return self.showDivider
            ? UsageMenuCardLayout.sectionBottomPadding
            : UsageMenuCardLayout.headerOnlyVerticalPadding
    }
}

private struct UsageMenuCardUsageContentView: View {
    let model: UsageMenuCardView.Model
    let showBottomDivider: Bool
    @Environment(\.menuItemHighlighted) private var isHighlighted

    var body: some View {
        VStack(alignment: .leading, spacing: 12) {
            ForEach(self.model.metrics, id: \.id) { metric in
                MetricRow(
                    metric: metric,
                    title: UsageMenuCardView.popupMetricTitle(provider: self.model.provider, metric: metric),
                    progressColor: self.model.progressColor)
            }
            if let resetCredits = self.model.codexResetCredits {
                if !self.model.metrics.isEmpty {
                    Divider()
                }
                CodexResetCreditsContent(presentation: resetCredits)
            }
            if let dashboard = self.model.inlineUsageDashboard {
                InlineUsageDashboardContent(model: dashboard)
            } else if !self.model.usageNotes.isEmpty {
                UsageNotesContent(notes: self.model.usageNotes)
            } else if let placeholder = self.model.placeholder, self.model.metrics.isEmpty,
                      self.model.codexResetCredits == nil
            {
                Text(placeholder)
                    .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
                    .font(.subheadline)
            }
            if self.showBottomDivider {
                Divider()
            }
        }
    }
}

struct UsageMenuCardUsageSectionView: View {
    let model: UsageMenuCardView.Model
    let showBottomDivider: Bool
    let bottomPadding: CGFloat
    let width: CGFloat
    @Environment(\.menuCardRefreshMonitor) private var refreshMonitor

    var body: some View {
        let liveModel = self.liveModel
        UsageMenuCardUsageContentView(model: liveModel, showBottomDivider: self.showBottomDivider)
            .padding(.horizontal, UsageMenuCardLayout.horizontalPadding)
            .padding(.top, UsageMenuCardLayout.usageSectionTopPadding)
            .padding(.bottom, self.bottomPadding)
            .frame(width: self.width, alignment: .leading)
    }

    private var liveModel: UsageMenuCardView.Model {
        guard self.model.usesLiveSubtitle else { return self.model }
        return self.refreshMonitor?.model(for: self.model.provider, fallback: self.model) ?? self.model
    }
}

struct UsageMenuCardCreditsSectionView: View {
    let model: UsageMenuCardView.Model
    let showBottomDivider: Bool
    let topPadding: CGFloat
    let bottomPadding: CGFloat
    let width: CGFloat
    @Environment(\.menuCardRefreshMonitor) private var refreshMonitor

    var body: some View {
        let liveModel = self.liveModel
        if let credits = liveModel.creditsText {
            VStack(alignment: .leading, spacing: 6) {
                CreditsBarContent(
                    creditsText: credits,
                    creditsRemaining: liveModel.creditsRemaining,
                    progressPercent: liveModel.creditsProgressPercent,
                    scaleText: liveModel.creditsScaleText,
                    hintText: liveModel.creditsHintText,
                    hintCopyText: liveModel.creditsHintCopyText,
                    progressColor: liveModel.progressColor)
                if self.showBottomDivider {
                    Divider()
                }
            }
            .padding(.horizontal, UsageMenuCardLayout.horizontalPadding)
            .padding(.top, self.topPadding)
            .padding(.bottom, self.bottomPadding)
            .frame(width: self.width, alignment: .leading)
        }
    }

    private var liveModel: UsageMenuCardView.Model {
        guard self.model.usesLiveSubtitle else { return self.model }
        return self.refreshMonitor?.model(for: self.model.provider, fallback: self.model) ?? self.model
    }
}

private struct CreditsBarContent: View {
    private static let fullScaleTokens: Double = 1000

    let creditsText: String
    let creditsRemaining: Double?
    var progressPercent: Double?, scaleText: String?
    let hintText: String?
    let hintCopyText: String?
    let progressColor: Color
    @Environment(\.menuItemHighlighted) private var isHighlighted

    private var percentLeft: Double? {
        if let progressPercent {
            return min(100, max(0, progressPercent))
        }
        guard let creditsRemaining else { return nil }
        let percent = (creditsRemaining / Self.fullScaleTokens) * 100
        return min(100, max(0, percent))
    }

    private var effectiveScaleText: String {
        if let scaleText {
            return scaleText
        }
        let scale = UsageFormatter.tokenCountString(Int(Self.fullScaleTokens))
        return "\(scale) \(L("tokens"))"
    }

    var body: some View {
        VStack(alignment: .leading, spacing: 6) {
            Text(L("Credits"))
                .font(.body)
                .fontWeight(.medium)
            if let percentLeft {
                UsageProgressBar(
                    percent: percentLeft,
                    tint: self.progressColor,
                    accessibilityLabel: L("Credits remaining"))
                HStack(alignment: .firstTextBaseline) {
                    Text(self.creditsText)
                        .font(.caption)
                        .lineLimit(1)
                    Spacer()
                    Text(self.effectiveScaleText)
                        .font(.caption)
                        .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
                }
            } else {
                Text(self.creditsText)
                    .font(.caption)
            }
            if let hintText, !hintText.isEmpty {
                Text(hintText)
                    .font(.footnote)
                    .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
                    .lineLimit(4)
                    .fixedSize(horizontal: false, vertical: true)
                    .overlay {
                        ClickToCopyOverlay(copyText: self.hintCopyText ?? hintText)
                    }
            }
        }
    }
}

struct UsageMenuCardCostSectionView: View {
    let model: UsageMenuCardView.Model
    let topPadding: CGFloat
    let bottomPadding: CGFloat
    let width: CGFloat
    @Environment(\.menuItemHighlighted) private var isHighlighted
    @Environment(\.menuCardRefreshMonitor) private var refreshMonitor

    var body: some View {
        let liveModel = self.liveModel
        let hasTokenCost = liveModel.tokenUsage != nil
        return Group {
            if hasTokenCost {
                VStack(alignment: .leading, spacing: 10) {
                    if let tokenUsage = liveModel.tokenUsage {
                        VStack(alignment: .leading, spacing: 6) {
                            Text(L("cost_header_estimated"))
                                .font(.body)
                                .fontWeight(.medium)
                            Text(tokenUsage.sessionLine)
                                .font(.caption)
                                .lineLimit(1)
                            Text(tokenUsage.monthLine)
                                .font(.caption)
                                .lineLimit(1)
                            ForEach(tokenUsage.comparisonLines, id: \.self) { line in
                                Text(line)
                                    .font(.caption)
                                    .lineLimit(1)
                            }
                            if let hint = tokenUsage.hintLine, !hint.isEmpty {
                                Text(hint)
                                    .font(.footnote)
                                    .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
                                    .lineLimit(4)
                                    .fixedSize(horizontal: false, vertical: true)
                            }
                            if let error = tokenUsage.errorLine, !error.isEmpty {
                                Text(error)
                                    .font(.footnote)
                                    .foregroundStyle(MenuHighlightStyle.error(self.isHighlighted))
                                    .lineLimit(4)
                                    .fixedSize(horizontal: false, vertical: true)
                                    .overlay {
                                        ClickToCopyOverlay(copyText: tokenUsage.errorCopyText ?? error)
                                    }
                            }
                        }
                    }
                }
                .padding(.horizontal, UsageMenuCardLayout.horizontalPadding)
                .padding(.top, self.topPadding)
                .padding(.bottom, self.bottomPadding)
                .frame(width: self.width, alignment: .leading)
            }
        }
    }

    private var liveModel: UsageMenuCardView.Model {
        guard self.model.usesLiveSubtitle else { return self.model }
        return self.refreshMonitor?.model(for: self.model.provider, fallback: self.model) ?? self.model
    }
}

struct UsageMenuCardExtraUsageSectionView: View {
    let model: UsageMenuCardView.Model
    let topPadding: CGFloat
    let bottomPadding: CGFloat
    let width: CGFloat
    @Environment(\.menuCardRefreshMonitor) private var refreshMonitor

    var body: some View {
        let liveModel = self.liveModel
        Group {
            if let providerCost = liveModel.providerCost {
                ProviderCostContent(
                    section: providerCost,
                    progressColor: liveModel.progressColor)
                    .padding(.horizontal, UsageMenuCardLayout.horizontalPadding)
                    .padding(.top, self.topPadding)
                    .padding(.bottom, self.bottomPadding)
                    .frame(width: self.width, alignment: .leading)
            }
        }
    }

    private var liveModel: UsageMenuCardView.Model {
        guard self.model.usesLiveSubtitle else { return self.model }
        return self.refreshMonitor?.model(for: self.model.provider, fallback: self.model) ?? self.model
    }
}

// MARK: - Model factory

extension UsageMenuCardView.Model {
    static func make(_ input: Input) -> UsageMenuCardView.Model {
        let planText = Self.plan(
            for: input.provider,
            snapshot: input.snapshot,
            account: input.account,
            override: input.planOverride,
            metadata: input.metadata)
        let metrics = Self.redactedMetrics(
            Self.metrics(input: input),
            provider: input.provider,
            hidePersonalInfo: input.hidePersonalInfo)
        let openAIAPIUsage = input.snapshot?.openAIAPIUsage
        let inlineUsageDashboard = Self.inlineUsageDashboard(input: input)
        let usageNotes = Self.usageNotes(input: input)
        let rawCreditsText: String? = if input.provider == .openrouter {
            nil
        } else if input.codexProjection != nil, !input.showOptionalCreditsAndExtraUsage {
            nil
        } else {
            Self.creditsLine(
                metadata: input.metadata,
                snapshot: input.snapshot,
                credits: input.credits,
                error: input.creditsError)
        }
        let creditsText = PersonalInfoRedactor.redactEmails(in: rawCreditsText, isEnabled: input.hidePersonalInfo)
        let creditsProgressPercent = Self.creditsProgressPercent(credits: input.credits)
        let creditsScaleText = Self.creditsScaleText(credits: input.credits)
        let codexCreditLimitDetail = Self.codexCreditLimitDetail(credits: input.credits, now: input.now)
        let isClaudeAdminAPI = input.provider == .claude &&
            input.snapshot?.identity?.loginMethod == "Admin API"
        let isRequiredOpenCodeZenBalance = Self.isRequiredOpenCodeZenBalance(input.snapshot)
        let hidesOptionalProviderCost = ((input.provider == .claude && !isClaudeAdminAPI) ||
            input.provider == .factory ||
            input.provider == .devin ||
            (input.provider == .opencodego && !isRequiredOpenCodeZenBalance)) &&
            !input.showOptionalCreditsAndExtraUsage
        let providerCost: ProviderCostSection? = if input.provider == .sakana {
            input.showOptionalCreditsAndExtraUsage
                ? Self.sakanaPayAsYouGoSection(input.snapshot?.sakanaPayAsYouGo)
                : nil
        } else if hidesOptionalProviderCost ||
            (input.provider == .openai && openAIAPIUsage != nil)
        {
            nil
        } else {
            Self.providerCostSection(provider: input.provider, cost: input.snapshot?.providerCost)
        }
        let tokenUsageSnapshot = Self.tokenUsageSnapshot(input: input)
        let tokenUsage = Self.tokenUsageSection(
            provider: input.provider,
            enabled: input.tokenCostMenuSectionEnabled,
            comparisonPeriodsEnabled: input.costComparisonPeriodsEnabled,
            snapshot: tokenUsageSnapshot,
            error: input.tokenError)
        let subtitle = Self.subtitle(
            snapshot: input.snapshot,
            isRefreshing: input.isRefreshing,
            lastError: Self.lastError(input: input),
            now: input.now)
        let redacted = Self.redactedText(input: input, subtitle: subtitle)
        let placeholder = Self.placeholder(input: input)

        return UsageMenuCardView.Model(
            provider: input.provider,
            providerName: input.metadata.displayName,
            email: redacted.email,
            subtitleText: redacted.subtitleText,
            subtitleStyle: subtitle.style,
            usesLiveSubtitle: input.usesLiveSubtitle,
            planText: planText,
            metrics: metrics,
            usageNotes: usageNotes,
            openAIAPIUsage: openAIAPIUsage,
            inlineUsageDashboard: inlineUsageDashboard,
            creditsText: creditsText,
            creditsRemaining: input.credits?.codexCreditLimit?.remaining ?? input.credits?.remaining,
            creditsProgressPercent: creditsProgressPercent,
            creditsScaleText: creditsScaleText,
            creditsHintText: codexCreditLimitDetail ?? redacted.creditsHintText,
            creditsHintCopyText: codexCreditLimitDetail ?? redacted.creditsHintCopyText,
            codexResetCredits: Self.codexResetCredits(input: input),
            providerCost: providerCost,
            tokenUsage: tokenUsage,
            placeholder: placeholder,
            progressColor: Self.progressColor(for: input.provider))
    }

    static func openRouterSpendNotes(_ usage: OpenRouterUsageSnapshot) -> [String] {
        var parts: [String] = []
        if let daily = usage.keyUsageDaily {
            parts.append("\(L("Today")): \(Self.openRouterCurrencyString(daily))")
        }
        if let weekly = usage.keyUsageWeekly {
            parts.append("\(L("This week")): \(Self.openRouterCurrencyString(weekly))")
        }
        guard !parts.isEmpty else { return [] }
        return [parts.joined(separator: " · ")]
    }

    private static func openRouterCurrencyString(_ value: Double) -> String {
        String(format: "$%.2f", value)
    }

    private static func email(
        for provider: UsageProvider,
        snapshot: UsageSnapshot?,
        account: AccountInfo,
        metadata: ProviderMetadata,
        accountIsAuthoritative: Bool) -> String
    {
        if let email = snapshot?.accountEmail(for: provider), !email.isEmpty {
            return email
        }
        if metadata.usesAccountFallback || accountIsAuthoritative,
           let email = account.email, !email.isEmpty
        {
            return email
        }
        return ""
    }

    private static func plan(
        for provider: UsageProvider,
        snapshot: UsageSnapshot?,
        account: AccountInfo,
        override: String?,
        metadata: ProviderMetadata) -> String?
    {
        if let override, !override.isEmpty {
            return override
        }
        if provider == .kiro,
           let plan = kiroPlan(snapshot: snapshot)
        {
            return plan
        }
        if provider == .kilo {
            guard let pass = self.kiloLoginPass(snapshot: snapshot) else {
                return nil
            }
            return self.planDisplay(pass, for: provider)
        }
        if let plan = snapshot?.loginMethod(for: provider), !plan.isEmpty {
            return self.planDisplay(plan, for: provider)
        }
        if metadata.usesAccountFallback,
           let plan = account.plan, !plan.isEmpty
        {
            return Self.planDisplay(plan, for: provider)
        }
        return nil
    }

    private static func planDisplay(_ text: String, for provider: UsageProvider) -> String {
        if provider == .minimax {
            return self.miniMaxPlanDisplay(text)
        }
        let cleaned = if provider == .codex {
            CodexPlanFormatting.displayName(text) ?? UsageFormatter.cleanPlanName(text)
        } else {
            UsageFormatter.cleanPlanName(text)
        }
        return cleaned.isEmpty ? text : cleaned
    }

    private static func miniMaxPlanDisplay(_ text: String) -> String {
        let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
        let normalized = trimmed.lowercased()
        if normalized.contains("tokenplanplus") || normalized.contains("token plan plus") {
            return "Plus"
        }
        if normalized.contains("tokenplanmax") || normalized.contains("token plan max") {
            return "Max"
        }
        if normalized.contains("tokenplanultra") || normalized.contains("token plan ultra") {
            return "Ultra"
        }
        return trimmed
    }

    private static func kiloLoginPass(snapshot: UsageSnapshot?) -> String? {
        self.kiloLoginParts(snapshot: snapshot).pass
    }

    static func kiloLoginDetails(snapshot: UsageSnapshot?) -> [String] {
        self.kiloLoginParts(snapshot: snapshot).details
    }

    private static func kiloLoginParts(snapshot: UsageSnapshot?) -> (pass: String?, details: [String]) {
        guard let loginMethod = snapshot?.loginMethod(for: .kilo) else {
            return (nil, [])
        }
        let parts = loginMethod
            .components(separatedBy: "·")
            .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }
            .filter { !$0.isEmpty }
        guard !parts.isEmpty else {
            return (nil, [])
        }
        let first = parts[0]
        if self.isKiloActivitySegment(first) {
            return (nil, parts)
        }
        return (first, Array(parts.dropFirst()))
    }

    private static func isKiloActivitySegment(_ text: String) -> Bool {
        let normalized = text.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
        return normalized.hasPrefix("auto top-up:")
    }

    private static func subtitle(
        snapshot: UsageSnapshot?,
        isRefreshing: Bool,
        lastError: String?,
        now: Date) -> (text: String, style: SubtitleStyle)
    {
        if let lastError, !lastError.isEmpty {
            return (lastError.trimmingCharacters(in: .whitespacesAndNewlines), .error)
        }

        if isRefreshing {
            return ("\(L("Refreshing"))…", .loading)
        }

        if let updated = snapshot?.updatedAt {
            return (UsageFormatter.updatedString(from: updated, now: now), .info)
        }

        return (L("Not fetched yet"), .info)
    }

    private struct RedactedText {
        let email: String
        let subtitleText: String
        let creditsHintText: String?
        let creditsHintCopyText: String?
    }

    private static func redactedText(
        input: Input,
        subtitle: (text: String, style: SubtitleStyle)) -> RedactedText
    {
        let email = PersonalInfoRedactor.redactEmail(
            Self.email(
                for: input.provider,
                snapshot: input.snapshot,
                account: input.account,
                metadata: input.metadata,
                accountIsAuthoritative: input.accountIsAuthoritative),
            isEnabled: input.hidePersonalInfo)
        let subtitleText = PersonalInfoRedactor.redactEmails(in: subtitle.text, isEnabled: input.hidePersonalInfo)
            ?? subtitle.text
        let creditsHintText = PersonalInfoRedactor.redactEmails(
            in: Self.dashboardHint(error: input.dashboardError),
            isEnabled: input.hidePersonalInfo)
        let creditsHintCopyText = Self.creditsHintCopyText(
            dashboardError: input.dashboardError,
            hidePersonalInfo: input.hidePersonalInfo)
        return RedactedText(
            email: email,
            subtitleText: subtitleText,
            creditsHintText: creditsHintText,
            creditsHintCopyText: creditsHintCopyText)
    }

    private static func creditsHintCopyText(dashboardError: String?, hidePersonalInfo: Bool) -> String? {
        guard let dashboardError, !dashboardError.isEmpty else { return nil }
        return hidePersonalInfo ? "" : dashboardError
    }

    private static func metrics(input: Input) -> [Metric] {
        guard let snapshot = input.snapshot else { return [] }
        if input.provider == .antigravity {
            return Self.antigravityMetrics(input: input, snapshot: snapshot)
        }
        if input.provider == .minimax {
            if let minimaxUsage = snapshot.minimaxUsage {
                let services = minimaxUsage.orderedQuotaServices
                if !services.isEmpty {
                    return Self.minimaxMetrics(services: services, input: input)
                }
            }
        }
        var metrics: [Metric] = []
        let percentStyle: PercentStyle = input.usageBarsShowUsed ? .used : .left
        let zaiUsage = input.provider == .zai ? snapshot.zaiUsage : nil
        let zaiTokenDetail = Self.zaiLimitDetailText(limit: zaiUsage?.tokenLimit)
        let zaiTimeDetail = Self.zaiLimitDetailText(limit: zaiUsage?.timeLimit)
        let zaiSessionDetail = Self.zaiLimitDetailText(limit: zaiUsage?.sessionTokenLimit)
        let openRouterQuotaDetail = Self.openRouterQuotaDetail(provider: input.provider, snapshot: snapshot)
        let labels = Self.rateWindowLabels(input: input, snapshot: snapshot)
        if input.provider == .mistral, let credits = snapshot.mistralUsage?.credits {
            metrics.append(Metric(
                id: "mistral-balance",
                title: L("Balance"),
                percent: 0,
                percentStyle: percentStyle,
                statusText: credits.formattedAvailableAmount,
                resetText: nil,
                detailText: nil,
                detailLeftText: nil,
                detailRightText: nil,
                pacePercent: nil,
                paceOnTop: true))
        }
        if input.provider == .codex, let codexProjection = input.codexProjection {
            metrics.append(contentsOf: Self.codexRateMetrics(
                input: input,
                projection: codexProjection,
                percentStyle: percentStyle))
        } else if let primary = snapshot.primary {
            metrics.append(Self.primaryMetric(
                input: input,
                primary: primary,
                percentStyle: percentStyle,
                title: labels.primary,
                zaiTokenDetail: zaiTokenDetail,
                openRouterQuotaDetail: openRouterQuotaDetail))
        }
        if input.provider != .codex, let weekly = snapshot.secondary {
            metrics.append(Self.secondaryMetric(
                input: input,
                weekly: weekly,
                percentStyle: percentStyle,
                title: labels.secondary,
                zaiTimeDetail: zaiTimeDetail))
        }
        if input.provider == .mimo, let mimoUsage = snapshot.mimoUsage {
            metrics.append(Metric(
                id: "mimo-balance",
                title: L("Balance"),
                percent: 0,
                percentStyle: percentStyle,
                statusText: mimoUsage.balanceDetail,
                resetText: nil,
                detailText: nil,
                detailLeftText: nil,
                detailRightText: nil,
                pacePercent: nil,
                paceOnTop: true))
        }
        if labels.showsTertiary, let opus = snapshot.tertiary {
            var tertiaryDetailText: String?
            if input.provider == .alibaba || input.provider == .alibabatokenplan,
               let detail = opus.resetDescription,
               !detail.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
            {
                tertiaryDetailText = detail
            }
            if input.provider == .zai, let detail = zaiSessionDetail {
                tertiaryDetailText = detail
            }
            // Perplexity purchased credits don't reset; show balance without "Resets" prefix.
            let opusResetText: String? = input.provider == .perplexity || input.provider == .sub2api
                ? opus.resetDescription?.trimmingCharacters(in: .whitespacesAndNewlines)
                : Self.resetText(for: opus, style: input.resetTimeDisplayStyle, now: input.now)
            let tertiaryPaceDetail = Self.resetWindowPaceDetail(window: opus, input: input)
            metrics.append(Metric(
                id: "tertiary",
                title: labels.tertiary,
                percent: Self.clamped(input.usageBarsShowUsed ? opus.usedPercent : opus.remainingPercent),
                percentStyle: percentStyle,
                resetText: opusResetText,
                detailText: tertiaryDetailText,
                detailLeftText: tertiaryPaceDetail?.leftLabel,
                detailRightText: tertiaryPaceDetail?.rightLabel,
                pacePercent: tertiaryPaceDetail?.pacePercent,
                paceOnTop: tertiaryPaceDetail?.paceOnTop ?? true,
                warningMarkerPercents: Self.warningMarkerPercents(
                    thresholds: input.quotaWarningThresholds[.weekly],
                    showUsed: input.usageBarsShowUsed)))
        }
        metrics.append(contentsOf: Self.extraRateWindowMetrics(
            snapshot: snapshot,
            input: input,
            percentStyle: percentStyle))
        if input.provider == .kilo || input.provider == .kimi,
           metrics.contains(where: { $0.id == "primary" }),
           metrics.contains(where: { $0.id == "secondary" })
        {
            metrics.sort { lhs, rhs in
                let primarySecondaryOrder: [String: Int] = [
                    "secondary": 0,
                    "primary": 1,
                ]
                return (primarySecondaryOrder[lhs.id] ?? Int.max) < (primarySecondaryOrder[rhs.id] ?? Int.max)
            }
        }

        if let codexProjection = input.codexProjection,
           codexProjection.supplementalMetrics.contains(.codeReview),
           let remaining = codexProjection.remainingPercent(for: .codeReview)
        {
            let percent = input.usageBarsShowUsed ? (100 - remaining) : remaining
            let resetText = codexProjection.limitWindow(for: .codeReview).flatMap {
                Self.resetText(for: $0, style: input.resetTimeDisplayStyle, now: input.now)
            }
            metrics.append(Metric(
                id: "code-review",
                title: L("Code review"),
                percent: Self.clamped(percent),
                percentStyle: percentStyle,
                resetText: resetText,
                detailText: nil,
                detailLeftText: nil,
                detailRightText: nil,
                pacePercent: nil,
                paceOnTop: true))
        }
        return metrics
    }

    private static func primaryMetric(
        input: Input,
        primary: RateWindow,
        percentStyle: PercentStyle,
        title: String? = nil,
        zaiTokenDetail: String?,
        openRouterQuotaDetail: String?) -> Metric
    {
        var primaryDetailText: String? = input.provider == .zai ? zaiTokenDetail : nil
        var primaryResetText = Self.resetText(for: primary, style: input.resetTimeDisplayStyle, now: input.now)
        var primaryDetailLeft: String?
        var primaryDetailRight: String?
        if input.provider == .crof,
           let detail = primary.resetDescription?.trimmingCharacters(in: .whitespacesAndNewlines),
           !detail.isEmpty
        {
            primaryDetailRight = detail
        }
        if input.provider == .openrouter,
           let openRouterQuotaDetail
        {
            primaryResetText = openRouterQuotaDetail
        }
        if input.provider == .copilot,
           let detail = primary.resetDescription?.trimmingCharacters(in: .whitespacesAndNewlines),
           !detail.isEmpty
        {
            primaryDetailLeft = detail
        }
        if [.warp, .kilo, .mimo, .deepseek, .qoder, .mistral, .litellm].contains(input.provider),
           let detail = primary.resetDescription,
           !detail.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
        {
            primaryDetailText = detail
        }
        if input.provider == .sub2api {
            primaryResetText = primary.resetDescription
        }
        if let balance = Self.poeBalanceDetailText(input: input) {
            primaryDetailText = balance
        }
        if input.provider == .kiro,
           let kiroUsage = input.snapshot?.kiroUsage,
           kiroUsage.creditsTotal > 0
        {
            let remaining = UsageFormatter.kiroCreditNumber(kiroUsage.creditsRemaining)
            let total = UsageFormatter.kiroCreditNumber(kiroUsage.creditsTotal)
            primaryDetailLeft = String(format: L("%@ of %@ credits left"), remaining, total)
        }
        if input.provider == .alibaba || input.provider == .alibabatokenplan || input.provider == .manus,
           let detail = primary.resetDescription,
           !detail.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
        {
            primaryDetailText = detail
            if input.provider == .manus {
                primaryResetText = nil
            }
        }
        if [.warp, .kilo, .mimo, .deepseek, .qoder, .mistral, .litellm].contains(input.provider),
           primary.resetsAt == nil
        {
            primaryResetText = nil
        }
        // Abacus: show credits as detail, compute pace on the primary monthly window
        var primaryPacePercent: Double?
        var primaryPaceOnTop = true
        if let paceDetail = Self.sessionPaceDetail(
            provider: input.provider,
            window: primary,
            now: input.now,
            showUsed: input.usageBarsShowUsed)
        {
            primaryDetailLeft = paceDetail.leftLabel
            primaryDetailRight = paceDetail.rightLabel
            primaryPacePercent = paceDetail.pacePercent
            primaryPaceOnTop = paceDetail.paceOnTop
        }
        if input.provider == .abacus {
            if let detail = primary.resetDescription,
               !detail.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
            {
                primaryDetailText = detail
            }
            if primary.resetsAt == nil {
                primaryResetText = nil
            }
            if let pace = input.weeklyPace {
                let paceDetail = Self.weeklyPaceDetail(
                    provider: input.provider,
                    window: primary,
                    now: input.now,
                    pace: pace,
                    showUsed: input.usageBarsShowUsed)
                if let paceDetail {
                    primaryDetailLeft = paceDetail.leftLabel
                    primaryDetailRight = paceDetail.rightLabel
                    primaryPacePercent = paceDetail.pacePercent
                    primaryPaceOnTop = paceDetail.paceOnTop
                }
            }
        } else if let paceDetail = Self.resetWindowPaceDetail(window: primary, input: input) {
            primaryDetailLeft = paceDetail.leftLabel
            primaryDetailRight = paceDetail.rightLabel
            primaryPacePercent = paceDetail.pacePercent
            primaryPaceOnTop = paceDetail.paceOnTop
        }
        // Legacy request-based Cursor plans: surface the raw used/limit quota on its own line,
        // since the percentage bar and pace detail alone never spell out the request cap.
        if input.provider == .cursor, let requests = input.snapshot?.cursorRequests {
            primaryDetailText = String(
                format: L("Request quota: %@ / %@"),
                "\(requests.used)",
                "\(requests.limit)")
        }
        if input.provider == .synthetic,
           let regen = Self.syntheticRollingRegenDetail(
               window: primary,
               now: input.now,
               showUsed: input.usageBarsShowUsed)
        {
            primaryResetText = regen.resetText
            primaryDetailLeft = regen.pace.leftLabel
            primaryDetailRight = regen.pace.rightLabel
            primaryPacePercent = regen.pace.pacePercent
            primaryPaceOnTop = regen.pace.paceOnTop
        }
        let usesBalanceStatusText = input.provider == .deepseek
        let primaryStatusText = usesBalanceStatusText ? primaryDetailText : nil
        if usesBalanceStatusText {
            primaryDetailText = nil
        }
        return Metric(
            id: "primary",
            title: title ?? L(input.metadata.sessionLabel),
            percent: Self.clamped(
                input.usageBarsShowUsed ? primary.usedPercent : primary.remainingPercent),
            percentStyle: percentStyle,
            statusText: primaryStatusText,
            resetText: primaryResetText,
            detailText: primaryDetailText,
            detailLeftText: primaryDetailLeft,
            detailRightText: primaryDetailRight,
            pacePercent: primaryPacePercent,
            paceOnTop: primaryPaceOnTop,
            warningMarkerPercents: Self.warningMarkerPercents(
                thresholds: input.quotaWarningThresholds[.session],
                showUsed: input.usageBarsShowUsed))
    }

    private static func secondaryMetric(
        input: Input,
        weekly: RateWindow,
        percentStyle: PercentStyle,
        title: String? = nil,
        zaiTimeDetail: String?) -> Metric
    {
        var paceDetail = Self.weeklyPaceDetail(
            provider: input.provider,
            window: weekly,
            now: input.now,
            pace: input.weeklyPace,
            showUsed: input.usageBarsShowUsed)
        var weeklyResetText = Self.resetText(for: weekly, style: input.resetTimeDisplayStyle, now: input.now)
        var weeklyDetailText: String? = input.provider == .zai ? zaiTimeDetail : nil
        if input.provider == .warp,
           let detail = weekly.resetDescription,
           !detail.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
        {
            weeklyResetText = nil
            weeklyDetailText = detail
        }
        if input.provider == .kilo || input.provider == .litellm,
           let detail = weekly.resetDescription,
           !detail.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
        {
            weeklyDetailText = detail
            if weekly.resetsAt == nil {
                weeklyResetText = nil
            }
        }
        if input.provider == .sub2api {
            weeklyResetText = weekly.resetDescription
        }
        if input.provider == .kiro,
           let kiroUsage = input.snapshot?.kiroUsage,
           let remaining = kiroUsage.bonusCreditsRemaining,
           let total = kiroUsage.bonusCreditsTotal
        {
            let remainingText = UsageFormatter.kiroCreditNumber(remaining)
            let totalText = UsageFormatter.kiroCreditNumber(total)
            paceDetail = PaceDetail(
                leftLabel: String(format: L("%@ of %@ bonus credits left"), remainingText, totalText),
                rightLabel: nil,
                pacePercent: nil,
                paceOnTop: true)
        }
        if input.provider == .alibaba || input.provider == .alibabatokenplan,
           let detail = weekly.resetDescription,
           !detail.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
        {
            weeklyDetailText = detail
        }
        if input.provider == .manus,
           let detail = weekly.resetDescription,
           !detail.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
        {
            weeklyDetailText = detail
        }
        if input.provider == .crof,
           let detail = weekly.resetDescription?.trimmingCharacters(in: .whitespacesAndNewlines),
           !detail.isEmpty
        {
            weeklyResetText = detail
        }
        if input.provider == .copilot,
           let detail = weekly.resetDescription?.trimmingCharacters(in: .whitespacesAndNewlines),
           !detail.isEmpty
        {
            paceDetail = PaceDetail(leftLabel: detail, rightLabel: nil, pacePercent: nil, paceOnTop: true)
        }
        if let cursorPaceDetail = Self.resetWindowPaceDetail(
            window: weekly,
            input: input,
            pace: input.weeklyPace)
        {
            paceDetail = cursorPaceDetail
        }
        // Perplexity bonus credits don't reset; show balance without "Resets" prefix.
        if input.provider == .perplexity,
           let detail = weekly.resetDescription?.trimmingCharacters(in: .whitespacesAndNewlines),
           !detail.isEmpty
        {
            weeklyResetText = detail
        }
        if input.provider == .synthetic,
           let regen = Self.syntheticRegenDetail(
               weekly: weekly,
               cost: input.snapshot?.providerCost,
               now: input.now,
               showUsed: input.usageBarsShowUsed)
        {
            weeklyResetText = regen.resetText
            paceDetail = regen.pace
        }
        return Metric(
            id: "secondary",
            title: title ?? L(input.metadata.weeklyLabel),
            percent: Self.clamped(input.usageBarsShowUsed ? weekly.usedPercent : weekly.remainingPercent),
            percentStyle: percentStyle,
            statusText: nil,
            resetText: weeklyResetText,
            detailText: weeklyDetailText,
            detailLeftText: paceDetail?.leftLabel,
            detailRightText: paceDetail?.rightLabel,
            pacePercent: paceDetail?.pacePercent,
            paceOnTop: paceDetail?.paceOnTop ?? true,
            warningMarkerPercents: Self.warningMarkerPercents(
                thresholds: input.quotaWarningThresholds[.weekly],
                showUsed: input.usageBarsShowUsed),
            workdayMarkerPercents: workDayMarkerPercents(
                workDays: input.workDaysPerWeek,
                windowMinutes: weekly.windowMinutes))
    }

    private static func codexRateMetrics(
        input: Input,
        projection: CodexConsumerProjection,
        percentStyle: PercentStyle) -> [Metric]
    {
        projection.visibleRateLanes.compactMap { lane in
            guard let window = projection.rateWindow(for: lane) else { return nil }

            let title: String
            let id: String
            let paceDetail: PaceDetail?
            switch lane {
            case .session:
                title = L(input.metadata.sessionLabel)
                id = "primary"
                paceDetail = Self.sessionPaceDetail(
                    provider: input.provider,
                    window: window,
                    now: input.now,
                    showUsed: input.usageBarsShowUsed)
            case .weekly:
                title = L(input.metadata.weeklyLabel)
                id = "secondary"
                paceDetail = Self.weeklyPaceDetail(
                    provider: input.provider,
                    window: window,
                    now: input.now,
                    pace: Self.standardWeeklyPace(input: input, window: window),
                    showUsed: input.usageBarsShowUsed)
            }

            return Metric(
                id: id,
                title: title,
                percent: Self.clamped(input.usageBarsShowUsed ? window.usedPercent : window.remainingPercent),
                percentStyle: percentStyle,
                resetText: Self.resetText(for: window, style: input.resetTimeDisplayStyle, now: input.now),
                detailText: nil,
                detailLeftText: paceDetail?.leftLabel,
                detailRightText: paceDetail?.rightLabel,
                pacePercent: paceDetail?.pacePercent,
                paceOnTop: paceDetail?.paceOnTop ?? true,
                warningMarkerPercents: Self.warningMarkerPercents(
                    thresholds: input.quotaWarningThresholds[lane.quotaWarningWindow],
                    showUsed: input.usageBarsShowUsed),
                workdayMarkerPercents: lane == .weekly
                    ? workDayMarkerPercents(
                        workDays: input.workDaysPerWeek,
                        windowMinutes: window.windowMinutes)
                    : [])
        }
    }
}