import Foundation
import SwiftUI
import Testing
@testable import CodexBar
@testable import CodexBarCore

@MainActor
struct DeepgramProviderTests {
    @Test
    func `deepgram field kinds and bindings`() throws {
        let suite = "DeepgramProviderTests-field-kinds"
        let defaults = try #require(UserDefaults(suiteName: suite))
        defaults.removePersistentDomain(forName: suite)
        let configStore = testConfigStore(suiteName: suite)
        let settings = SettingsStore(
            userDefaults: defaults,
            configStore: configStore,
            zaiTokenStore: NoopZaiTokenStore(),
            syntheticTokenStore: NoopSyntheticTokenStore())
        let store = UsageStore(
            fetcher: UsageFetcher(environment: [:]),
            browserDetection: BrowserDetection(cacheTTL: 0),
            settings: settings)

        let context = ProviderSettingsContext(
            provider: .deepgram,
            settings: settings,
            store: store,
            boolBinding: { keyPath in
                Binding(
                    get: { settings[keyPath: keyPath] },
                    set: { settings[keyPath: keyPath] = $0 })
            },
            stringBinding: { keyPath in
                Binding(
                    get: { settings[keyPath: keyPath] },
                    set: { settings[keyPath: keyPath] = $0 })
            },
            statusText: { _ in nil },
            setStatusText: { _, _ in },
            lastAppActiveRunAt: { _ in nil },
            setLastAppActiveRunAt: { _, _ in },
            requestConfirmation: { _ in },
            runLoginFlow: {})

        let implementation = DeepgramProviderImplementation()
        let fields = implementation.settingsFields(context: context)

        let apiField = try #require(fields.first(where: { $0.id == "deepgram-api-key" }))
        let projectField = try #require(fields.first(where: { $0.id == "deepgram-project-id" }))

        #expect(apiField.kind == .secure)
        #expect(projectField.kind == .plain)

        // Verify bindings update the SettingsStore
        apiField.binding.wrappedValue = "dg_test_token"
        #expect(settings.deepgramAPIKey == "dg_test_token")

        projectField.binding.wrappedValue = "proj-1234"
        #expect(settings.deepgramProjectID == "proj-1234")
    }

