import Foundation
import Testing
@testable import CodexBarCore

struct StepFunSettingsReaderTests {
    @Test
    func `reads STEPFUN_TOKEN`() {
        let env = ["STEPFUN_TOKEN": "some-oasis-token-value"]
        #expect(StepFunSettingsReader.token(environment: env) == "some-oasis-token-value")
    }

    @Test
    func `reads STEPFUN_USERNAME`() {
        let env = ["STEPFUN_USERNAME": "user@example.com"]
        #expect(StepFunSettingsReader.username(environment: env) == "user@example.com")
    }

    @Test
    func `reads STEPFUN_PASSWORD`() {
        let env = ["STEPFUN_PASSWORD": "secret123"]
        #expect(StepFunSettingsReader.password(environment: env) == "secret123")
    }

    @Test
    func `trims whitespace from token`() {
        let env = ["STEPFUN_TOKEN": "  some-token  "]
        #expect(StepFunSettingsReader.token(environment: env) == "some-token")
    }

    @Test
    func `strips double quotes from token`() {
        let env = ["STEPFUN_TOKEN": "\"some-token\""]
        #expect(StepFunSettingsReader.token(environment: env) == "some-token")
    }

    @Test
    func `strips single quotes from token`() {
        let env = ["STEPFUN_TOKEN": "'some-token'"]
        #expect(StepFunSettingsReader.token(environment: env) == "some-token")
    }

    @Test
    func `returns nil when no env vars present`() {
        #expect(StepFunSettingsReader.token(environment: [:]) == nil)
        #expect(StepFunSettingsReader.username(environment: [:]) == nil)
        #expect(StepFunSettingsReader.password(environment: [:]) == nil)
    }

    @Test
    func `returns nil for empty values`() {
        let env = ["STEPFUN_TOKEN": "", "STEPFUN_USERNAME": "", "STEPFUN_PASSWORD": ""]
        #expect(StepFunSettingsReader.token(environment: env) == nil)
        #expect(StepFunSettingsReader.username(environment: env) == nil)
        #expect(StepFunSettingsReader.password(environment: env) == nil)
    }

    @Test
    func `returns nil for whitespace-only values`() {
        let env = ["STEPFUN_TOKEN": "   "]
        #expect(StepFunSettingsReader.token(environment: env) == nil)
    }
}

struct StepFunProviderTokenResolverTests {
    @Test
    func `resolves token from environment`() {
        let env = ["STEPFUN_TOKEN": "my-test-token"]
        let resolution = ProviderTokenResolver.stepfunResolution(environment: env)
        #expect(resolution?.token == "my-test-token")
        #expect(resolution?.source == .environment)
    }

    @Test
    func `returns nil when token absent`() {
        let resolution = ProviderTokenResolver.stepfunResolution(environment: [:])
        #expect(resolution == nil)
    }
}

struct StepFunUsageFetcherParsingTests {
    @Test
    func `parses real API response format with string timestamps and integer rates`() throws {
        // This matches the actual StepFun API response format:
        // - timestamps as strings (e.g. "1777528800")
        // - rates can be integers (e.g. 1) or floats (e.g. 0.99781543)
        let json = """
        {
            "status": 1,
            "desc": "",
            "five_hour_usage_left_rate": 1,
            "five_hour_usage_reset_time": "1777528800",
            "weekly_usage_left_rate": 0.99781543,
            "weekly_usage_reset_time": "1777899600"
        }
        """
        let data = Data(json.utf8)
        let snapshot = try StepFunUsageFetcher._parseSnapshotForTesting(data)

        #expect(snapshot.fiveHourUsageLeftRate == 1.0)
        #expect(snapshot.weeklyUsageLeftRate > 0.997 && snapshot.weeklyUsageLeftRate < 0.998)
    }

