import Foundation
import Testing
@testable import CodexBarCore
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif

/// Tests for `CommandCodeUsageFetcher` parsers and the cookie/snapshot derivation,
/// using real responses captured from api.commandcode.ai for an active "individual-go" plan.
struct CommandCodeUsageFetcherTests {
    private static let creditsJSON = """
    {"credits":{"belowThreshold":false,"creditThreshold":0,"monthlyCredits":8.7784,\
    "purchasedCredits":0,"premiumMonthlyCredits":0,"opensourceMonthlyCredits":8.7784}}
    """

    private static let subscriptionJSON = """
    {"success":true,"data":{"id":"sub_1TTzt3DSZgxV3MJKG4ClCWpn","status":"active",\
    "userId":"915e93a7-a1f9-4c97-a3f0-20a85fcb3a45","orgId":null,\
    "createdAt":"2026-05-06T07:28:50.000Z","priceId":"price_1TMD8zDSZgxV3MJKxOZMVZrP",\
    "metadata":{"commandCode":"true","commandCodeUserId":"915e93a7-a1f9-4c97-a3f0-20a85fcb3a45"},\
    "quantity":1,"cancelAtPeriodEnd":false,\
    "currentPeriodStart":"2026-05-06T07:28:50.000Z","currentPeriodEnd":"2026-06-06T07:28:50.000Z",\
    "endedAt":null,"cancelAt":null,"canceledAt":null,"planId":"individual-go"}}
    """

    @Test
    func `parses credits payload`() throws {
        let data = try #require(Self.creditsJSON.data(using: .utf8))
        let payload = try CommandCodeUsageFetcher.parseCredits(data: data)
        #expect(payload.monthlyCredits == 8.7784)
        #expect(payload.purchasedCredits == 0)
        #expect(payload.premiumMonthlyCredits == 0)
        #expect(payload.opensourceMonthlyCredits == 8.7784)
    }

    @Test
    func `parses subscription payload`() throws {
        let data = try #require(Self.subscriptionJSON.data(using: .utf8))
        let payload = try #require(try CommandCodeUsageFetcher.parseSubscription(data: data))
        #expect(payload.planID == "individual-go")
        #expect(payload.status == "active")
        let isoFormatter = ISO8601DateFormatter()
        isoFormatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
        let expectedEnd = isoFormatter.date(from: "2026-06-06T07:28:50.000Z")
        #expect(payload.currentPeriodEnd == expectedEnd)
    }

