import Foundation
import Testing
@testable import CodexBarCore

struct ZaiSettingsReaderTests {
    @Test
    func `api token reads from environment`() {
        let token = ZaiSettingsReader.apiToken(environment: ["Z_AI_API_KEY": "abc123"])
        #expect(token == "abc123")
    }

    @Test
    func `api token strips quotes`() {
        let token = ZaiSettingsReader.apiToken(environment: ["Z_AI_API_KEY": "\"token-xyz\""])
        #expect(token == "token-xyz")
    }

    @Test
    func `api host reads from environment`() {
        let host = ZaiSettingsReader.apiHost(environment: [ZaiSettingsReader.apiHostKey: " open.bigmodel.cn "])
        #expect(host == "open.bigmodel.cn")
    }

    @Test
    func `quota URL infers scheme`() {
        let url = ZaiSettingsReader
            .quotaURL(environment: [ZaiSettingsReader.quotaURLKey: "open.bigmodel.cn/api/coding"])
        #expect(url?.absoluteString == "https://open.bigmodel.cn/api/coding")
    }

    @Test
    func `endpoint override validation accepts HTTPS and bare hosts`() throws {
        try ZaiSettingsReader.validateEndpointOverrides(environment: [
            ZaiSettingsReader.quotaURLKey: "https://open.bigmodel.cn/api/coding",
        ])
        try ZaiSettingsReader.validateEndpointOverrides(environment: [
            ZaiSettingsReader.apiHostKey: "open.bigmodel.cn",
        ])
    }

    @Test
    func `endpoint override validation rejects insecure URLs`() {
        #expect(throws: ZaiSettingsError.invalidEndpointOverride(ZaiSettingsReader.quotaURLKey)) {
            try ZaiSettingsReader.validateEndpointOverrides(environment: [
                ZaiSettingsReader.quotaURLKey: "http://attacker.test/quota",
            ])
        }
        #expect(throws: ZaiSettingsError.invalidEndpointOverride(ZaiSettingsReader.apiHostKey)) {
            try ZaiSettingsReader.validateEndpointOverrides(environment: [
                ZaiSettingsReader.apiHostKey: "http://attacker.test",
            ])
        }
    }
}

struct ZaiUsageSnapshotTests {
    @Test
    func `maps usage snapshot windows`() {
        let reset = Date(timeIntervalSince1970: 123)
        let tokenLimit = ZaiLimitEntry(
            type: .tokensLimit,
            unit: .hours,
            number: 5,
            usage: 100,
            currentValue: 20,
            remaining: 80,
            percentage: 25,
            usageDetails: [],
            nextResetTime: reset)
        let timeLimit = ZaiLimitEntry(
            type: .timeLimit,
            unit: .days,
            number: 30,
            usage: 200,
            currentValue: 40,
            remaining: 160,
            percentage: 50,
            usageDetails: [],
            nextResetTime: nil)
        let snapshot = ZaiUsageSnapshot(
            tokenLimit: tokenLimit,
            timeLimit: timeLimit,
            planName: nil,
            updatedAt: reset)

        let usage = snapshot.toUsageSnapshot()

        #expect(usage.primary?.usedPercent == 20)
        #expect(usage.primary?.windowMinutes == 300)
        #expect(usage.primary?.resetsAt == reset)
        #expect(usage.primary?.resetDescription == "5 hours window")
        #expect(usage.secondary?.usedPercent == 20)
        #expect(usage.secondary?.resetDescription == "30 days window")
        #expect(usage.tertiary == nil)
        #expect(usage.zaiUsage?.tokenLimit?.usage == 100)
        #expect(usage.zaiUsage?.sessionTokenLimit == nil)
    }

    @Test
    func `maps usage snapshot windows with missing fields`() {
        let reset = Date(timeIntervalSince1970: 123)
        let tokenLimit = ZaiLimitEntry(
            type: .tokensLimit,
            unit: .hours,
            number: 5,
            usage: nil,
            currentValue: nil,
            remaining: nil,
            percentage: 25,
            usageDetails: [],
            nextResetTime: reset)
        let snapshot = ZaiUsageSnapshot(
            tokenLimit: tokenLimit,
            timeLimit: nil,
            planName: nil,
            updatedAt: reset)

        let usage = snapshot.toUsageSnapshot()

        #expect(usage.primary?.usedPercent == 25)
        #expect(usage.primary?.windowMinutes == 300)
        #expect(usage.primary?.resetsAt == reset)
        #expect(usage.primary?.resetDescription == "5 hours window")
        #expect(usage.zaiUsage?.tokenLimit?.usage == nil)
    }