    @Test
    func `parses response with float rates and integer timestamps`() throws {
        let json = """
        {
            "status": 1,
            "five_hour_usage_left_rate": 0.75,
            "weekly_usage_left_rate": 0.5,
            "five_hour_usage_reset_time": 1746000000,
            "weekly_usage_reset_time": 1746500000
        }
        """
        let data = Data(json.utf8)
        let snapshot = try StepFunUsageFetcher._parseSnapshotForTesting(data)

        #expect(snapshot.fiveHourUsageLeftRate == 0.75)
        #expect(snapshot.weeklyUsageLeftRate == 0.5)
    }

    @Test
    func `throws on failed API status`() {
        let json = """
        {
            "status": 0,
            "message": "Unauthorized",
            "five_hour_usage_left_rate": 0.75,
            "weekly_usage_left_rate": 0.5,
            "five_hour_usage_reset_time": "1746000000",
            "weekly_usage_reset_time": "1746500000"
        }
        """
        let data = Data(json.utf8)
        #expect(throws: StepFunUsageError.self) {
            try StepFunUsageFetcher._parseSnapshotForTesting(data)
        }
    }

    @Test
    func `throws on missing fields`() {
        let json = """
        {
            "status": 1
        }
        """
        let data = Data(json.utf8)
        #expect(throws: StepFunUsageError.self) {
            try StepFunUsageFetcher._parseSnapshotForTesting(data)
        }
    }

    @Test
    func `throws on invalid JSON`() {
        let data = Data("not json".utf8)
        #expect(throws: StepFunUsageError.self) {
            try StepFunUsageFetcher._parseSnapshotForTesting(data)
        }
    }

    @Test
    func `snapshot maps to UsageSnapshot correctly`() throws {
        let json = """
        {
            "status": 1,
            "five_hour_usage_left_rate": 0.8,
            "weekly_usage_left_rate": 0.6,
            "five_hour_usage_reset_time": "1746000000",
            "weekly_usage_reset_time": "1746500000"
        }
        """
        let data = Data(json.utf8)
        let snapshot = try StepFunUsageFetcher._parseSnapshotForTesting(data)
        let usage = snapshot.toUsageSnapshot()

        // Five-hour window: 20% used (1.0 - 0.8)
        let primaryUsed = usage.primary?.usedPercent ?? 0
        #expect(primaryUsed > 19.9 && primaryUsed < 20.1)

        // Weekly window: 40% used (1.0 - 0.6)
        let secondaryUsed = usage.secondary?.usedPercent ?? 0
        #expect(secondaryUsed > 39.9 && secondaryUsed < 40.1)
        #expect(usage.secondary?.windowMinutes == 10080)

        // Identity
        #expect(usage.identity?.providerID == .stepfun)
        #expect(usage.identity?.loginMethod == "password")
    }

    @Test
    func `clamps used percent to 0-100 range`() throws {
        let json = """
        {
            "status": 1,
            "five_hour_usage_left_rate": 0.0,
            "weekly_usage_left_rate": 1,
            "five_hour_usage_reset_time": "1746000000",
            "weekly_usage_reset_time": "1746500000"
        }
        """
        let data = Data(json.utf8)
        let snapshot = try StepFunUsageFetcher._parseSnapshotForTesting(data)
        let usage = snapshot.toUsageSnapshot()

        // 0% remaining → 100% used
        #expect(usage.primary?.usedPercent == 100.0)
        // 100% remaining → 0% used (integer 1 parsed as 1.0)
        #expect(usage.secondary?.usedPercent == 0.0)
    }
}

struct StepFunTokenNormalizerTests {
    @Test
    func `extracts Oasis-Token from cookie header`() {
        let input = "Oasis-Token=abc123...def456; Oasis-Webid=someid"
        #expect(StepFunTokenNormalizer.normalize(input) == "abc123...def456")
    }

    @Test
    func `returns raw value when not a cookie header`() {
        let input = "abc123...def456"
        #expect(StepFunTokenNormalizer.normalize(input) == "abc123...def456")
    }

    @Test
    func `returns empty for empty string`() {
        #expect(StepFunTokenNormalizer.normalize("").isEmpty)
    }

    @Test
    func `trims whitespace`() {
        #expect(StepFunTokenNormalizer.normalize("  token123  ") == "token123")
    }
}

