import Foundation
import Testing
@testable import CodexBarCore

struct CodexOAuthTests {
    private func makeContext(
        runtime: ProviderRuntime = .app,
        sourceMode: ProviderSourceMode = .auto,
        includeCredits: Bool = true,
        includeOptionalUsage: Bool = true) -> ProviderFetchContext
    {
        let browserDetection = BrowserDetection(cacheTTL: 0)
        return ProviderFetchContext(
            runtime: runtime,
            sourceMode: sourceMode,
            includeCredits: includeCredits,
            includeOptionalUsage: includeOptionalUsage,
            webTimeout: 60,
            webDebugDumpHTML: false,
            verbose: false,
            env: [:],
            settings: nil,
            fetcher: UsageFetcher(),
            claudeFetcher: ClaudeUsageFetcher(browserDetection: browserDetection),
            browserDetection: browserDetection)
    }

    @Test
    func `parses O auth credentials`() throws {
        let json = """
        {
          "OPENAI_API_KEY": null,
          "tokens": {
            "access_token": "access-token",
            "refresh_token": "refresh-token",
            "id_token": "id-token",
            "account_id": "account-123"
          },
          "last_refresh": "2025-12-20T12:34:56Z"
        }
        """
        let creds = try CodexOAuthCredentialsStore.parse(data: Data(json.utf8))
        #expect(creds.accessToken == "access-token")
        #expect(creds.refreshToken == "refresh-token")
        #expect(creds.idToken == "id-token")
        #expect(creds.accountId == "account-123")
        #expect(creds.lastRefresh != nil)
    }

    @Test
    func `parses legacy camel case O auth credentials`() throws {
        let json = """
        {
          "OPENAI_API_KEY": null,
          "tokens": {
            "accessToken": "access-token",
            "refreshToken": "refresh-token",
            "idToken": "id-token",
            "accountId": "account-123"
          },
          "last_refresh": "2025-12-20T12:34:56Z"
        }
        """
        let creds = try CodexOAuthCredentialsStore.parse(data: Data(json.utf8))
        #expect(creds.accessToken == "access-token")
        #expect(creds.refreshToken == "refresh-token")
        #expect(creds.idToken == "id-token")
        #expect(creds.accountId == "account-123")
        #expect(creds.lastRefresh != nil)
    }

    @Test
    func `parses API key credentials`() throws {
        let json = """
        {
          "OPENAI_API_KEY": "sk-test"
        }
        """
        let creds = try CodexOAuthCredentialsStore.parse(data: Data(json.utf8))
        #expect(creds.accessToken == "sk-test")
        #expect(creds.refreshToken.isEmpty)
        #expect(creds.idToken == nil)
        #expect(creds.accountId == nil)
        #expect(creds.isAPIKey)
        #expect(!creds.needsRefresh)
    }

    @Test
    func `reset-credit token load ignores an API key beside O auth tokens`() throws {
        let home = FileManager.default.temporaryDirectory
            .appendingPathComponent("codexbar-reset-credit-oauth-\(UUID().uuidString)")
        try FileManager.default.createDirectory(at: home, withIntermediateDirectories: true)
        defer { try? FileManager.default.removeItem(at: home) }
        let json = """
        {
          "OPENAI_API_KEY": "sk-test",
          "tokens": {
            "access_token": "oauth-access-token",
            "refresh_token": "oauth-refresh-token",
            "account_id": "account-123"
          },
          "last_refresh": "2026-07-01T12:00:00Z"
        }
        """
        try Data(json.utf8).write(to: home.appendingPathComponent("auth.json"))

        let credentials = try CodexOAuthCredentialsStore.loadOAuthTokens(env: ["CODEX_HOME": home.path])

        #expect(credentials.accessToken == "oauth-access-token")
        #expect(credentials.refreshToken == "oauth-refresh-token")
        #expect(credentials.accountId == "account-123")
    }