    @Test
    nonisolated func `parses usage breakdown response into visible usage notes`() throws {
        let body = #"""
        {
          "start": "2025-01-16",
          "end": "2025-01-23",
          "resolution": {
            "units": "day",
            "amount": 1
          },
          "results": [
            {
              "hours": 1619.7242069444444,
              "total_hours": 1621.7395791666668,
              "agent_hours": 41.33564388888889,
              "tokens_in": 1200,
              "tokens_out": 340,
              "tts_characters": 9158866,
              "requests": 373381,
              "grouping": {
                "start": "2025-01-16",
                "end": "2025-01-16",
                "endpoint": "listen"
              }
            },
            {
              "hours": 2.25,
              "total_hours": 3.5,
              "requests": 19,
              "grouping": {
                "start": "2025-01-17",
                "end": "2025-01-17",
                "endpoint": "speak"
              }
            }
          ]
        }
        """#

        let updatedAt = Date(timeIntervalSince1970: 123)
        let snapshot = try DeepgramUsageFetcher._parseSnapshotForTesting(
            Data(body.utf8),
            projectID: "project-123",
            updatedAt: updatedAt)
        let usage = snapshot.toUsageSnapshot()

        #expect(snapshot.requests == 373_400)
        #expect(snapshot.hours == 1621.9742069444444)
        #expect(snapshot.totalHours == 1625.2395791666668)
        #expect(snapshot.agentHours == 41.33564388888889)
        #expect(snapshot.tokensIn == 1200)
        #expect(snapshot.tokensOut == 340)
        #expect(snapshot.ttsCharacters == 9_158_866)
        #expect(usage.deepgramUsage?.requests == 373_400)
        #expect(usage.loginMethod(for: .deepgram) == "Project: project-123")
        #expect(usage.deepgramUsage?.displayLines == [
            "Requests: 373,400",
            "1,622.0 audio hours · 1,625.2 billable hours",
            "41.3 agent hours · 1,540 tokens · 9,158,866 TTS chars",
            "Period: 2025-01-16 to 2025-01-23",
        ])
    }

    @Test
    nonisolated func `fetch usage calls breakdown endpoint with token auth`() async throws {
        let transport = ProviderHTTPTransportStub { request in
            guard let url = request.url else { throw URLError(.badURL) }
            #expect(url.path == "/v1/projects/project-123/usage/breakdown")
            let components = URLComponents(url: url, resolvingAgainstBaseURL: false)
            #expect(components?.queryItems?.contains(URLQueryItem(name: "start", value: "2025-01-16")) == true)
            #expect(components?.queryItems?.contains(URLQueryItem(name: "end", value: "2025-01-23")) == true)
            #expect(request.value(forHTTPHeaderField: "Authorization") == "Token dg-test")
            #expect(request.value(forHTTPHeaderField: "Accept") == "application/json")
            #expect(request.timeoutInterval == 15)

            let body = #"""
            {
              "start": "2025-01-16",
              "end": "2025-01-23",
              "resolution": {
                "units": "day",
                "amount": 1
              },
              "results": [
                {
                  "hours": 1.5,
                  "total_hours": 2,
                  "requests": 7
                }
              ]
            }
            """#
            return Self.makeResponse(url: url, body: body)
        }

        let usage = try await DeepgramUsageFetcher.fetchUsage(
            apiKey: " dg-test ",
            projectID: " project-123 ",
            query: DeepgramUsageQuery(start: "2025-01-16", end: "2025-01-23"),
            environment: ["DEEPGRAM_API_URL": "https://deepgram.test/v1"],
            transport: transport)

        #expect(usage.projectID == "project-123")
        #expect(usage.requests == 7)
        #expect(usage.hours == 1.5)
        #expect(usage.totalHours == 2)

        let requests = await transport.requests()
        #expect(requests.count == 1)
    }

    @Test
    nonisolated func `fetch usage discovers projects when project id is omitted`() async throws {
        let transport = ProviderHTTPTransportStub { request in
            let url = try #require(request.url)
            #expect(request.value(forHTTPHeaderField: "Authorization") == "Token dg-test")

            switch url.path {
            case "/v1/projects":
                return Self.makeResponse(url: url, body: #"""
                {
                  "projects": [
                    { "project_id": "project-a", "name": "Alpha" },
                    { "project_id": "project-b", "name": "Beta" }
                  ]
                }
                """#)

            case "/v1/projects/project-a/usage/breakdown":
                return Self.makeResponse(url: url, body: #"""
                {
                  "start": "2025-01-16",
                  "end": "2025-01-23",
                  "results": [
                    { "hours": 1, "total_hours": 2, "requests": 3 }
                  ]
                }
                """#)

            case "/v1/projects/project-b/usage/breakdown":
                return Self.makeResponse(url: url, body: #"""
                {
                  "start": "2025-01-17",
                  "end": "2025-01-24",
                  "results": [
                    { "hours": 4, "total_hours": 5, "requests": 6 }
                  ]
                }
                """#)

            default:
                throw URLError(.badURL)
            }
        }

        let usage = try await DeepgramUsageFetcher.fetchUsage(
            apiKey: "dg-test",
            environment: ["DEEPGRAM_API_URL": "https://deepgram.test/v1"],
            transport: transport)

        #expect(usage.projectID == "all")
        #expect(usage.projectCount == 2)
        #expect(usage.requests == 9)
        #expect(usage.hours == 5)
        #expect(usage.totalHours == 7)
        #expect(usage.start == "2025-01-16")
        #expect(usage.end == "2025-01-24")
        #expect(usage.toUsageSnapshot().loginMethod(for: .deepgram) == "2 projects")

        let requests = await transport.requests()
        #expect(requests.map { $0.url?.path } == [
            "/v1/projects",
            "/v1/projects/project-a/usage/breakdown",
            "/v1/projects/project-b/usage/breakdown",
        ])
    }

    private nonisolated static func makeResponse(
        url: URL,
        body: String,
        statusCode: Int = 200) -> (Data, URLResponse)
    {
        let response = HTTPURLResponse(
            url: url,
            statusCode: statusCode,
            httpVersion: "HTTP/1.1",
            headerFields: ["Content-Type": "application/json"])!
        return (Data(body.utf8), response)
    }
}