@Suite(.serialized)
struct StepFunTokenRefreshTests {
    private struct StubClaudeFetcher: ClaudeUsageFetching {
        func loadLatestUsage(model _: String) async throws -> ClaudeUsageSnapshot {
            throw ClaudeUsageError.parseFailed("stub")
        }

        func debugRawProbe(model _: String) async -> String {
            "stub"
        }

        func detectVersion() -> String? {
            nil
        }
    }

    @Test
    func `refresh token returns combined token pair`() async throws {
        try await self.withStubProtocol { recorder in
            StepFunStubURLProtocol.handler = { request in
                #expect(request.url?.path.contains("RefreshToken") == true)
                #expect(request.value(forHTTPHeaderField: "Oasis-Token") == "old-access...old-refresh")
                #expect(request.value(forHTTPHeaderField: "Cookie")?.contains("old-access...old-refresh") == true)
                recorder.recordRefreshCall()
                return Self.jsonResponse(
                    for: request,
                    body: """
                    {
                        "accessToken": {"raw": "new-access"},
                        "refreshToken": {"raw": "new-refresh"}
                    }
                    """)
            }

            let token = try await StepFunUsageFetcher.refreshToken(token: "old-access...old-refresh")
            #expect(token == "new-access...new-refresh")
            #expect(recorder.refreshCallCount == 1)
        }
    }