    @Test
    func `decodes credits balance string`() throws {
        let json = """
        {
          "plan_type": "pro",
          "rate_limit": {
            "primary_window": {
              "used_percent": 12,
              "reset_at": 1766948068,
              "limit_window_seconds": 18000
            }
          },
          "credits": {
            "has_credits": false,
            "unlimited": false,
            "balance": "0"
          }
        }
        """
        let response = try CodexOAuthUsageFetcher._decodeUsageResponseForTesting(Data(json.utf8))
        #expect(response.planType?.rawValue == "pro")
        #expect(response.credits?.balance == 0)
        #expect(response.credits?.hasCredits == false)
        #expect(response.credits?.unlimited == false)
    }

    @Test
    func `decodes prolite plan type without failing usage mapping`() throws {
        let json = """
        {
          "plan_type": "prolite",
          "rate_limit": {
            "primary_window": {
              "used_percent": 12,
              "reset_at": 1766948068,
              "limit_window_seconds": 18000
            }
          }
        }
        """
        let response = try CodexOAuthUsageFetcher._decodeUsageResponseForTesting(Data(json.utf8))
        #expect(response.planType?.rawValue == "prolite")

        let creds = CodexOAuthCredentials(
            accessToken: "access",
            refreshToken: "refresh",
            idToken: nil,
            accountId: nil,
            lastRefresh: Date())
        let mapped = try CodexOAuthFetchStrategy._mapUsageForTesting(Data(json.utf8), credentials: creds)
        #expect(mapped?.primary?.usedPercent == 12)
    }

    @Test
    func `maps usage windows from O auth`() throws {
        let json = """
        {
          "rate_limit": {
            "primary_window": {
              "used_percent": 22,
              "reset_at": 1766948068,
              "limit_window_seconds": 18000
            },
            "secondary_window": {
              "used_percent": 43,
              "reset_at": 1767407914,
              "limit_window_seconds": 604800
            }
          }
        }
        """
        let creds = CodexOAuthCredentials(
            accessToken: "access",
            refreshToken: "refresh",
            idToken: nil,
            accountId: nil,
            lastRefresh: Date())
        let mapped = try CodexOAuthFetchStrategy._mapUsageForTesting(Data(json.utf8), credentials: creds)
        let snapshot = try #require(mapped)
        #expect(snapshot.primary?.usedPercent == 22)
        #expect(snapshot.primary?.windowMinutes == 300)
        #expect(snapshot.secondary?.usedPercent == 43)
        #expect(snapshot.secondary?.windowMinutes == 10080)
        #expect(snapshot.primary?.resetsAt != nil)
        #expect(snapshot.secondary?.resetsAt != nil)
    }

    @Test
    func `O auth response with precise windows maps to exact confidence`() throws {
        let json = """
        {
          "rate_limit": {
            "primary_window": {
              "used_percent": 22,
              "reset_at": 1766948068,
              "limit_window_seconds": 18000
            },
            "secondary_window": {
              "used_percent": 43,
              "reset_at": 1767407914,
              "limit_window_seconds": 604800
            }
          }
        }
        """
        let creds = CodexOAuthCredentials(
            accessToken: "access",
            refreshToken: "refresh",
            idToken: nil,
            accountId: nil,
            lastRefresh: Date())
        let result = try CodexOAuthFetchStrategy._mapResultForTesting(Data(json.utf8), credentials: creds)

        #expect(result.sourceLabel == "oauth")
        #expect(result.usage.dataConfidence == .exact)
        #expect(result.usage.primary?.usedPercent == 22)
        #expect(result.usage.secondary?.usedPercent == 43)
    }

    @Test
    func `O auth response with malformed additional window maps to unknown confidence`() throws {
        let json = """
        {
          "rate_limit": {
            "primary_window": {
              "used_percent": 22,
              "reset_at": 1766948068,
              "limit_window_seconds": 18000
            }
          },
          "additional_rate_limits": [
            {
              "limit_name": "GPT-5.3-Codex-Spark",
              "metered_feature": "gpt_5_3_codex_spark",
              "rate_limit": {
                "primary_window": { "used_percent": "bad" }
              }
            }
          ]
        }
        """
        let creds = CodexOAuthCredentials(
            accessToken: "access",
            refreshToken: "refresh",
            idToken: nil,
            accountId: nil,
            lastRefresh: Date())
        let result = try CodexOAuthFetchStrategy._mapResultForTesting(Data(json.utf8), credentials: creds)

        #expect(result.usage.primary?.usedPercent == 22)
        #expect(result.usage.extraRateWindows == nil)
        #expect(result.usage.dataConfidence == .unknown)
    }

