import Foundation

public struct PerplexityUsageSnapshot: Sendable {
    public let recurringTotal: Double
    public let recurringUsed: Double
    public let promoTotal: Double
    public let promoUsed: Double
    public let purchasedTotal: Double
    public let purchasedUsed: Double
    public let balanceCents: Double
    public let totalUsageCents: Double
    public let renewalDate: Date
    public let promoExpiration: Date?
    public let updatedAt: Date

    public init(response: PerplexityCreditsResponse, now: Date) {
        let recurring = response.creditGrants.filter { $0.type == "recurring" }
        let promotional = response.creditGrants.filter {
            $0.type == "promotional" && ($0.expiresAtTs ?? .infinity) > now.timeIntervalSince1970
        }
        let purchased = response.creditGrants.filter { $0.type == "purchased" }

        // All timestamps from the Perplexity API are Unix seconds (verified Feb 2026).
        let recurringSum = max(0, recurring.reduce(0.0) { $0 + $1.amountCents })
        let promoSum = max(0, promotional.reduce(0.0) { $0 + $1.amountCents })
        // Purchased credits may appear in the top-level field, in the credit_grants
        // array (type == "purchased"), or both. Take whichever is larger to avoid
        // double-counting while still catching either source.
        let purchasedFromGrants = max(0, purchased.reduce(0.0) { $0 + $1.amountCents })
        let purchasedFromField = max(0, response.currentPeriodPurchasedCents)
        let purchasedSum = max(purchasedFromGrants, purchasedFromField)

        // Waterfall attribution: recurring → purchased → promotional
        var remaining = response.totalUsageCents
        let usedFromRecurring = min(remaining, recurringSum); remaining -= usedFromRecurring
        let usedFromPurchased = min(remaining, purchasedSum); remaining -= usedFromPurchased
        let usedFromPromo = min(remaining, promoSum)

        self.recurringTotal = recurringSum
        self.recurringUsed = usedFromRecurring
        self.promoTotal = promoSum
        self.promoUsed = usedFromPromo
        self.purchasedTotal = purchasedSum
        self.purchasedUsed = usedFromPurchased
        self.balanceCents = response.balanceCents
        self.totalUsageCents = response.totalUsageCents
        self.renewalDate = Date(timeIntervalSince1970: response.renewalDateTs)
        self.promoExpiration = promotional
            .compactMap { $0.expiresAtTs.map { Date(timeIntervalSince1970: $0) } }
            .min()
        self.updatedAt = now
    }

    /// Infer plan name from recurring credit allotment.
    /// Free = 0, Pro = small pool (~500–1000), Max = 10,000+.
    public var planName: String? {
        if self.recurringTotal <= 0 { return nil }
        if self.recurringTotal < 5000 { return "Pro" }
        return "Max"
    }

    private static let promoExpiryFormatter: DateFormatter = {
        let fmt = DateFormatter()
        fmt.dateFormat = "MMM d"
        return fmt
    }()
}

extension PerplexityUsageSnapshot {
    public func toUsageSnapshot() -> UsageSnapshot {
        // Primary: recurring (monthly) credits
        let hasFallbackCredits = self.promoTotal > 0 || self.purchasedTotal > 0
        let primaryWindow: RateWindow? = {
            if self.recurringTotal > 0 {
                let primaryPercent = min(100, max(0, self.recurringUsed / self.recurringTotal * 100))
                return RateWindow(
                    usedPercent: primaryPercent,
                    windowMinutes: nil,
                    resetsAt: self.renewalDate,
                    resetDescription: "\(Int(self.recurringUsed.rounded()))/\(Int(self.recurringTotal)) credits")
            }
            if hasFallbackCredits {
                // When recurring is absent but bonus/purchased credits remain, omit the fake 0/0 primary lane
                // so automatic menu-bar rendering can fall through to the usable pool.
                return nil
            }
            return RateWindow(
                usedPercent: 100,
                windowMinutes: nil,
                resetsAt: self.renewalDate,
                resetDescription: "0/0 credits")
        }()

        // Secondary: promotional bonus credits — always shown.
        // usedPercent=100 when promoTotal==0 so the bar renders empty rather than full.
        let promoPercent = self.promoTotal > 0
            ? min(100, max(0, self.promoUsed / self.promoTotal * 100))
            : 100.0
        var promoDesc = "\(Int(promoUsed.rounded()))/\(Int(self.promoTotal)) bonus"
        if let expiry = promoExpiration {
            promoDesc += " \u{00b7} exp. \(Self.promoExpiryFormatter.string(from: expiry))"
        }
        let secondary = RateWindow(
            usedPercent: promoPercent,
            windowMinutes: nil,
            resetsAt: nil,
            resetDescription: promoDesc)

        // Tertiary: on-demand purchased credits — always shown.
        // usedPercent=100 when purchasedTotal==0 so the bar renders empty rather than full.
        let purchasedPercent = self.purchasedTotal > 0
            ? min(100, max(0, self.purchasedUsed / self.purchasedTotal * 100))
            : 100.0
        let tertiary = RateWindow(
            usedPercent: purchasedPercent,
            windowMinutes: nil,
            resetsAt: nil,
            resetDescription: "\(Int(purchasedUsed.rounded()))/\(Int(self.purchasedTotal)) credits")

        let identity = ProviderIdentitySnapshot(
            providerID: .perplexity,
            accountEmail: nil,
            accountOrganization: nil,
            loginMethod: planName)

        return UsageSnapshot(
            primary: primaryWindow,
            secondary: secondary,
            tertiary: tertiary,
            providerCost: nil,
            updatedAt: self.updatedAt,
            identity: identity)
    }
}