    @Test
    func `maps usage snapshot windows with missing remaining uses current value`() {
        let reset = Date(timeIntervalSince1970: 123)
        let tokenLimit = ZaiLimitEntry(
            type: .tokensLimit,
            unit: .hours,
            number: 5,
            usage: 100,
            currentValue: 20,
            remaining: nil,
            percentage: 25,
            usageDetails: [],
            nextResetTime: reset)
        let snapshot = ZaiUsageSnapshot(
            tokenLimit: tokenLimit,
            timeLimit: nil,
            planName: nil,
            updatedAt: reset)

        let usage = snapshot.toUsageSnapshot()

        #expect(usage.primary?.usedPercent == 20)
    }

    @Test
    func `maps usage snapshot windows with missing current value uses remaining`() {
        let reset = Date(timeIntervalSince1970: 123)
        let tokenLimit = ZaiLimitEntry(
            type: .tokensLimit,
            unit: .hours,
            number: 5,
            usage: 100,
            currentValue: nil,
            remaining: 80,
            percentage: 25,
            usageDetails: [],
            nextResetTime: reset)
        let snapshot = ZaiUsageSnapshot(
            tokenLimit: tokenLimit,
            timeLimit: nil,
            planName: nil,
            updatedAt: reset)

        let usage = snapshot.toUsageSnapshot()

        #expect(usage.primary?.usedPercent == 20)
    }

    @Test
    func `maps usage snapshot windows with missing remaining and current value falls back to percentage`() {
        let reset = Date(timeIntervalSince1970: 123)
        let tokenLimit = ZaiLimitEntry(
            type: .tokensLimit,
            unit: .hours,
            number: 5,
            usage: 100,
            currentValue: nil,
            remaining: nil,
            percentage: 25,
            usageDetails: [],
            nextResetTime: reset)
        let snapshot = ZaiUsageSnapshot(
            tokenLimit: tokenLimit,
            timeLimit: nil,
            planName: nil,
            updatedAt: reset)

        let usage = snapshot.toUsageSnapshot()

        #expect(usage.primary?.usedPercent == 25)
    }
}