    @Test
    func `maps free weekly only window into secondary`() throws {
        let json = """
        {
          "plan_type": "free",
          "rate_limit": {
            "primary_window": {
              "used_percent": 0,
              "reset_at": 1775468693,
              "limit_window_seconds": 604800
            },
            "secondary_window": null
          }
        }
        """
        let creds = CodexOAuthCredentials(
            accessToken: "access",
            refreshToken: "refresh",
            idToken: nil,
            accountId: nil,
            lastRefresh: Date())
        let mapped = try CodexOAuthFetchStrategy._mapUsageForTesting(Data(json.utf8), credentials: creds)
        let snapshot = try #require(mapped)
        #expect(snapshot.primary == nil)
        #expect(snapshot.secondary?.usedPercent == 0)
        #expect(snapshot.secondary?.windowMinutes == 10080)
    }

    @Test
    func `keeps single session window as primary`() throws {
        let json = """
        {
          "rate_limit": {
            "primary_window": {
              "used_percent": 9,
              "reset_at": 1766948068,
              "limit_window_seconds": 18000
            },
            "secondary_window": null
          }
        }
        """
        let creds = CodexOAuthCredentials(
            accessToken: "access",
            refreshToken: "refresh",
            idToken: nil,
            accountId: nil,
            lastRefresh: Date())
        let mapped = try CodexOAuthFetchStrategy._mapUsageForTesting(Data(json.utf8), credentials: creds)
        let snapshot = try #require(mapped)
        #expect(snapshot.primary?.usedPercent == 9)
        #expect(snapshot.primary?.windowMinutes == 300)
        #expect(snapshot.secondary == nil)
    }

    @Test
    func `preserves unknown single window as primary`() throws {
        let json = """
        {
          "rate_limit": {
            "primary_window": {
              "used_percent": 17,
              "reset_at": 1766948068,
              "limit_window_seconds": 32400
            },
            "secondary_window": null
          }
        }
        """
        let creds = CodexOAuthCredentials(
            accessToken: "access",
            refreshToken: "refresh",
            idToken: nil,
            accountId: nil,
            lastRefresh: Date())
        let mapped = try CodexOAuthFetchStrategy._mapUsageForTesting(Data(json.utf8), credentials: creds)
        let snapshot = try #require(mapped)
        #expect(snapshot.primary?.usedPercent == 17)
        #expect(snapshot.primary?.windowMinutes == 540)
        #expect(snapshot.secondary == nil)
    }

    @Test
    func `preserves unknown secondary only window as primary`() throws {
        let json = """
        {
          "rate_limit": {
            "primary_window": null,
            "secondary_window": {
              "used_percent": 17,
              "reset_at": 1766948068,
              "limit_window_seconds": 32400
            }
          }
        }
        """
        let creds = CodexOAuthCredentials(
            accessToken: "access",
            refreshToken: "refresh",
            idToken: nil,
            accountId: nil,
            lastRefresh: Date())
        let mapped = try CodexOAuthFetchStrategy._mapUsageForTesting(Data(json.utf8), credentials: creds)
        let snapshot = try #require(mapped)
        #expect(snapshot.primary?.usedPercent == 17)
        #expect(snapshot.primary?.windowMinutes == 540)
        #expect(snapshot.secondary == nil)
    }