    @Test
    func `manual token auth failure refreshes token account and retries usage`() async throws {
        let accountID = UUID()
        let updateRecorder = StepFunTokenUpdateRecorder()

        try await self.withStubProtocol { recorder in
            StepFunStubURLProtocol.handler = { request in
                let path = request.url?.path ?? ""
                if path.contains("QueryStepPlanRateLimit") {
                    let call = recorder.recordUsageCall()
                    if call == 1 {
                        #expect(request.value(forHTTPHeaderField: "Cookie")?
                            .contains("old-access...old-refresh") == true)
                        return Self.jsonResponse(for: request, statusCode: 401, body: #"{"error":"unauthorized"}"#)
                    }

                    #expect(request.value(forHTTPHeaderField: "Cookie")?.contains("new-access...new-refresh") == true)
                    return Self.usageResponse(for: request)
                }

                if path.contains("RefreshToken") {
                    recorder.recordRefreshCall()
                    #expect(request.value(forHTTPHeaderField: "Oasis-Token") == "old-access...old-refresh")
                    return Self.jsonResponse(
                        for: request,
                        body: """
                        {
                            "accessToken": {"raw": "new-access"},
                            "refreshToken": {"raw": "new-refresh"}
                        }
                        """)
                }

                if path.contains("GetStepPlanStatus") {
                    return Self.jsonResponse(
                        for: request,
                        body: #"{"status":1,"subscription":{"name":"Plus","plan_type":1,"status":1}}"#)
                }

                return Self.jsonResponse(for: request, statusCode: 404, body: #"{"error":"unexpected"}"#)
            }

            let settings = ProviderSettingsSnapshot.make(
                stepfun: ProviderSettingsSnapshot.StepFunProviderSettings(
                    cookieSource: .manual,
                    manualToken: "old-access...old-refresh"))
            let context = self.makeContext(
                settings: settings,
                selectedTokenAccountID: accountID,
                tokenUpdater: { provider, updatedAccountID, token in
                    #expect(provider == .stepfun)
                    #expect(updatedAccountID == accountID)
                    await updateRecorder.record(token)
                })

            let result = try await StepFunWebFetchStrategy().fetch(context)

            #expect(result.usage.identity?.loginMethod == "Plus")
            #expect(recorder.usageCallCount == 2)
            #expect(recorder.refreshCallCount == 1)
            let updatedToken = await updateRecorder.recordedToken()
            #expect(updatedToken == "new-access...new-refresh")
        }
    }

    @Test
    func `manual token auth failure refreshes settings token and retries usage`() async throws {
        let updateRecorder = StepFunTokenUpdateRecorder()

        try await self.withStubProtocol { recorder in
            StepFunStubURLProtocol.handler = { request in
                let path = request.url?.path ?? ""
                if path.contains("QueryStepPlanRateLimit") {
                    let call = recorder.recordUsageCall()
                    if call == 1 {
                        return Self.jsonResponse(for: request, statusCode: 401, body: #"{"error":"unauthorized"}"#)
                    }

                    #expect(request.value(forHTTPHeaderField: "Cookie")?.contains("new-access...new-refresh") == true)
                    return Self.usageResponse(for: request)
                }

                if path.contains("RefreshToken") {
                    recorder.recordRefreshCall()
                    return Self.jsonResponse(
                        for: request,
                        body: """
                        {
                            "accessToken": {"raw": "new-access"},
                            "refreshToken": {"raw": "new-refresh"}
                        }
                        """)
                }

                if path.contains("GetStepPlanStatus") {
                    return Self.jsonResponse(
                        for: request,
                        body: #"{"status":1,"subscription":{"name":"Plus","plan_type":1,"status":1}}"#)
                }

                return Self.jsonResponse(for: request, statusCode: 404, body: #"{"error":"unexpected"}"#)
            }

            let settings = ProviderSettingsSnapshot.make(
                stepfun: ProviderSettingsSnapshot.StepFunProviderSettings(
                    cookieSource: .manual,
                    manualToken: "old-access...old-refresh"))
            let context = self.makeContext(
                settings: settings,
                manualTokenUpdater: { provider, token in
                    #expect(provider == .stepfun)
                    await updateRecorder.record(token)
                })

            _ = try await StepFunWebFetchStrategy().fetch(context)

            #expect(recorder.usageCallCount == 2)
            #expect(recorder.refreshCallCount == 1)
            let updatedToken = await updateRecorder.recordedToken()
            #expect(updatedToken == "new-access...new-refresh")
        }
    }

    @Test
    func `stale cached token falls back to configured env token`() async throws {
        CookieHeaderCache.store(provider: .stepfun, cookieHeader: "stale-access...stale-refresh", sourceLabel: "test")
        defer { CookieHeaderCache.clear(provider: .stepfun) }

        try await self.withStubProtocol { recorder in
            StepFunStubURLProtocol.handler = { request in
                let path = request.url?.path ?? ""
                if path.contains("QueryStepPlanRateLimit") {
                    let call = recorder.recordUsageCall()
                    if call == 1 {
                        #expect(request.value(forHTTPHeaderField: "Cookie")?
                            .contains("stale-access...stale-refresh") == true)
                        return Self.jsonResponse(for: request, statusCode: 401, body: #"{"error":"unauthorized"}"#)
                    }

                    #expect(request.value(forHTTPHeaderField: "Cookie")?.contains("env-access...env-refresh") == true)
                    return Self.usageResponse(for: request)
                }

                if path.contains("RefreshToken") {
                    recorder.recordRefreshCall()
                    return Self.jsonResponse(for: request, statusCode: 401, body: #"{"error":"expired"}"#)
                }

                if path.contains("GetStepPlanStatus") {
                    return Self.jsonResponse(
                        for: request,
                        body: #"{"status":1,"subscription":{"name":"Plus","plan_type":1,"status":1}}"#)
                }

                return Self.jsonResponse(for: request, statusCode: 404, body: #"{"error":"unexpected"}"#)
            }

            let settings = ProviderSettingsSnapshot.make(
                stepfun: ProviderSettingsSnapshot.StepFunProviderSettings(cookieSource: .auto))
            let context = self.makeContext(
                settings: settings,
                env: ["STEPFUN_TOKEN": "env-access...env-refresh"])

            _ = try await StepFunWebFetchStrategy().fetch(context)

            #expect(recorder.usageCallCount == 2)
            #expect(recorder.refreshCallCount == 1)
            #expect(CookieHeaderCache.load(provider: .stepfun) == nil)
        }
    }

    @Test
    func `stale cached and env tokens fall back to env login credentials`() async throws {
        CookieHeaderCache.store(provider: .stepfun, cookieHeader: "stale-access...stale-refresh", sourceLabel: "test")
        defer { CookieHeaderCache.clear(provider: .stepfun) }

        try await self.withStubProtocol { recorder in
            StepFunStubURLProtocol.handler = { request in
                let path = request.url?.path ?? ""
                if path.isEmpty || path == "/" {
                    return Self.jsonResponse(
                        for: request,
                        body: "{}",
                        headers: ["Set-Cookie": "INGRESSCOOKIE=ingress-cookie; Path=/"])
                }

                if path.contains("RegisterDevice") {
                    return Self.jsonResponse(
                        for: request,
                        body: """
                        {
                            "accessToken": {"raw": "anon-access"},
                            "refreshToken": {"raw": "anon-refresh"}
                        }
                        """)
                }

                if path.contains("SignInByPassword") {
                    return Self.jsonResponse(
                        for: request,
                        body: """
                        {
                            "accessToken": {"raw": "login-access"},
                            "refreshToken": {"raw": "login-refresh"}
                        }
                        """)
                }

                if path.contains("QueryStepPlanRateLimit") {
                    let call = recorder.recordUsageCall()
                    if call == 1 {
                        #expect(request.value(forHTTPHeaderField: "Cookie")?
                            .contains("stale-access...stale-refresh") == true)
                        return Self.jsonResponse(for: request, statusCode: 401, body: #"{"error":"unauthorized"}"#)
                    }
                    if call == 2 {
                        #expect(request.value(forHTTPHeaderField: "Cookie")?
                            .contains("env-access...env-refresh") == true)
                        return Self.jsonResponse(for: request, statusCode: 401, body: #"{"error":"unauthorized"}"#)
                    }

                    #expect(request.value(forHTTPHeaderField: "Cookie")?
                        .contains("login-access...login-refresh") == true)
                    return Self.usageResponse(for: request)
                }

                if path.contains("RefreshToken") {
                    recorder.recordRefreshCall()
                    return Self.jsonResponse(for: request, statusCode: 401, body: #"{"error":"expired"}"#)
                }

                if path.contains("GetStepPlanStatus") {
                    return Self.jsonResponse(
                        for: request,
                        body: #"{"status":1,"subscription":{"name":"Plus","plan_type":1,"status":1}}"#)
                }

                return Self.jsonResponse(for: request, statusCode: 404, body: #"{"error":"unexpected"}"#)
            }

            let settings = ProviderSettingsSnapshot.make(
                stepfun: ProviderSettingsSnapshot.StepFunProviderSettings(cookieSource: .auto))
            let context = self.makeContext(
                settings: settings,
                env: [
                    "STEPFUN_TOKEN": "env-access...env-refresh",
                    "STEPFUN_USERNAME": "user@example.com",
                    "STEPFUN_PASSWORD": "password",
                ])

            _ = try await StepFunWebFetchStrategy().fetch(context)

            #expect(recorder.usageCallCount == 3)
            #expect(recorder.refreshCallCount == 1)
            #expect(CookieHeaderCache.load(provider: .stepfun)?.cookieHeader == "login-access...login-refresh")
        }
    }

    @Test
    func `post refresh non auth usage failure is not rewritten as auth guidance`() async throws {
        try await self.withStubProtocol { recorder in
            StepFunStubURLProtocol.handler = { request in
                let path = request.url?.path ?? ""
                if path.contains("QueryStepPlanRateLimit") {
                    let call = recorder.recordUsageCall()
                    if call == 1 {
                        return Self.jsonResponse(for: request, statusCode: 401, body: #"{"error":"unauthorized"}"#)
                    }
                    return Self.jsonResponse(for: request, statusCode: 500, body: #"{"error":"temporary"}"#)
                }

                if path.contains("RefreshToken") {
                    recorder.recordRefreshCall()
                    return Self.jsonResponse(
                        for: request,
                        body: """
                        {
                            "accessToken": {"raw": "new-access"},
                            "refreshToken": {"raw": "new-refresh"}
                        }
                        """)
                }

                return Self.jsonResponse(for: request, statusCode: 404, body: #"{"error":"unexpected"}"#)
            }

            let settings = ProviderSettingsSnapshot.make(
                stepfun: ProviderSettingsSnapshot.StepFunProviderSettings(
                    cookieSource: .manual,
                    manualToken: "old-access...old-refresh"))
            let context = self.makeContext(settings: settings)

            do {
                _ = try await StepFunWebFetchStrategy().fetch(context)
                Issue.record("Expected post-refresh usage failure")
            } catch let StepFunUsageError.apiError(message) {
                #expect(message == "HTTP 500")
            } catch {
                Issue.record("Expected StepFunUsageError.apiError, got \(error)")
            }

            #expect(recorder.usageCallCount == 2)
            #expect(recorder.refreshCallCount == 1)
        }
    }

    @Test
    func `manual token refresh failure does not fall back to ambient env credentials`() async throws {
        try await self.withStubProtocol { recorder in
            StepFunStubURLProtocol.handler = { request in
                let path = request.url?.path ?? ""
                if path.contains("QueryStepPlanRateLimit") {
                    _ = recorder.recordUsageCall()
                    return Self.jsonResponse(for: request, statusCode: 401, body: #"{"error":"unauthorized"}"#)
                }

                if path.contains("RefreshToken") {
                    recorder.recordRefreshCall()
                    return Self.jsonResponse(for: request, statusCode: 401, body: #"{"error":"expired"}"#)
                }

                Issue.record("Manual token recovery should not call login endpoint: \(path)")
                return Self.jsonResponse(for: request, statusCode: 404, body: #"{"error":"unexpected"}"#)
            }

            let settings = ProviderSettingsSnapshot.make(
                stepfun: ProviderSettingsSnapshot.StepFunProviderSettings(
                    cookieSource: .manual,
                    manualToken: "old-access...old-refresh"))
            let context = self.makeContext(
                settings: settings,
                env: [
                    "STEPFUN_USERNAME": "someone@example.com",
                    "STEPFUN_PASSWORD": "secret",
                ])

            do {
                _ = try await StepFunWebFetchStrategy().fetch(context)
                Issue.record("Expected manual token auth failure")
            } catch let StepFunUsageError.apiError(message) {
                #expect(message.contains("Refresh the Oasis-Token"))
            } catch {
                Issue.record("Expected StepFunUsageError.apiError, got \(error)")
            }

            #expect(recorder.usageCallCount == 1)
            #expect(recorder.refreshCallCount == 1)
        }
    }

    @Test
    func `non auth token wording does not trigger refresh recovery`() async throws {
        try await self.withStubProtocol { recorder in
            StepFunStubURLProtocol.handler = { request in
                let path = request.url?.path ?? ""
                if path.contains("QueryStepPlanRateLimit") {
                    _ = recorder.recordUsageCall()
                    return Self.jsonResponse(
                        for: request,
                        body: #"{"status":0,"message":"token plan status temporarily unavailable"}"#)
                }

                Issue.record("Non-auth usage error should not call recovery endpoint: \(path)")
                return Self.jsonResponse(for: request, statusCode: 404, body: #"{"error":"unexpected"}"#)
            }

            let settings = ProviderSettingsSnapshot.make(
                stepfun: ProviderSettingsSnapshot.StepFunProviderSettings(
                    cookieSource: .manual,
                    manualToken: "old-access...old-refresh"))
            let context = self.makeContext(settings: settings)

            do {
                _ = try await StepFunWebFetchStrategy().fetch(context)
                Issue.record("Expected provider API error")
            } catch let StepFunUsageError.apiError(message) {
                #expect(message == "token plan status temporarily unavailable")
            } catch {
                Issue.record("Expected StepFunUsageError.apiError, got \(error)")
            }

            #expect(recorder.usageCallCount == 1)
            #expect(recorder.refreshCallCount == 0)
        }
    }

    private func makeContext(
        settings: ProviderSettingsSnapshot?,
        env: [String: String] = [:],
        selectedTokenAccountID: UUID? = nil,
        tokenUpdater: ProviderFetchContext.TokenAccountTokenUpdater? = nil,
        manualTokenUpdater: ProviderFetchContext.ProviderManualTokenUpdater? = nil) -> ProviderFetchContext
    {
        ProviderFetchContext(
            runtime: .app,
            sourceMode: .auto,
            includeCredits: false,
            webTimeout: 1,
            webDebugDumpHTML: false,
            verbose: false,
            env: env,
            settings: settings,
            fetcher: UsageFetcher(environment: [:]),
            claudeFetcher: StubClaudeFetcher(),
            browserDetection: BrowserDetection(cacheTTL: 0),
            selectedTokenAccountID: selectedTokenAccountID,
            tokenAccountTokenUpdater: tokenUpdater,
            providerManualTokenUpdater: manualTokenUpdater)
    }

    private func withStubProtocol(
        _ body: (StepFunRequestRecorder) async throws -> Void) async throws
    {
        let recorder = StepFunRequestRecorder()
        let registered = URLProtocol.registerClass(StepFunStubURLProtocol.self)
        defer {
            if registered {
                URLProtocol.unregisterClass(StepFunStubURLProtocol.self)
            }
            StepFunStubURLProtocol.handler = nil
        }
        try await body(recorder)
    }

    private static func usageResponse(for request: URLRequest) -> (HTTPURLResponse, Data) {
        self.jsonResponse(
            for: request,
            body: """
            {
                "status": 1,
                "five_hour_usage_left_rate": 0.8,
                "weekly_usage_left_rate": 0.6,
                "five_hour_usage_reset_time": "1777528800",
                "weekly_usage_reset_time": "1777899600"
            }
            """)
    }

    private static func jsonResponse(
        for request: URLRequest,
        statusCode: Int = 200,
        body: String,
        headers: [String: String] = ["Content-Type": "application/json"]) -> (HTTPURLResponse, Data)
    {
        let response = HTTPURLResponse(
            url: request.url!,
            statusCode: statusCode,
            httpVersion: nil,
            headerFields: headers)!
        return (response, Data(body.utf8))
    }
}

private actor StepFunTokenUpdateRecorder {
    private var token: String?

    func record(_ token: String) {
        self.token = token
    }

    func recordedToken() -> String? {
        self.token
    }
}

private final class StepFunRequestRecorder: @unchecked Sendable {
    private let lock = NSLock()
    private var usageCalls = 0
    private var refreshCalls = 0

    var usageCallCount: Int {
        self.lock.lock()
        defer { self.lock.unlock() }
        return self.usageCalls
    }

    var refreshCallCount: Int {
        self.lock.lock()
        defer { self.lock.unlock() }
        return self.refreshCalls
    }

    func recordUsageCall() -> Int {
        self.lock.lock()
        defer { self.lock.unlock() }
        self.usageCalls += 1
        return self.usageCalls
    }

    func recordRefreshCall() {
        self.lock.lock()
        defer { self.lock.unlock() }
        self.refreshCalls += 1
    }
}

private final class StepFunStubURLProtocol: URLProtocol {
    nonisolated(unsafe) static var handler: (@Sendable (URLRequest) throws -> (HTTPURLResponse, Data))?

    override static func canInit(with request: URLRequest) -> Bool {
        request.url?.host == "platform.stepfun.com"
    }

    override static func canonicalRequest(for request: URLRequest) -> URLRequest {
        request
    }

    override func startLoading() {
        guard let handler = Self.handler else {
            self.client?.urlProtocol(self, didFailWithError: URLError(.badServerResponse))
            return
        }

        do {
            let (response, data) = try handler(self.request)
            self.client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
            self.client?.urlProtocol(self, didLoad: data)
            self.client?.urlProtocolDidFinishLoading(self)
        } catch {
            self.client?.urlProtocol(self, didFailWithError: error)
        }
    }

    override func stopLoading() {}
}