struct ZaiUsageParsingTests {
    @Test
    func `empty body returns parse failed`() {
        #expect {
            _ = try ZaiUsageFetcher.parseUsageSnapshot(from: Data())
        } throws: { error in
            guard case let ZaiUsageError.parseFailed(message) = error else { return false }
            return message == "Empty response body"
        }
    }

    @Test
    func `parses usage response`() throws {
        let json = """
        {
          "code": 200,
          "msg": "Operation successful",
          "data": {
            "limits": [
              {
                "type": "TIME_LIMIT",
                "unit": 5,
                "number": 1,
                "usage": 100,
                "currentValue": 102,
                "remaining": 0,
                "percentage": 100,
                "usageDetails": [
                  { "modelCode": "search-prime", "usage": 95 }
                ]
              },
              {
                "type": "TOKENS_LIMIT",
                "unit": 3,
                "number": 5,
                "usage": 40000000,
                "currentValue": 13628365,
                "remaining": 26371635,
                "percentage": 34,
                "nextResetTime": 1768507567547
              }
            ],
            "planName": "Pro"
          },
          "success": true
        }
        """

        let snapshot = try ZaiUsageFetcher.parseUsageSnapshot(from: Data(json.utf8))

        #expect(snapshot.planName == "Pro")
        #expect(snapshot.tokenLimit?.usage == 40_000_000)
        #expect(snapshot.timeLimit?.usageDetails.first?.modelCode == "search-prime")
        #expect(snapshot.tokenLimit?.percentage == 34.0)

        let usage = snapshot.toUsageSnapshot()
        #expect(usage.secondary?.windowMinutes == nil)
        #expect(usage.secondary?.resetDescription == "Monthly")
    }

    @Test
    func `zai mcp time limit displays monthly instead of one minute window`() throws {
        let json = """
        {
          "code": 200,
          "msg": "Operation successful",
          "data": {
            "limits": [
              {
                "type": "TIME_LIMIT",
                "unit": 5,
                "number": 1,
                "usage": 100,
                "currentValue": 50,
                "remaining": 50,
                "percentage": 50,
                "usageDetails": []
              },
              {
                "type": "TOKENS_LIMIT",
                "unit": 3,
                "number": 5,
                "percentage": 34,
                "nextResetTime": 1768507567547
              }
            ]
          },
          "success": true
        }
        """

        let snapshot = try ZaiUsageFetcher.parseUsageSnapshot(from: Data(json.utf8))
        let usage = snapshot.toUsageSnapshot()

        #expect(snapshot.timeLimit?.windowDescription == "1 minute")
        #expect(usage.secondary?.windowMinutes == nil)
        #expect(usage.secondary?.resetDescription == "Monthly")
    }

    @Test
    func `missing data returns api error`() {
        let json = """
        { "code": 1001, "msg": "Authorization Token Missing", "success": false }
        """

        #expect {
            _ = try ZaiUsageFetcher.parseUsageSnapshot(from: Data(json.utf8))
        } throws: { error in
            guard case let ZaiUsageError.apiError(message) = error else { return false }
            return message == "Authorization Token Missing"
        }
    }

    @Test
    func `failed response without message reports the API code`() {
        let json = """
        { "code": 1001, "success": false }
        """

        #expect {
            _ = try ZaiUsageFetcher.parseUsageSnapshot(from: Data(json.utf8))
        } throws: { error in
            guard case let ZaiUsageError.apiError(message) = error else { return false }
            return message == "Z.ai quota API returned code 1001"
        }
    }

    @Test
    func `success without data returns parse failed`() {
        let json = """
        { "code": 200, "msg": "Operation successful", "success": true }
        """

        #expect {
            _ = try ZaiUsageFetcher.parseUsageSnapshot(from: Data(json.utf8))
        } throws: { error in
            guard case let ZaiUsageError.parseFailed(message) = error else { return false }
            return message == "Missing data"
        }
    }

    @Test
    func `success without limits parses empty usage`() throws {
        let json = """
        {
          "code": 200,
          "msg": "Operation successful",
          "data": { "planName": "Pro" },
          "success": true
        }
        """

        let snapshot = try ZaiUsageFetcher.parseUsageSnapshot(from: Data(json.utf8))

        #expect(snapshot.planName == "Pro")
        #expect(snapshot.tokenLimit == nil)
        #expect(snapshot.timeLimit == nil)
    }

    @Test
    func `parses new schema with missing token limit fields`() throws {
        let json = """
        {
          "code": 200,
          "msg": "Operation successful",
          "data": {
            "limits": [
              {
                "type": "TIME_LIMIT",
                "unit": 5,
                "number": 1,
                "usage": 100,
                "currentValue": 0,
                "remaining": 100,
                "percentage": 0,
                "usageDetails": [
                  { "modelCode": "search-prime", "usage": 0 },
                  { "modelCode": "web-reader", "usage": 1 },
                  { "modelCode": "zread", "usage": 0 }
                ]
              },
              {
                "type": "TOKENS_LIMIT",
                "unit": 3,
                "number": 5,
                "percentage": 1,
                "nextResetTime": 1770724088678
              }
            ]
          },
          "success": true
        }
        """

        let snapshot = try ZaiUsageFetcher.parseUsageSnapshot(from: Data(json.utf8))

        #expect(snapshot.tokenLimit?.percentage == 1.0)
        #expect(snapshot.tokenLimit?.usage == nil)
        #expect(snapshot.tokenLimit?.currentValue == nil)
        #expect(snapshot.tokenLimit?.remaining == nil)
        #expect(snapshot.tokenLimit?.usedPercent == 1.0)
        #expect(snapshot.tokenLimit?.windowMinutes == 300)
        #expect(snapshot.timeLimit?.usage == 100)
    }

    @Test
    func `parses BigModel CN quota response without message`() throws {
        let json = """
        {
          "code": 200,
          "data": {
            "limits": [
              {
                "type": "TIME_LIMIT",
                "unit": 5,
                "number": 1,
                "usage": 1000,
                "currentValue": 147,
                "remaining": 853,
                "percentage": 14,
                "nextResetTime": 1784706344993,
                "usageDetails": [
                  { "modelCode": "search-prime", "usage": 84 },
                  { "modelCode": "web-reader", "usage": 41 },
                  { "modelCode": "zread", "usage": 8 }
                ]
              },
              {
                "type": "TOKENS_LIMIT",
                "unit": 3,
                "number": 5,
                "percentage": 8,
                "nextResetTime": 1783049703178
              },
              {
                "type": "TOKENS_LIMIT",
                "unit": 6,
                "number": 1,
                "percentage": 7,
                "nextResetTime": 1783496744998
              }
            ],
            "level": "pro"
          },
          "success": true
        }
        """

        let snapshot = try ZaiUsageFetcher.parseUsageSnapshot(from: Data(json.utf8))
        let usage = snapshot.toUsageSnapshot()

        #expect(usage.primary?.usedPercent == 7)
        #expect(usage.secondary?.usedPercent == 14.7)
        #expect(usage.tertiary?.usedPercent == 8)
    }
}