    @Test
    func `swaps reversed weekly and unknown windows`() throws {
        let json = """
        {
          "rate_limit": {
            "primary_window": {
              "used_percent": 43,
              "reset_at": 1767407914,
              "limit_window_seconds": 604800
            },
            "secondary_window": {
              "used_percent": 17,
              "reset_at": 1766948068,
              "limit_window_seconds": 32400
            }
          }
        }
        """
        let creds = CodexOAuthCredentials(
            accessToken: "access",
            refreshToken: "refresh",
            idToken: nil,
            accountId: nil,
            lastRefresh: Date())
        let mapped = try CodexOAuthFetchStrategy._mapUsageForTesting(Data(json.utf8), credentials: creds)
        let snapshot = try #require(mapped)
        #expect(snapshot.primary?.usedPercent == 17)
        #expect(snapshot.primary?.windowMinutes == 540)
        #expect(snapshot.secondary?.usedPercent == 43)
        #expect(snapshot.secondary?.windowMinutes == 10080)
    }

    @Test
    func `returns nil when O auth usage has no windows`() throws {
        let json = """
        {
          "rate_limit": {
            "primary_window": null,
            "secondary_window": null
          }
        }
        """
        let creds = CodexOAuthCredentials(
            accessToken: "access",
            refreshToken: "refresh",
            idToken: nil,
            accountId: nil,
            lastRefresh: Date())
        let snapshot = try CodexOAuthFetchStrategy._mapUsageForTesting(Data(json.utf8), credentials: creds)
        #expect(snapshot == nil)
    }

    @Test
    func `keeps valid window when secondary window is malformed`() throws {
        let json = """
        {
          "rate_limit": {
            "primary_window": {
              "used_percent": 18,
              "reset_at": 1766948068,
              "limit_window_seconds": 18000
            },
            "secondary_window": {
              "used_percent": "bad",
              "reset_at": 1767407914,
              "limit_window_seconds": 604800
            }
          }
        }
        """
        let creds = CodexOAuthCredentials(
            accessToken: "access",
            refreshToken: "refresh",
            idToken: nil,
            accountId: nil,
            lastRefresh: Date())
        let snapshot = try CodexOAuthFetchStrategy._mapUsageForTesting(Data(json.utf8), credentials: creds)
        #expect(snapshot?.primary?.usedPercent == 18)
        #expect(snapshot?.secondary == nil)

        let result = try CodexOAuthFetchStrategy._mapResultForTesting(Data(json.utf8), credentials: creds)
        #expect(result.usage.primary?.usedPercent == 18)
        #expect(result.usage.secondary == nil)
        #expect(result.usage.dataConfidence == .unknown)
    }

    @Test
    func `auto mode keeps weekly window when primary window is malformed`() throws {
        let json = """
        {
          "rate_limit": {
            "primary_window": {
              "used_percent": "bad",
              "reset_at": 1766948068,
              "limit_window_seconds": 18000
            },
            "secondary_window": {
              "used_percent": 43,
              "reset_at": 1767407914,
              "limit_window_seconds": 604800
            }
          }
        }
        """
        let creds = CodexOAuthCredentials(
            accessToken: "access",
            refreshToken: "refresh",
            idToken: nil,
            accountId: nil,
            lastRefresh: Date())

        let result = try CodexOAuthFetchStrategy._mapResultForTesting(
            Data(json.utf8),
            credentials: creds,
            sourceMode: .auto)

        #expect(result.usage.primary == nil)
        #expect(result.usage.secondary?.usedPercent == 43)
        #expect(result.usage.secondary?.windowMinutes == 10080)
    }

    @Test
    func `explicit oauth keeps weekly window when primary window is malformed`() throws {
        let json = """
        {
          "rate_limit": {
            "primary_window": {
              "used_percent": "bad",
              "reset_at": 1766948068,
              "limit_window_seconds": 18000
            },
            "secondary_window": {
              "used_percent": 43,
              "reset_at": 1767407914,
              "limit_window_seconds": 604800
            }
          }
        }
        """
        let creds = CodexOAuthCredentials(
            accessToken: "access",
            refreshToken: "refresh",
            idToken: nil,
            accountId: nil,
            lastRefresh: Date())

        let result = try CodexOAuthFetchStrategy._mapResultForTesting(
            Data(json.utf8),
            credentials: creds,
            sourceMode: .oauth)

        #expect(result.usage.primary == nil)
        #expect(result.usage.secondary?.usedPercent == 43)
        #expect(result.usage.secondary?.windowMinutes == 10080)
    }

