import Foundation
import Testing
@testable import CodexBarCore

@Suite(.serialized)
struct CursorEnterpriseUsageTests {
    @Test
    func `legacy provider cost snapshot decodes without personal spend`() throws {
        let json = """
        {
            "used": 12.5,
            "limit": 100,
            "currencyCode": "USD",
            "period": "Monthly",
            "resetsAt": null,
            "nextRegenAmount": null,
            "updatedAt": 0
        }
        """

        let snapshot = try JSONDecoder().decode(ProviderCostSnapshot.self, from: Data(json.utf8))

        #expect(snapshot.used == 12.5)
        #expect(snapshot.personalUsed == nil)
    }

    @Test
    func `parses enterprise overall and pooled usage summary`() throws {
        // Live Cursor Enterprise payload (sanitized). The Pro/Hobby `plan` block is absent;
        // instead Cursor reports `individualUsage.overall` (personal cap) and `teamUsage.pooled`
        // (shared team pool). Both blocks use cents like the existing `plan` block.
        let json = """
        {
            "billingCycleStart": "2026-04-01T00:00:00.000Z",
            "billingCycleEnd": "2026-05-01T00:00:00.000Z",
            "membershipType": "enterprise",
            "limitType": "team",
            "isUnlimited": false,
            "individualUsage": {
                "overall": {
                    "enabled": true,
                    "used": 7384,
                    "limit": 10000,
                    "remaining": 2616
                }
            },
            "teamUsage": {
                "onDemand": {
                    "enabled": true,
                    "used": 0,
                    "limit": null,
                    "remaining": null
                },
                "pooled": {
                    "enabled": true,
                    "used": 12725135,
                    "limit": 28122000,
                    "remaining": 15396865
                }
            }
        }
        """
        let data = try #require(json.data(using: .utf8))
        let summary = try JSONDecoder().decode(CursorUsageSummary.self, from: data)

        #expect(summary.membershipType == "enterprise")
        #expect(summary.limitType == "team")
        #expect(summary.individualUsage?.plan == nil)
        #expect(summary.individualUsage?.overall?.used == 7384)
        #expect(summary.individualUsage?.overall?.limit == 10000)
        #expect(summary.individualUsage?.overall?.remaining == 2616)
        #expect(summary.teamUsage?.pooled?.used == 12_725_135)
        #expect(summary.teamUsage?.pooled?.limit == 28_122_000)
    }

    @Test
    func `enterprise overall drives headline percent and dollars`() throws {
        // Regression: Cursor Enterprise/Team accounts ship `individualUsage.overall` instead of
        // `individualUsage.plan`. Without a model for `overall`, the parser used to report 0%
        // (i.e. the menu showed "100% remaining"). The personal cap must take precedence over
        // any team pool, and USD figures must reflect the same source.
        let snapshot = CursorStatusProbe(browserDetection: BrowserDetection(cacheTTL: 0))
            .parseUsageSummary(
                CursorUsageSummary(
                    billingCycleStart: "2026-04-01T00:00:00.000Z",
                    billingCycleEnd: "2026-05-01T00:00:00.000Z",
                    membershipType: "enterprise",
                    limitType: "team",
                    isUnlimited: false,
                    autoModelSelectedDisplayMessage: nil,
                    namedModelSelectedDisplayMessage: nil,
                    individualUsage: CursorIndividualUsage(
                        plan: nil,
                        onDemand: nil,
                        overall: CursorOverallUsage(enabled: true, used: 7384, limit: 10000, remaining: 2616)),
                    teamUsage: CursorTeamUsage(
                        onDemand: CursorOnDemandUsage(enabled: true, used: 0, limit: nil, remaining: nil),
                        pooled: CursorPooledUsage(
                            enabled: true,
                            used: 12_725_135,
                            limit: 28_122_000,
                            remaining: 15_396_865))),
                userInfo: nil,
                rawJSON: nil)

        // Headline: $73.84 / $100 -> 73.84% (matches Cursor's own dashboard).
        // Allow a tiny tolerance for floating-point division (7384/10000 * 100).
        #expect(abs(snapshot.planPercentUsed - 73.84) < 0.0001)
        #expect(snapshot.planUsedUSD == 73.84)
        #expect(snapshot.planLimitUSD == 100.0)
        #expect(snapshot.autoPercentUsed == nil)
        #expect(snapshot.apiPercentUsed == nil)

        let primaryPercent = try #require(snapshot.toUsageSnapshot().primary?.usedPercent)
        #expect(abs(primaryPercent - 73.84) < 0.0001)
    }