struct ZaiBigModelTeamScopeTests {
    @Test
    func `team scope appends type 2 and sends BigModel project headers`() async throws {
        let transport = ProviderHTTPTransportStub { request in
            let json = """
            {
              "code": 200,
              "msg": "操作成功",
              "data": {
                "level": "pro",
                "limits": [
                  {
                    "type": "TIME_LIMIT",
                    "unit": 5,
                    "number": 1,
                    "usage": 1000,
                    "currentValue": 224,
                    "remaining": 776,
                    "percentage": 22,
                    "nextResetTime": 1777575229998,
                    "usageDetails": []
                  },
                  {
                    "type": "TOKENS_LIMIT",
                    "unit": 3,
                    "number": 5,
                    "percentage": 25,
                    "nextResetTime": 1775020168897
                  },
                  {
                    "type": "TOKENS_LIMIT",
                    "unit": 6,
                    "number": 1,
                    "percentage": 9,
                    "nextResetTime": 1775588029998
                  }
                ]
              },
              "success": true
            }
            """
            return (
                Data(json.utf8),
                HTTPURLResponse(
                    url: request.url!,
                    statusCode: 200,
                    httpVersion: nil,
                    headerFields: nil)!)
        }

        let snapshot = try await ZaiUsageFetcher.fetchUsage(
            apiKey: "zai-test-token",
            region: .bigmodelCN,
            usageScope: .team,
            teamContext: ZaiBigModelTeamContext(
                organizationID: "org-test",
                projectID: "proj-test"),
            environment: [:],
            transport: transport)

        let requests = await transport.requests()
        let request = try #require(requests.first)

        #expect(request.url?.absoluteString == "https://open.bigmodel.cn/api/monitor/usage/quota/limit?type=2")
        #expect(request.value(forHTTPHeaderField: "Authorization") == "Bearer zai-test-token")
        #expect(request.value(forHTTPHeaderField: "Bigmodel-Organization") == "org-test")
        #expect(request.value(forHTTPHeaderField: "Bigmodel-Project") == "proj-test")
        #expect(snapshot.tokenLimit?.unit == .weeks)
        #expect(snapshot.sessionTokenLimit?.unit == .hours)
        #expect(snapshot.timeLimit?.usage == 1000)
    }