    @Test
    func `auto mode preserves reversed session window when primary window is malformed`() throws {
        let json = """
        {
          "rate_limit": {
            "primary_window": {
              "used_percent": "bad",
              "reset_at": 1767407914,
              "limit_window_seconds": 604800
            },
            "secondary_window": {
              "used_percent": 18,
              "reset_at": 1766948068,
              "limit_window_seconds": 18000
            }
          }
        }
        """
        let creds = CodexOAuthCredentials(
            accessToken: "access",
            refreshToken: "refresh",
            idToken: nil,
            accountId: nil,
            lastRefresh: Date())

        let result = try CodexOAuthFetchStrategy._mapResultForTesting(
            Data(json.utf8),
            credentials: creds,
            sourceMode: .auto)

        #expect(result.usage.primary?.usedPercent == 18)
        #expect(result.usage.primary?.windowMinutes == 300)
        #expect(result.usage.secondary == nil)
    }

    @Test
    func `auto mode keeps weekly window when reversed session window is malformed`() throws {
        let json = """
        {
          "rate_limit": {
            "primary_window": {
              "used_percent": 43,
              "reset_at": 1767407914,
              "limit_window_seconds": 604800
            },
            "secondary_window": {
              "used_percent": "bad",
              "reset_at": 1766948068,
              "limit_window_seconds": 18000
            }
          }
        }
        """
        let creds = CodexOAuthCredentials(
            accessToken: "access",
            refreshToken: "refresh",
            idToken: nil,
            accountId: nil,
            lastRefresh: Date())

        let result = try CodexOAuthFetchStrategy._mapResultForTesting(
            Data(json.utf8),
            credentials: creds,
            sourceMode: .auto)

        #expect(result.usage.primary == nil)
        #expect(result.usage.secondary?.usedPercent == 43)
        #expect(result.usage.secondary?.windowMinutes == 10080)
    }

    @Test
    func `explicit oauth keeps weekly window when reversed session window is malformed`() throws {
        let json = """
        {
          "rate_limit": {
            "primary_window": {
              "used_percent": 43,
              "reset_at": 1767407914,
              "limit_window_seconds": 604800
            },
            "secondary_window": {
              "used_percent": "bad",
              "reset_at": 1766948068,
              "limit_window_seconds": 18000
            }
          }
        }
        """
        let creds = CodexOAuthCredentials(
            accessToken: "access",
            refreshToken: "refresh",
            idToken: nil,
            accountId: nil,
            lastRefresh: Date())

        let result = try CodexOAuthFetchStrategy._mapResultForTesting(
            Data(json.utf8),
            credentials: creds,
            sourceMode: .oauth)

        #expect(result.usage.primary == nil)
        #expect(result.usage.secondary?.usedPercent == 43)
        #expect(result.usage.secondary?.windowMinutes == 10080)
    }

    @Test
    func `ignores malformed credits payload while keeping usage`() throws {
        let json = """
        {
          "rate_limit": {
            "primary_window": {
              "used_percent": 22,
              "reset_at": 1766948068,
              "limit_window_seconds": 18000
            }
          },
          "credits": {
            "has_credits": false,
            "unlimited": false,
            "balance": []
          }
        }
        """
        let response = try CodexOAuthUsageFetcher._decodeUsageResponseForTesting(Data(json.utf8))
        #expect(response.credits?.hasCredits == false)
        #expect(response.credits?.unlimited == false)
        #expect(response.credits?.balance == nil)

        let creds = CodexOAuthCredentials(
            accessToken: "access",
            refreshToken: "refresh",
            idToken: nil,
            accountId: nil,
            lastRefresh: Date())
        let snapshot = try CodexOAuthFetchStrategy._mapUsageForTesting(Data(json.utf8), credentials: creds)
        #expect(snapshot?.primary?.usedPercent == 22)
    }

