import Foundation
import UsageCore

// Proves the Swift -> C ABI -> core path, with no network: the responses come from the recorded
// fixtures the TypeScript and Zig implementations are compared against.
// Pass the fixtures directory as argv[1], or let the two likely working directories decide: the
// package directory (`swift run` from swift/) or repository root.
func locateFixtures() -> URL {
	if CommandLine.arguments.count > 1 {
		return URL(fileURLWithPath: CommandLine.arguments[1])
	}
	let cwd = URL(fileURLWithPath: FileManager.default.currentDirectoryPath)
	for candidate in ["../tests/fixtures", "tests/fixtures"] {
		let url = cwd.appendingPathComponent(candidate)
		if FileManager.default.fileExists(atPath: url.appendingPathComponent("codex-usage-live.json").path) {
			return url
		}
	}
	fail("cannot find tests/fixtures; pass the directory as the first argument")
}

let fixtures = locateFixtures()

func fixture(_ name: String) throws -> String {
	try String(contentsOf: fixtures.appendingPathComponent(name), encoding: .utf8)
}

func fail(_ message: String) -> Never {
	FileHandle.standardError.write(Data("FAIL: \(message)\n".utf8))
	exit(1)
}

func check(_ condition: Bool, _ message: String) {
	if !condition { fail(message) }
}