    @Test
    func `personal scope keeps existing quota URL and omits team headers`() async throws {
        let transport = ProviderHTTPTransportStub { request in
            let json = """
            {
              "code": 200,
              "msg": "Operation successful",
              "data": {
                "limits": [
                  {
                    "type": "TOKENS_LIMIT",
                    "unit": 3,
                    "number": 5,
                    "percentage": 34,
                    "nextResetTime": 1768507567547
                  }
                ]
              },
              "success": true
            }
            """
            return (
                Data(json.utf8),
                HTTPURLResponse(
                    url: request.url!,
                    statusCode: 200,
                    httpVersion: nil,
                    headerFields: nil)!)
        }

        _ = try await ZaiUsageFetcher.fetchUsage(
            apiKey: "zai-test-token",
            region: .bigmodelCN,
            usageScope: .personal,
            teamContext: ZaiBigModelTeamContext(
                organizationID: "org-test",
                projectID: "proj-test"),
            environment: [:],
            transport: transport)

        let requests = await transport.requests()
        let request = try #require(requests.first)

        #expect(request.url?.absoluteString == "https://open.bigmodel.cn/api/monitor/usage/quota/limit")
        #expect(request.value(forHTTPHeaderField: "Bigmodel-Organization") == nil)
        #expect(request.value(forHTTPHeaderField: "Bigmodel-Project") == nil)
    }

    @Test
    func `team scope requires complete BigModel context`() async {
        let transport = ProviderHTTPTransportStub { request in
            (
                Data(),
                HTTPURLResponse(
                    url: request.url!,
                    statusCode: 200,
                    httpVersion: nil,
                    headerFields: nil)!)
        }

        await self.expectMissingTeamContext {
            _ = try await ZaiUsageFetcher.fetchUsage(
                apiKey: "zai-test-token",
                region: .bigmodelCN,
                usageScope: .team,
                teamContext: nil,
                environment: [:],
                transport: transport)
        }

        let requests = await transport.requests()
        #expect(requests.isEmpty)

        await self.expectMissingTeamContext {
            _ = try await ZaiUsageFetcher.fetchUsage(
                apiKey: "zai-test-token",
                region: .bigmodelCN,
                usageScope: .team,
                teamContext: nil,
                environment: [ZaiSettingsReader.bigModelOrganizationKey: "org-only"],
                transport: transport)
        }

        await self.expectMissingTeamContext {
            _ = try await ZaiUsageFetcher.fetchUsage(
                apiKey: "zai-test-token",
                region: .bigmodelCN,
                usageScope: .team,
                teamContext: nil,
                environment: [ZaiSettingsReader.bigModelProjectKey: "proj-only"],
                transport: transport)
        }
    }

    @Test
    func `team model usage appends type 3 and sends BigModel project headers`() async throws {
        let transport = ProviderHTTPTransportStub { request in
            let json = """
            {
              "code": 200,
              "msg": "success",
              "success": true,
              "data": {
                "x_time": ["2026-06-21 08:00"],
                "modelDataList": [
                  { "modelName": "glm-4.6", "tokensUsage": [100] }
                ]
              }
            }
            """
            return (
                Data(json.utf8),
                HTTPURLResponse(
                    url: request.url!,
                    statusCode: 200,
                    httpVersion: nil,
                    headerFields: nil)!)
        }

        let usage = try await ZaiUsageFetcher.fetchModelUsage(
            apiKey: "zai-test-token",
            region: .bigmodelCN,
            usageScope: .team,
            teamContext: ZaiBigModelTeamContext(
                organizationID: "org-test",
                projectID: "proj-test"),
            environment: [:],
            transport: transport)

        let requests = await transport.requests()
        let request = try #require(requests.first)
        let requestURL = try #require(request.url)
        let components = try #require(URLComponents(url: requestURL, resolvingAgainstBaseURL: false))

        #expect(components.path == "/api/monitor/usage/model-usage")
        #expect(components.queryItems?.first { $0.name == "type" }?.value == "3")
        #expect(request.value(forHTTPHeaderField: "Authorization") == "Bearer zai-test-token")
        #expect(request.value(forHTTPHeaderField: "Bigmodel-Organization") == "org-test")
        #expect(request.value(forHTTPHeaderField: "Bigmodel-Project") == "proj-test")
        #expect(usage.modelNames == ["glm-4.6"])
    }

    @Test
    func `team quota rejects insecure override before sending credentials`() async throws {
        let transport = ProviderHTTPTransportStub { request in
            Issue.record("Unexpected z.ai team quota request to \(request.url?.absoluteString ?? "<nil>")")
            throw URLError(.badURL)
        }

        await #expect(throws: ZaiSettingsError.invalidEndpointOverride(ZaiSettingsReader.quotaURLKey)) {
            try await ZaiUsageFetcher.fetchUsage(
                apiKey: "zai-test-token",
                region: .bigmodelCN,
                usageScope: .team,
                teamContext: ZaiBigModelTeamContext(
                    organizationID: "org-test",
                    projectID: "proj-test"),
                environment: [ZaiSettingsReader.quotaURLKey: "http://attacker.test/quota"],
                transport: transport)
        }