    @Test
    func `credits only O auth payload still returns credits result`() throws {
        let json = """
        {
          "rate_limit": {
            "primary_window": null,
            "secondary_window": null
          },
          "credits": {
            "has_credits": true,
            "unlimited": false,
            "balance": "14.5"
          }
        }
        """
        let creds = CodexOAuthCredentials(
            accessToken: "access",
            refreshToken: "refresh",
            idToken: nil,
            accountId: nil,
            lastRefresh: Date())

        let result = try CodexOAuthFetchStrategy._mapResultForTesting(Data(json.utf8), credentials: creds)

        #expect(result.usage.primary == nil)
        #expect(result.usage.secondary == nil)
        #expect(result.credits?.remaining == 14.5)
        #expect(result.sourceLabel == "oauth")
    }

    @Test
    func `credits only O auth payload returns credits in auto mode`() throws {
        let json = """
        {
          "rate_limit": {
            "primary_window": null,
            "secondary_window": null
          },
          "credits": {
            "has_credits": true,
            "unlimited": false,
            "balance": "14.5"
          }
        }
        """
        let creds = CodexOAuthCredentials(
            accessToken: "access",
            refreshToken: "refresh",
            idToken: nil,
            accountId: nil,
            lastRefresh: Date())

        let result = try CodexOAuthFetchStrategy._mapResultForTesting(
            Data(json.utf8),
            credentials: creds,
            sourceMode: .auto)

        #expect(result.usage.primary == nil)
        #expect(result.usage.secondary == nil)
        #expect(result.credits?.remaining == 14.5)
        #expect(result.sourceLabel == "oauth")
    }