do {
	check(UsageCore.abiVersion == 4, "unexpected ABI version \(UsageCore.abiVersion)")

	let providers = try UsageCore.providers()
	check(providers.contains { $0.provider == "openai-codex" }, "codex should be a known provider")
	check(providers.first { $0.provider == "anthropic" }?.credentialKinds == ["oauth"], "anthropic takes oauth")
	check(providers.first { $0.provider == "opencode-go" }?.credentialKinds == ["oauth", "apiKey"], "opencode-go takes oauth and apiKey")

	let codexCredential = UsageDriver.credentialJSON(kind: "oauth", value: "test-token", email: "codex@example.com")
	let firstStep = try UsageCore.advance(provider: "openai-codex", credentialJSON: codexCredential, responses: [], nowMs: 1_789_514_000_000)
	guard case .requests(let requests) = firstStep else { fail("expected a request, not a report") }
	check(requests.count == 1, "codex needs one request")
	check(requests[0].url.hasSuffix("/wham/usage"), "unexpected codex url \(requests[0].url)")
	check(requests[0].headers["Authorization"] == "Bearer test-token", "codex must send the bearer token")

	guard let codexReport = try UsageCore.advance(
		provider: "openai-codex",
		credentialJSON: codexCredential,
		responses: [UsageResponse(status: 200, body: try fixture("codex-usage-live.json"))],
		nowMs: 1_789_514_000_000
	).reportValue else { fail("codex should report") }

	check(codexReport.planType == "prolite", "plan type \(codexReport.planType ?? "nil")")
	check(codexReport.limits.count == 3, "expected three windows, got \(codexReport.limits.count)")
	check(codexReport.limits.first?.status == "exhausted", "the primary window is at 100%")

	// anthropic: round 1 fetches usage and profile concurrently; round 2 reports with ISO reset converted to epoch ms.
	let anthropicCredential = UsageDriver.credentialJSON(kind: "oauth", value: "test-token")
	let anthropicStep = try UsageCore.advance(provider: "anthropic", credentialJSON: anthropicCredential, responses: [], nowMs: 1_700_000_000_000)
	guard case .requests(let anthropicRequests) = anthropicStep else { fail("anthropic should ask for requests") }
	check(anthropicRequests.count == 2, "anthropic asks for usage and profile, got \(anthropicRequests.count)")

	guard let anthropicReport = try UsageCore.advance(
		provider: "anthropic",
		credentialJSON: anthropicCredential,
		responses: [
			UsageResponse(status: 200, body: try fixture("anthropic-usage.json")),
			UsageResponse(status: 200, body: try fixture("anthropic-profile.json")),
		],
		nowMs: 1_700_000_000_000
	).reportValue else { fail("anthropic should report") }

	check(anthropicReport.limits.count == 2, "expected session and weekly, got \(anthropicReport.limits.count)")
	let weekly = anthropicReport.limits[1]
	check(weekly.label == "Weekly", "second window is the week")
	check(weekly.usedPercent == 94, "weekly is 94% used, got \(weekly.usedPercent ?? -1)")
	check(weekly.resetsAt == 1_789_545_600_037, "ISO reset should become epoch ms, got \(weekly.resetsAt ?? -1)")
	check(weekly.status == "warning", "severity critical is a warning below 100%")
	check(anthropicReport.planType == "team_standard", "plan type from the profile")


	// google-antigravity: the endpoint is gated on the antigravity user-agent, and the body reports
	// REMAINING fraction, so usedPercent is an inversion. Both are pinned here because both are easy
	// to "fix" into something that looks fine and is wrong.
	let antigravityCredential = UsageDriver.credentialJSON(kind: "oauth", value: "ya29.test")
	let antigravityStep = try UsageCore.advance(provider: "google-antigravity", credentialJSON: antigravityCredential, responses: [], nowMs: 1_789_514_000_000)
	guard case .requests(let antigravityRequests) = antigravityStep else { fail("antigravity should ask for a request") }
	check(antigravityRequests.count == 1, "antigravity needs one request")
	check(antigravityRequests[0].method == "POST", "antigravity is a POST")
	check(antigravityRequests[0].headers["User-Agent"]?.hasPrefix("antigravity/") == true, "without the antigravity user-agent the endpoint answers 403")

	guard let antigravityReport = try UsageCore.advance(
		provider: "google-antigravity",
		credentialJSON: antigravityCredential,
		responses: [UsageResponse(status: 200, body: try fixture("antigravity-quota.json"))],
		nowMs: 1_789_514_000_000
	).reportValue else { fail("antigravity should report") }

	guard let gemini = antigravityReport.limits.first(where: { $0.label == "Gemini" }) else {
		fail("antigravity should pool a Gemini family, got \(antigravityReport.limits.map(\.label))")
	}
	check(gemini.usedPercent == 83.4, "remaining 0.166 must invert to 83.4, got \(gemini.usedPercent ?? -1)")
	check(gemini.detail == "17% free", "the detail keeps the free share, got \(gemini.detail ?? "nil")")
	check(!antigravityReport.limits.contains { $0.label.lowercased().contains("chat") || $0.label.lowercased().contains("tab") }, "internal buckets must be dropped")

	// alibaba: CLI-first, 127 fallback to console session, and a FRACTION that has to become a percentage.
	let alibabaSession = #"{"url":"https://bailian-singapore-cs.alibabacloud.com/data/api.json","region":"ap-southeast-1","secToken":"test-csrf","headers":{"cookie":"login_aliyunid=test"}}"#
	let alibabaStep = try UsageCore.advance(provider: "alibaba", credentialJSON: UsageDriver.credentialJSON(kind: "session", value: alibabaSession), responses: [], nowMs: 1_789_514_000_000)
	guard case .requests(let cliRequests) = alibabaStep else { fail("alibaba should ask for the bl command first") }
	check(cliRequests.count == 1, "alibaba asks for one command request first, got \(cliRequests.count)")
	check(cliRequests[0].kind == "command", "first request is a command")
	check(cliRequests[0].command == "bl", "command is bl")
	check(cliRequests[0].args?.contains("usage") == true, "args contain usage")
	check(cliRequests[0].args?.contains("token-plan") == true, "args contain token-plan")
	check(cliRequests[0].args?.contains("--console-region") == true, "args contain --console-region")
	check(cliRequests[0].args?.contains("ap-southeast-1") == true, "args contain ap-southeast-1")
	check(cliRequests[0].args?.contains("international") == true, "args contain international")

	// Host runs no commands -> falls back to four console HTTP requests
	let noCommands = [UsageResponse(status: 127, body: "this host does not run commands (bl)")]
	let consoleStep = try UsageCore.advance(provider: "alibaba", credentialJSON: UsageDriver.credentialJSON(kind: "session", value: alibabaSession), responses: noCommands, nowMs: 1_789_514_000_000)
	guard case .requests(let alibabaRequests) = consoleStep else { fail("alibaba should ask for its four console calls on 127") }
	check(alibabaRequests.count == 4, "alibaba reads usage, subscription, quota-config and reset cards, got \(alibabaRequests.count)")
	check(alibabaRequests[0].kind == "http", "console calls are HTTP")
	check(alibabaRequests[0].method == "POST", "the console gateway is a POST")
	check(alibabaRequests[0].headers["cookie"] == "login_aliyunid=test", "the captured cookies have to travel with the request")
	check(alibabaRequests[0].body?.contains("sec_token=test-csrf") == true, "the form body carries the session csrf token")
	check(alibabaRequests[0].body?.contains("region=ap-southeast-1") == true, "and the region")

	guard let alibabaReport = try UsageCore.advance(
		provider: "alibaba",
		credentialJSON: UsageDriver.credentialJSON(kind: "session", value: alibabaSession),
		responses: [
			UsageResponse(status: 200, body: try fixture("alibaba-usage.json")),
			UsageResponse(status: 200, body: try fixture("alibaba-subscription.json")),
			UsageResponse(status: 200, body: try fixture("alibaba-quota-config.json")),
			UsageResponse(status: 200, body: try fixture("alibaba-reset-card_list.json")),
		],
		nowMs: 1_789_514_000_000
	).reportValue else { fail("alibaba should report from console") }

	check(alibabaReport.planType == "pro", "plan type is pro")
	check(alibabaReport.limits.count == 1, "expected weekly limit")
	check(alibabaReport.limits[0].label == "Weekly", "weekly label")
	check(alibabaReport.notes?.contains(where: { $0.contains("days remaining in the plan") }) == true, "notes carry remaining days")
	check(alibabaReport.notes?.contains(where: { $0.contains("Token plan pro") }) == true, "notes carry quota config")

	// hyper: multi-round flow with UsageState preserving team across calls
	let hyperState = UsageState()
	let hyperCredential = UsageDriver.credentialJSON(kind: "apiKey", value: "sk-hyper-test")
	let hyperStep0 = try UsageCore.advance(state: hyperState, provider: "hyper", credentialJSON: hyperCredential, responses: [], nowMs: 1_789_514_000_000)
	guard case .requests(let hyperReq0) = hyperStep0 else { fail("hyper should ask for teams first") }
	check(hyperReq0.count == 1, "hyper round 1 asks for teams")
	check(hyperReq0[0].url.hasSuffix("/v1/teams"), "teams url")

	let hyperTeamsResponse = [UsageResponse(status: 200, body: try fixture("hyper-teams.json"))]
	let hyperStep1 = try UsageCore.advance(state: hyperState, provider: "hyper", credentialJSON: hyperCredential, responses: hyperTeamsResponse, nowMs: 1_789_514_000_000)
	guard case .requests(let hyperReq1) = hyperStep1 else { fail("hyper round 2 should ask for billing and members") }
	check(hyperReq1.count == 2, "hyper asks for billing and members")

	let hyperDataResponses = [
		UsageResponse(status: 200, body: try fixture("hyper-billing.json")),
		UsageResponse(status: 200, body: try fixture("hyper-members.json")),
	]
	guard let hyperReport = try UsageCore.advance(state: hyperState, provider: "hyper", credentialJSON: hyperCredential, responses: hyperDataResponses, nowMs: 1_789_514_000_000).reportValue else {
		fail("hyper should report")
	}
	check(hyperReport.planType == "shred", "hyper planType shred")
	check(hyperReport.notes?.contains("Team: Example Team") == true, "hyper preserved team name in state across rounds")

	// An unknown provider is an error, not an empty report.
	do {
		_ = try UsageCore.advance(provider: "nope", credentialJSON: "{}", responses: [], nowMs: 0)
		fail("an unknown provider should throw")
	} catch UsageCoreError.providerRefused(let message) {
		check(message.contains("unknown provider"), "unexpected message: \(message)")
	}

	print("usage-smoke: abi=\(UsageCore.abiVersion) providers=\(providers.count) codex=\(codexReport.limits.count) anthropic=\(anthropicReport.limits.count) hyper=\(hyperReport.limits.count) antigravity=\(antigravityReport.limits.count) alibaba=\(alibabaRequests.count) calls OK")
} catch {
	fail("\(error)")
}