        let requests = await transport.requests()
        #expect(requests.isEmpty)
    }

    @Test
    func `team model usage rejects insecure API host before sending credentials`() async throws {
        let transport = ProviderHTTPTransportStub { request in
            Issue.record("Unexpected z.ai team model usage request to \(request.url?.absoluteString ?? "<nil>")")
            throw URLError(.badURL)
        }

        await #expect(throws: ZaiSettingsError.invalidEndpointOverride(ZaiSettingsReader.apiHostKey)) {
            try await ZaiUsageFetcher.fetchModelUsage(
                apiKey: "zai-test-token",
                region: .bigmodelCN,
                usageScope: .team,
                teamContext: ZaiBigModelTeamContext(
                    organizationID: "org-test",
                    projectID: "proj-test"),
                environment: [ZaiSettingsReader.apiHostKey: "http://attacker.test"],
                transport: transport)
        }

        let requests = await transport.requests()
        #expect(requests.isEmpty)
    }

    private func expectMissingTeamContext(_ operation: () async throws -> Void) async {
        do {
            try await operation()
            Issue.record("Expected z.ai missing team context error.")
        } catch ZaiUsageError.missingTeamContext {
            // Expected.
        } catch {
            Issue.record("Expected z.ai missing team context error, got \(error).")
        }
    }

    @Test
    func `team context can be resolved from environment`() {
        let env = [
            ZaiSettingsReader.bigModelOrganizationKey: " org-env ",
            ZaiSettingsReader.bigModelProjectKey: " proj-env ",
        ]

        #expect(ZaiBigModelTeamContext(environment: env)?.organizationID == "org-env")
        #expect(ZaiBigModelTeamContext(environment: env)?.projectID == "proj-env")
    }
}

struct ZaiHourlyUsageTests {
    @Test
    func `model usage parser decodes hourly model payload`() throws {
        let json = """
        {
          "code": 200,
          "msg": "success",
          "success": true,
          "data": {
            "x_time": ["2026-05-14 08:00", "2026-05-14 09:00"],
            "modelDataList": [
              { "modelName": "glm-4.6", "tokensUsage": [100, null] },
              { "modelName": "glm-4.5", "tokensUsage": [50, 25] }
            ]
          }
        }
        """

        let usage = try ZaiUsageFetcher.parseModelUsage(from: Data(json.utf8))

        #expect(usage.xTime == ["2026-05-14 08:00", "2026-05-14 09:00"])
        #expect(usage.modelNames == ["glm-4.6", "glm-4.5"])
        #expect(usage.modelDataList[0].tokensUsage == [100, nil])
        #expect(usage.modelDataList[1].tokensUsage == [50, 25])
    }

    @Test
    func `today hourly bars filter earlier days and skip empty hours`() {
        let reference = Self.localDate(year: 2026, month: 5, day: 14, hour: 12)
        let yesterday = Calendar.current.date(byAdding: .day, value: -1, to: reference) ?? reference
        let modelData = ZaiModelUsageData(
            xTime: [
                Self.hourString(yesterday),
                "2026-05-14 08:00",
                "2026-05-14 09:00",
            ],
            modelDataList: [
                ZaiModelDataItem(modelName: "glm-4.6", tokensUsage: [999, 100, 0]),
                ZaiModelDataItem(modelName: "glm-4.5", tokensUsage: [0, 50, nil]),
            ])

        let bars = ZaiHourlyBars.from(modelData: modelData, range: .today(referenceDate: reference), now: reference)

        #expect(bars.map(\.label) == ["08"])
        #expect(bars.first?.totalTokens == 150)
        #expect(bars.first?.segments.count == 2)
    }