    @Test
    func `auto mode only falls back from O auth on auth failures`() {
        let strategy = CodexOAuthFetchStrategy()
        let context = self.makeContext(sourceMode: .auto)

        #expect(strategy.shouldFallback(on: CodexOAuthFetchError.unauthorized, context: context))
        #expect(strategy.shouldFallback(on: CodexOAuthCredentialsError.notFound, context: context))
        #expect(strategy.shouldFallback(on: CodexOAuthCredentialsError.unreadable, context: context))
        #expect(strategy.shouldFallback(on: CodexOAuthCredentialsError.missingTokens, context: context))
        #expect(!strategy.shouldFallback(on: CodexOAuthCredentialsError.readOnlySource, context: context))
        #expect(strategy.shouldFallback(on: CodexTokenRefresher.RefreshError.expired, context: context))
        #expect(strategy.shouldFallback(on: CodexTokenRefresher.RefreshError.revoked, context: context))
        #expect(strategy.shouldFallback(on: CodexTokenRefresher.RefreshError.reused, context: context))

        #expect(!strategy.shouldFallback(on: UsageError.noRateLimitsFound, context: context))
        #expect(!strategy.shouldFallback(on: CodexOAuthCredentialsError.decodeFailed("bad json"), context: context))
        #expect(!strategy.shouldFallback(on: CodexOAuthFetchError.invalidResponse, context: context))
        #expect(!strategy.shouldFallback(on: CodexOAuthFetchError.serverError(500, "offline"), context: context))
        #expect(!strategy.shouldFallback(
            on: CodexOAuthFetchError.networkError(URLError(.notConnectedToInternet)),
            context: context))
        #expect(!strategy.shouldFallback(
            on: CodexTokenRefresher.RefreshError.networkError(URLError(.timedOut)),
            context: context))
    }

    @Test
    func `non 401 invalid grant refresh failure is treated as revoked`() {
        let data = Data(#"{"error":"invalid_grant"}"#.utf8)
        let error = CodexTokenRefresher._refreshFailureErrorForTesting(statusCode: 400, data: data)

        switch error {
        case .revoked:
            break
        default:
            Issue.record("Expected invalid_grant to be treated as revoked")
        }
    }

    @Test
    func `non auth refresh failure remains invalid response`() {
        let data = Data(#"{"error":"invalid_request"}"#.utf8)
        let error = CodexTokenRefresher._refreshFailureErrorForTesting(statusCode: 400, data: data)

        switch error {
        case let .invalidResponse(message):
            #expect(message == "Status 400")
        default:
            Issue.record("Expected invalid_request to remain an invalid response")
        }
    }

    @Test
    func `explicit O auth mode only falls back to CLI for native refresh recovery`() {
        let strategy = CodexOAuthFetchStrategy()
        let context = self.makeContext(sourceMode: .oauth)

        #expect(!strategy.shouldFallback(on: CodexOAuthFetchError.unauthorized, context: context))
        #expect(strategy.shouldFallback(on: CodexOAuthCredentialsError.nativeRefreshRequired, context: context))
        #expect(!strategy.shouldFallback(on: CodexOAuthCredentialsError.readOnlySource, context: context))
        #expect(!strategy.shouldFallback(on: CodexTokenRefresher.RefreshError.expired, context: context))
    }

    @Test
    func `credential recovery errors direct users to codex login`() {
        #expect(CodexOAuthCredentialsError.nativeRefreshRequired.localizedDescription.contains("codex login"))
        #expect(CodexOAuthCredentialsError.readOnlySource.localizedDescription.contains("codex login"))
        #expect(CodexOAuthFetchError.unauthorized.localizedDescription.contains("codex login"))
    }

    @Test
    func `explicit O auth mode includes CLI recovery after native credentials expire`() async {
        let context = self.makeContext(sourceMode: .oauth)
        let strategies = await CodexProviderDescriptor.descriptor.fetchPlan.pipeline.resolveStrategies(context)

        #expect(strategies.map(\.id) == ["codex.oauth", "codex.oauth-native-refresh-cli"])
    }

    @Test
    func `native refresh recovery is unavailable when Codex CLI is missing`() async throws {
        let home = FileManager.default.temporaryDirectory
            .appendingPathComponent("codexbar-native-refresh-no-cli-\(UUID().uuidString)")
        try FileManager.default.createDirectory(at: home, withIntermediateDirectories: true)
        defer { try? FileManager.default.removeItem(at: home) }
        try CodexOAuthCredentialsStore.save(
            CodexOAuthCredentials(
                accessToken: "access-token",
                refreshToken: "refresh-token",
                idToken: nil,
                accountId: "account-id",
                lastRefresh: Date(timeIntervalSinceNow: -(9 * 24 * 60 * 60))),
            env: ["CODEX_HOME": home.path])

        var context = self.makeContext(sourceMode: .oauth)
        context = ProviderFetchContext(
            runtime: context.runtime,
            sourceMode: context.sourceMode,
            includeCredits: context.includeCredits,
            includeOptionalUsage: context.includeOptionalUsage,
            webTimeout: context.webTimeout,
            webDebugDumpHTML: context.webDebugDumpHTML,
            verbose: context.verbose,
            env: ["CODEX_HOME": home.path, "CODEX_CLI_PATH": "/missing/codex"],
            settings: context.settings,
            fetcher: context.fetcher,
            claudeFetcher: context.claudeFetcher,
            browserDetection: context.browserDetection)

        let isAvailable = await CodexOAuthNativeRefreshCLIStrategy(binaryResolver: { _ in nil })
            .isAvailable(context)
        #expect(!isAvailable)
    }

    @Test
    func `resolves chat GPT usage URL from config`() {
        let config = "chatgpt_base_url = \"https://chatgpt.com/backend-api/\"\n"
        let url = CodexOAuthUsageFetcher._resolveUsageURLForTesting(configContents: config)
        #expect(url.absoluteString == "https://chatgpt.com/backend-api/wham/usage")
    }

    @Test
    func `resolves codex usage URL from config`() {
        let config = "chatgpt_base_url = \"https://api.openai.com\"\n"
        let url = CodexOAuthUsageFetcher._resolveUsageURLForTesting(configContents: config)
        #expect(url.absoluteString == "https://api.openai.com/api/codex/usage")
    }

    @Test
    func `normalizes chat GPT base URL without backend API`() {
        let config = "chatgpt_base_url = \"https://chat.openai.com\"\n"
        let url = CodexOAuthUsageFetcher._resolveUsageURLForTesting(configContents: config)
        #expect(url.absoluteString == "https://chat.openai.com/backend-api/wham/usage")
    }
}