    @Test
    func `enterprise pooled fallback used when no individual data`() {
        // When Cursor only reports a shared team pool (no `plan`, no `overall`) we should still surface
        // a non-zero headline so the menu reflects pool consumption rather than appearing "all clear".
        let snapshot = CursorStatusProbe(browserDetection: BrowserDetection(cacheTTL: 0))
            .parseUsageSummary(
                CursorUsageSummary(
                    billingCycleStart: nil,
                    billingCycleEnd: nil,
                    membershipType: "enterprise",
                    limitType: "team",
                    isUnlimited: false,
                    autoModelSelectedDisplayMessage: nil,
                    namedModelSelectedDisplayMessage: nil,
                    individualUsage: nil,
                    teamUsage: CursorTeamUsage(
                        onDemand: nil,
                        pooled: CursorPooledUsage(
                            enabled: true,
                            used: 12_725_135,
                            limit: 28_122_000,
                            remaining: 15_396_865))),
                userInfo: nil,
                rawJSON: nil)

        #expect(snapshot.planPercentUsed > 45.0)
        #expect(snapshot.planPercentUsed < 45.5)
        #expect(snapshot.planUsedUSD == 127_251.35)
        #expect(snapshot.planLimitUSD == 281_220.0)
    }

    @Test
    func `team on-demand pool is the budget and personal spend rides along`() {
        // Live team-plan payload (sanitized): the user's own on-demand spend has no personal limit,
        // so the team pool is the headline budget. The personal spend must still be surfaced.
        let snapshot = CursorStatusProbe(browserDetection: BrowserDetection(cacheTTL: 0))
            .parseUsageSummary(
                CursorUsageSummary(
                    billingCycleStart: "2026-06-01T00:00:00.000Z",
                    billingCycleEnd: "2026-07-01T00:00:00.000Z",
                    membershipType: "enterprise",
                    limitType: "team",
                    isUnlimited: false,
                    autoModelSelectedDisplayMessage: nil,
                    namedModelSelectedDisplayMessage: nil,
                    individualUsage: CursorIndividualUsage(
                        plan: CursorPlanUsage(
                            enabled: true,
                            used: 2000,
                            limit: 2000,
                            remaining: 0,
                            breakdown: nil,
                            autoPercentUsed: 0,
                            apiPercentUsed: 100,
                            totalPercentUsed: 100),
                        onDemand: CursorOnDemandUsage(enabled: true, used: 4471, limit: nil, remaining: nil),
                        overall: nil),
                    teamUsage: CursorTeamUsage(
                        onDemand: CursorOnDemandUsage(
                            enabled: true,
                            used: 1_311_125,
                            limit: 2_000_000,
                            remaining: 688_875),
                        pooled: nil)),
                userInfo: nil,
                rawJSON: nil)

        let cost = snapshot.toUsageSnapshot().providerCost
        #expect(cost?.used == 13111.25) // team pool used
        #expect(cost?.limit == 20000.0) // team pool limit
        #expect(cost?.personalUsed == 44.71) // this account's own on-demand spend
    }

    @Test
    func `personal on-demand limit keeps personal budget with no rider`() {
        // When the user has their own on-demand limit, that is the budget and there is no separate rider.
        let snapshot = CursorStatusProbe(browserDetection: BrowserDetection(cacheTTL: 0))
            .parseUsageSummary(
                CursorUsageSummary(
                    billingCycleStart: nil,
                    billingCycleEnd: nil,
                    membershipType: "pro",
                    limitType: "user",
                    isUnlimited: false,
                    autoModelSelectedDisplayMessage: nil,
                    namedModelSelectedDisplayMessage: nil,
                    individualUsage: CursorIndividualUsage(
                        plan: nil,
                        onDemand: CursorOnDemandUsage(enabled: true, used: 4471, limit: 10000, remaining: 5529),
                        overall: nil),
                    teamUsage: nil),
                userInfo: nil,
                rawJSON: nil)

        let cost = snapshot.toUsageSnapshot().providerCost
        #expect(cost?.used == 44.71)
        #expect(cost?.limit == 100.0)
        #expect(cost?.personalUsed == nil)
    }

    @Test
    func `existing plan block still wins over overall and pooled`() {
        // Guard against future drift: when Cursor sends both legacy `plan` and the newer `overall`
        // blocks, the existing percent precedence must remain intact.
        let snapshot = CursorStatusProbe(browserDetection: BrowserDetection(cacheTTL: 0))
            .parseUsageSummary(
                CursorUsageSummary(
                    billingCycleStart: nil,
                    billingCycleEnd: nil,
                    membershipType: "pro",
                    limitType: "user",
                    isUnlimited: false,
                    autoModelSelectedDisplayMessage: nil,
                    namedModelSelectedDisplayMessage: nil,
                    individualUsage: CursorIndividualUsage(
                        plan: CursorPlanUsage(
                            enabled: true,
                            used: 1500,
                            limit: 5000,
                            remaining: 3500,
                            breakdown: nil,
                            autoPercentUsed: nil,
                            apiPercentUsed: nil,
                            totalPercentUsed: 30.0),
                        onDemand: nil,
                        overall: CursorOverallUsage(enabled: true, used: 7384, limit: 10000, remaining: 2616)),
                    teamUsage: CursorTeamUsage(
                        onDemand: nil,
                        pooled: CursorPooledUsage(
                            enabled: true,
                            used: 12_725_135,
                            limit: 28_122_000,
                            remaining: 15_396_865))),
                userInfo: nil,
                rawJSON: nil)

        #expect(snapshot.planPercentUsed == 30.0)
        #expect(snapshot.planUsedUSD == 15.0)
        #expect(snapshot.planLimitUSD == 50.0)
    }
}