    @Test
    func `last 24 hour bars filter data outside trailing window`() {
        let reference = Self.localDate(year: 2026, month: 5, day: 14, hour: 12)
        let old = Calendar.current.date(byAdding: .hour, value: -25, to: reference) ?? reference
        let inWindow = Calendar.current.date(byAdding: .hour, value: -23, to: reference) ?? reference
        let modelData = ZaiModelUsageData(
            xTime: [
                Self.hourString(old),
                Self.hourString(inWindow),
                Self.hourString(reference),
            ],
            modelDataList: [
                ZaiModelDataItem(modelName: "glm-4.6", tokensUsage: [10, 20, 30]),
            ])

        let bars = ZaiHourlyBars.from(modelData: modelData, range: .last24h, now: reference)

        #expect(bars.map(\.label) == [Self.hourLabel(inWindow), Self.hourLabel(reference)])
        #expect(bars.map(\.totalTokens) == [20, 30])
    }

    private static func localDate(year: Int, month: Int, day: Int, hour: Int) -> Date {
        Calendar.current.date(from: DateComponents(year: year, month: month, day: day, hour: hour)) ?? Date()
    }

    private static func hourString(_ date: Date) -> String {
        let formatter = DateFormatter()
        formatter.dateFormat = "yyyy-MM-dd HH:mm"
        formatter.locale = Locale(identifier: "en_US_POSIX")
        return formatter.string(from: date)
    }

    private static func hourLabel(_ date: Date) -> String {
        let formatter = DateFormatter()
        formatter.dateFormat = "HH"
        formatter.locale = Locale(identifier: "en_US_POSIX")
        return formatter.string(from: date)
    }
}

struct ZaiThreeLimitTests {
    @Test
    func `parses three limit entries into session weekly and mcp slots`() throws {
        let json = """
        {
          "code": 200,
          "msg": "操作成功",
          "data": {
            "limits": [
              {
                "type": "TOKENS_LIMIT",
                "unit": 3,
                "number": 5,
                "percentage": 25,
                "nextResetTime": 1775020168897
              },
              {
                "type": "TOKENS_LIMIT",
                "unit": 6,
                "number": 1,
                "percentage": 9,
                "nextResetTime": 1775588029998
              },
              {
                "type": "TIME_LIMIT",
                "unit": 5,
                "number": 1,
                "usage": 1000,
                "currentValue": 224,
                "remaining": 776,
                "percentage": 22,
                "nextResetTime": 1777575229998,
                "usageDetails": [
                  { "modelCode": "search-prime", "usage": 210 },
                  { "modelCode": "web-reader", "usage": 14 }
                ]
              }
            ],
            "level": "pro"
          },
          "success": true
        }
        """

        let snapshot = try ZaiUsageFetcher.parseUsageSnapshot(from: Data(json.utf8))

        // Weekly token limit (unit:6=weeks, longer window) → tokenLimit (primary)
        #expect(snapshot.tokenLimit?.unit == .weeks)
        #expect(snapshot.tokenLimit?.number == 1)
        #expect(snapshot.tokenLimit?.percentage == 9.0)
        #expect(snapshot.tokenLimit?.windowMinutes == 10080)

        // 5-hour token limit (unit:3=hours, number:5 → 300 min) → sessionTokenLimit (tertiary)
        #expect(snapshot.sessionTokenLimit?.unit == .hours)
        #expect(snapshot.sessionTokenLimit?.number == 5)
        #expect(snapshot.sessionTokenLimit?.percentage == 25.0)
        #expect(snapshot.sessionTokenLimit?.windowMinutes == 300)

        // MCP time limit → timeLimit (secondary)
        #expect(snapshot.timeLimit?.usage == 1000)
        #expect(snapshot.timeLimit?.usageDetails.first?.modelCode == "search-prime")

        // UsageSnapshot slot mapping
        let usage = snapshot.toUsageSnapshot()
        #expect(usage.primary?.usedPercent == 9.0)
        #expect(usage.primary?.windowMinutes == 10080)
        #expect(usage.secondary != nil) // MCP
        #expect(usage.tertiary?.usedPercent == 25.0)
        #expect(usage.tertiary?.windowMinutes == 300)
    }