    @Test
    func `subscription on free tier returns nil`() throws {
        let data = Data(#"{"success":true,"data":null}"#.utf8)
        let payload = try CommandCodeUsageFetcher.parseSubscription(data: data)
        #expect(payload == nil)
    }

    @Test
    func `successful free tier lookup has no usage window`() async throws {
        let transport = ProviderHTTPTransportStub { request in
            let path = try #require(request.url?.path)
            let body = if path.hasSuffix("/credits") {
                """
                {"credits":{"monthlyCredits":0,"purchasedCredits":0,
                "premiumMonthlyCredits":0,"opensourceMonthlyCredits":0}}
                """
            } else {
                #"{"success":true,"data":null}"#
            }
            return try Self.response(request: request, statusCode: 200, body: body)
        }

        let snapshot = try await CommandCodeUsageFetcher.fetchUsage(
            cookieHeader: "session=valid",
            session: transport)

        #expect(snapshot.subscriptionEnrichmentUnavailable == false)
        #expect(snapshot.toUsageSnapshot().primary == nil)
    }

    @Test
    func `subscription failure envelope preserves required credits`() async throws {
        let transport = ProviderHTTPTransportStub { request in
            let path = try #require(request.url?.path)
            if path.hasSuffix("/credits") {
                return try Self.response(request: request, statusCode: 200, body: Self.creditsJSON)
            }
            return try Self.response(
                request: request,
                statusCode: 200,
                body: #"{"success":false,"error":"temporarily unavailable"}"#)
        }

        let snapshot = try await CommandCodeUsageFetcher.fetchUsage(
            cookieHeader: "session=valid",
            session: transport,
            now: Date(timeIntervalSince1970: 123))

        #expect(snapshot.monthlyCreditsRemaining == 8.7784)
        #expect(snapshot.plan == nil)
        #expect(snapshot.subscriptionEnrichmentUnavailable)
        #expect(snapshot.updatedAt == Date(timeIntervalSince1970: 123))
    }

    @Test
    func `successful subscription envelope requires explicit data`() throws {
        let data = Data(#"{"success":true}"#.utf8)

        #expect(throws: CommandCodeUsageError.self) {
            try CommandCodeUsageFetcher.parseSubscription(data: data)
        }
    }

    @Test
    func `subscription failure preserves required credits`() async throws {
        let transport = ProviderHTTPTransportStub { request in
            let path = try #require(request.url?.path)
            if path.hasSuffix("/credits") {
                return try Self.response(request: request, statusCode: 200, body: Self.creditsJSON)
            }
            return try Self.response(request: request, statusCode: 503, body: #"{"error":"unavailable"}"#)
        }

        let snapshot = try await CommandCodeUsageFetcher.fetchUsage(
            cookieHeader: "session=valid",
            session: transport,
            now: Date(timeIntervalSince1970: 123))

        #expect(snapshot.monthlyCreditsRemaining == 8.7784)
        #expect(snapshot.plan == nil)
        #expect(snapshot.billingPeriodEnd == nil)
        #expect(snapshot.subscriptionEnrichmentUnavailable)
        #expect(snapshot.updatedAt == Date(timeIntervalSince1970: 123))
    }

    @Test
    func `subscription timeout does not hold credits for full request timeout`() async throws {
        let transport = ProviderHTTPTransportStub { request in
            let path = try #require(request.url?.path)
            if path.hasSuffix("/credits") {
                return try Self.response(request: request, statusCode: 200, body: Self.creditsJSON)
            }
            try await Task.sleep(for: .seconds(10))
            return try Self.response(request: request, statusCode: 200, body: Self.subscriptionJSON)
        }

        let startedAt = ContinuousClock.now
        let snapshot = try await CommandCodeUsageFetcher.fetchUsage(
            cookieHeader: "session=valid",
            session: transport)
        let elapsed = startedAt.duration(to: .now)

        #expect(snapshot.monthlyCreditsRemaining == 8.7784)
        #expect(snapshot.plan == nil)
        #expect(snapshot.subscriptionEnrichmentUnavailable)
        #expect(elapsed < .seconds(3), "Subscription enrichment delayed credits: \(elapsed)")
    }

    @Test
    func `subscription grace does not wait for transport that ignores cancellation`() async throws {
        let transport = ProviderHTTPTransportStub { request in
            let path = try #require(request.url?.path)
            if path.hasSuffix("/credits") {
                return try Self.response(request: request, statusCode: 200, body: Self.creditsJSON)
            }
            let response = try Self.response(request: request, statusCode: 200, body: Self.subscriptionJSON)
            return await withCheckedContinuation { continuation in
                DispatchQueue.global().asyncAfter(deadline: .now() + 0.5) {
                    continuation.resume(returning: response)
                }
            }
        }

        let startedAt = ContinuousClock.now
        let snapshot = try await CommandCodeUsageFetcher._fetchUsageForTesting(
            cookieHeader: "session=valid",
            transport: transport,
            subscriptionGrace: .milliseconds(20))
        let elapsed = startedAt.duration(to: .now)

        #expect(snapshot.monthlyCreditsRemaining == 8.7784)
        #expect(snapshot.plan == nil)
        #expect(snapshot.subscriptionEnrichmentUnavailable)
        #expect(elapsed < .milliseconds(300), "Subscription enrichment delayed credits: \(elapsed)")

        // Let the deliberately cancellation-ignoring test task drain before the test exits.
        try await Task.sleep(for: .milliseconds(550))
    }

    @Test
    func `cancellation after credits complete does not return partial snapshot`() async throws {
        let subscriptionStarted = CommandCodeRequestGate()
        let transport = ProviderHTTPTransportStub { request in
            let path = try #require(request.url?.path)
            if path.hasSuffix("/credits") {
                return try Self.response(request: request, statusCode: 200, body: Self.creditsJSON)
            }
            await subscriptionStarted.open()
            try await Task.sleep(for: .seconds(10))
            return try Self.response(request: request, statusCode: 200, body: Self.subscriptionJSON)
        }
        let task = Task {
            try await CommandCodeUsageFetcher.fetchUsage(
                cookieHeader: "session=valid",
                session: transport)
        }

        await subscriptionStarted.wait()
        try await Task.sleep(for: .milliseconds(50))
        task.cancel()

        await #expect(throws: CancellationError.self) {
            try await task.value
        }
    }

    @Test
    func `cancellation cleans up subscription when credits transport ignores cancellation`() async throws {
        let creditsStarted = CommandCodeRequestGate()
        let subscriptionStarted = CommandCodeRequestGate()
        let subscriptionCancelled = CommandCodeRequestGate()
        let transport = ProviderHTTPTransportStub { request in
            let path = try #require(request.url?.path)
            if path.hasSuffix("/credits") {
                await creditsStarted.open()
                let response = try Self.response(request: request, statusCode: 200, body: Self.creditsJSON)
                return await withCheckedContinuation { continuation in
                    DispatchQueue.global().asyncAfter(deadline: .now() + 0.5) {
                        continuation.resume(returning: response)
                    }
                }
            }
            await subscriptionStarted.open()
            do {
                try await Task.sleep(for: .seconds(10))
            } catch {
                await subscriptionCancelled.open()
                throw error
            }
            return try Self.response(request: request, statusCode: 200, body: Self.subscriptionJSON)
        }
        let task = Task {
            try await CommandCodeUsageFetcher.fetchUsage(
                cookieHeader: "session=valid",
                session: transport)
        }

        await creditsStarted.wait()
        await subscriptionStarted.wait()
        let cancellationStartedAt = ContinuousClock.now
        task.cancel()

        await subscriptionCancelled.wait()
        #expect(cancellationStartedAt.duration(to: .now) < .milliseconds(300))
        await #expect(throws: CancellationError.self) {
            try await task.value
        }
    }

    @Test
    func `cancellation wins when optional transport ignores cancellation then fails`() async throws {
        let subscriptionStarted = CommandCodeRequestGate()
        let transport = ProviderHTTPTransportStub { request in
            let path = try #require(request.url?.path)
            if path.hasSuffix("/credits") {
                return try Self.response(request: request, statusCode: 200, body: Self.creditsJSON)
            }
            await subscriptionStarted.open()
            do {
                try await Task.sleep(for: .seconds(10))
            } catch {
                // Simulate a transport that converts cancellation into an ordinary endpoint failure.
            }
            return try Self.response(request: request, statusCode: 503, body: #"{"error":"unavailable"}"#)
        }
        let task = Task {
            try await CommandCodeUsageFetcher.fetchUsage(
                cookieHeader: "session=valid",
                session: transport)
        }

        await subscriptionStarted.wait()
        try await Task.sleep(for: .milliseconds(50))
        task.cancel()

        await #expect(throws: CancellationError.self) {
            try await task.value
        }
    }

    @Test
    func `successful unknown active subscription still fails explicitly`() async {
        let unknownPlanJSON = Self.subscriptionJSON.replacingOccurrences(
            of: #""planId":"individual-go""#,
            with: #""planId":"individual-future""#)
        let transport = ProviderHTTPTransportStub { request in
            let path = try #require(request.url?.path)
            let body = path.hasSuffix("/credits") ? Self.creditsJSON : unknownPlanJSON
            return try Self.response(request: request, statusCode: 200, body: body)
        }

        await #expect(throws: CommandCodeUsageError.unknownPlan("individual-future")) {
            try await CommandCodeUsageFetcher.fetchUsage(
                cookieHeader: "session=valid",
                session: transport)
        }
    }

    @Test
    func `snapshot derives used and total from plan catalog`() throws {
        let plan = try #require(CommandCodePlanCatalog.plan(forID: "individual-go"))
        let snapshot = CommandCodeUsageSnapshot(
            monthlyCreditsRemaining: 8.7784,
            purchasedCredits: 0,
            premiumMonthlyCredits: 0,
            opensourceMonthlyCredits: 8.7784,
            plan: plan,
            billingPeriodEnd: Date(timeIntervalSince1970: 1_780_000_000),
            subscriptionStatus: "active",
            updatedAt: Date(timeIntervalSince1970: 0))
        #expect(snapshot.monthlyCreditsTotal == 10)
        #expect(abs((snapshot.monthlyCreditsUsed ?? -1) - 1.2216) < 0.0001)

        let usage = snapshot.toUsageSnapshot()
        let primary = try #require(usage.primary)
        #expect(abs(primary.usedPercent - 12.216) < 0.001)
        #expect(primary.resetsAt == Date(timeIntervalSince1970: 1_780_000_000))
        #expect(usage.identity?.loginMethod == "Go · $1.22 of $10.00")
    }

    @Test
    func `free tier with no allowance has no usage window`() {
        let snapshot = CommandCodeUsageSnapshot(
            monthlyCreditsRemaining: 0,
            purchasedCredits: 0,
            premiumMonthlyCredits: 0,
            opensourceMonthlyCredits: 0,
            plan: nil,
            billingPeriodEnd: nil,
            subscriptionStatus: nil)

        #expect(snapshot.toUsageSnapshot().primary == nil)
    }

    @Test
    func `plan catalog covers known plans`() {
        #expect(CommandCodePlanCatalog.plan(forID: "individual-go")?.monthlyCreditsUSD == 10)
        #expect(CommandCodePlanCatalog.plan(forID: "individual-pro")?.monthlyCreditsUSD == 30)
        #expect(CommandCodePlanCatalog.plan(forID: "individual-max")?.monthlyCreditsUSD == 150)
        #expect(CommandCodePlanCatalog.plan(forID: "individual-ultra")?.monthlyCreditsUSD == 300)
        #expect(CommandCodePlanCatalog.plan(forID: "unknown") == nil)
    }

    @Test
    func `cookie header extracts secure session cookie`() throws {
        let raw = "_ga=GA1.2.123; __Secure-better-auth.session_token=abc123; foo=bar"
        let override = try #require(CommandCodeCookieHeader.override(from: raw))
        #expect(override.name == "__Secure-better-auth.session_token")
        #expect(override.token == "abc123")
        #expect(override.headerValue == "__Secure-better-auth.session_token=abc123")
    }

    @Test
    func `cookie header accepts non-secure variant`() throws {
        let raw = "better-auth.session_token=plain-token"
        let override = try #require(CommandCodeCookieHeader.override(from: raw))
        #expect(override.name == "better-auth.session_token")
        #expect(override.token == "plain-token")
    }

    @Test
    func `cookie header accepts bare token and uses secure name`() throws {
        let override = try #require(CommandCodeCookieHeader.override(from: "bare-value"))
        #expect(override.name == "__Secure-better-auth.session_token")
        #expect(override.token == "bare-value")
    }

    @Test
    func `cookie header rejects empty input`() {
        #expect(CommandCodeCookieHeader.override(from: nil) == nil)
        #expect(CommandCodeCookieHeader.override(from: "") == nil)
        #expect(CommandCodeCookieHeader.override(from: "   ") == nil)
    }

    private static func response(
        request: URLRequest,
        statusCode: Int,
        body: String) throws -> (Data, URLResponse)
    {
        let url = try #require(request.url)
        let response = try #require(HTTPURLResponse(
            url: url,
            statusCode: statusCode,
            httpVersion: nil,
            headerFields: nil))
        return (Data(body.utf8), response)
    }
}

private actor CommandCodeRequestGate {
    private var isOpen = false
    private var continuations: [CheckedContinuation<Void, Never>] = []

    func wait() async {
        guard !self.isOpen else { return }
        await withCheckedContinuation { continuation in
            self.continuations.append(continuation)
        }
    }

    func open() {
        self.isOpen = true
        let continuations = self.continuations
        self.continuations.removeAll()
        for continuation in continuations {
            continuation.resume()
        }
    }
}