    @Test
    func `unit 6 maps to weeks with correct window minutes`() {
        let entry = ZaiLimitEntry(
            type: .tokensLimit,
            unit: .weeks,
            number: 1,
            usage: nil,
            currentValue: nil,
            remaining: nil,
            percentage: 9,
            usageDetails: [],
            nextResetTime: nil)
        #expect(entry.windowMinutes == 10080)
        #expect(entry.windowDescription == "1 week")
        #expect(entry.windowLabel == "1 week window")
    }

    @Test
    func `two limit entries remain backward compatible`() throws {
        let json = """
        {
          "code": 200,
          "msg": "Operation successful",
          "data": {
            "limits": [
              {
                "type": "TIME_LIMIT",
                "unit": 5,
                "number": 1,
                "usage": 100,
                "currentValue": 50,
                "remaining": 50,
                "percentage": 50,
                "usageDetails": []
              },
              {
                "type": "TOKENS_LIMIT",
                "unit": 3,
                "number": 5,
                "percentage": 34,
                "nextResetTime": 1768507567547
              }
            ]
          },
          "success": true
        }
        """

        let snapshot = try ZaiUsageFetcher.parseUsageSnapshot(from: Data(json.utf8))

        #expect(snapshot.tokenLimit != nil)
        #expect(snapshot.sessionTokenLimit == nil)
        #expect(snapshot.timeLimit != nil)

        let usage = snapshot.toUsageSnapshot()
        #expect(usage.primary != nil)
        #expect(usage.secondary != nil)
        #expect(usage.tertiary == nil)
    }
}

struct ZaiAPIRegionTests {
    @Test
    func `dashboard URLs follow selected region`() {
        #expect(
            ZaiAPIRegion.global.dashboardURL.absoluteString ==
                "https://z.ai/manage-apikey/coding-plan/personal/my-plan")
        #expect(
            ZaiAPIRegion.bigmodelCN.dashboardURL.absoluteString ==
                "https://bigmodel.cn/coding-plan/personal/usage")
        #expect(
            ZaiProviderDescriptor.descriptor.metadata.dashboardURL ==
                ZaiAPIRegion.global.dashboardURL.absoluteString)
    }

    @Test
    func `defaults to global endpoint`() {
        let url = ZaiUsageFetcher.resolveQuotaURL(region: .global, environment: [:])
        #expect(url.absoluteString == "https://api.z.ai/api/monitor/usage/quota/limit")
    }

    @Test
    func `uses big model region when selected`() {
        let url = ZaiUsageFetcher.resolveQuotaURL(region: .bigmodelCN, environment: [:])
        #expect(url.absoluteString == "https://open.bigmodel.cn/api/monitor/usage/quota/limit")
    }

    @Test
    func `quota url environment override wins`() {
        let env = [ZaiSettingsReader.quotaURLKey: "https://open.bigmodel.cn/api/coding/paas/v4"]
        let url = ZaiUsageFetcher.resolveQuotaURL(region: .global, environment: env)
        #expect(url.absoluteString == "https://open.bigmodel.cn/api/coding/paas/v4")
    }

    @Test
    func `api host environment appends quota path`() {
        let env = [ZaiSettingsReader.apiHostKey: "open.bigmodel.cn"]
        let url = ZaiUsageFetcher.resolveQuotaURL(region: .global, environment: env)
        #expect(url.absoluteString == "https://open.bigmodel.cn/api/monitor/usage/quota/limit")
    }

    @Test
    func `dashboard follows known endpoint overrides`() {
        let china = ZaiUsageFetcher.resolveDashboardURL(
            region: .global,
            environment: [ZaiSettingsReader.apiHostKey: "open.bigmodel.cn"])
        #expect(china == ZaiAPIRegion.bigmodelCN.dashboardURL)

        let global = ZaiUsageFetcher.resolveDashboardURL(
            region: .bigmodelCN,
            environment: [ZaiSettingsReader.apiHostKey: "api.z.ai"])
        #expect(global == ZaiAPIRegion.global.dashboardURL)
    }

    @Test
    func `dashboard keeps selected region for custom endpoint override`() {
        let dashboard = ZaiUsageFetcher.resolveDashboardURL(
            region: .bigmodelCN,
            environment: [ZaiSettingsReader.apiHostKey: "zai.internal.example"])

        #expect(dashboard == ZaiAPIRegion.bigmodelCN.dashboardURL)
    }
}