/**
 * Offline checks on the extension: what it registers, with no network and no Prime Agent.
 *
 *   npm test
 *
 * The live claims (membership, prices, streaming, cache accounting) are `verify.ts`; this
 * covers the derivation and the key precedence, where a silent mistake would be invisible.
 */

import assert from "node:assert/strict";
import { readFileSync } from "node:fs";
import { dirname, join } from "node:path";
import { fileURLToPath } from "node:url";
import type { OpenAICompletionsCompat } from "@earendil-works/pi-ai";
import type { ExtensionAPI, ProviderConfig } from "@earendil-works/pi-coding-agent";
import { type ModelFacts, toProviderModel } from "./catalog.js";
import { API_KEY_CONFIG, ENV_VAR, resolveKey, storedKey, storedKeyFrom } from "./hyper.js";
import hyper from "./index.js";

const here = dirname(fileURLToPath(import.meta.url));
const catalog = JSON.parse(readFileSync(join(here, "catalog.json"), "utf-8")) as { models: ModelFacts[] };

// A provider entry is one credential or a list of them; both shapes must resolve.
assert.equal(storedKeyFrom({ hyper: { type: "api_key", key: "k1" } }), "k1");
assert.equal(
	storedKeyFrom({ hyper: [{ type: "oauth", access: "a" }, { type: "api_key", key: "k2" }] }),
	"k2",
	"a subscription entry must not hide the API key beside it",
);
assert.equal(storedKeyFrom({ hyper: [{ type: "oauth", access: "a" }] }), undefined);
assert.equal(storedKeyFrom({}), undefined);
assert.equal(storedKeyFrom(null), undefined);

process.env.PI_OFFLINE = "1";
assert.equal(
	API_KEY_CONFIG,
	`!printf %s "$${ENV_VAR}"`,
	"the config fallback must read the env var and resolve to nothing when it is unset",
);
delete process.env[ENV_VAR];
assert.equal(resolveKey(), storedKey(), "without HYPER_API_KEY the stored credential is the source");
assert.ok(storedKey() === undefined || !storedKey()?.includes(" "), "a stored key is a single token");
assert.ok(
	storedKey() === undefined || resolveKey() === storedKey(),
	"nothing but auth.json or the env var may supply a key",
);
process.env[ENV_VAR] = "sk-hyper-test";
assert.equal(resolveKey(), "sk-hyper-test", "HYPER_API_KEY must win over the stored credential");

const registrations: Array<{ name: string; config: ProviderConfig }> = [];
const commands: string[] = [];
await hyper({
	registerProvider: (name: string, config: ProviderConfig) => {
		registrations.push({ name, config });
	},
	registerCommand: (name: string) => {
		commands.push(name);
	},
} as unknown as ExtensionAPI);

assert.equal(registrations.length, 1, "the extension must register exactly one provider");
const provider = registrations[0] as { name: string; config: ProviderConfig };
assert.equal(provider.name, "hyper");
assert.equal(provider.config.name, "Charm Hyper");
assert.equal(provider.config.baseUrl, "https://hyper.charm.land/v1");
assert.equal(provider.config.api, "openai-completions");
assert.equal(provider.config.models?.length, catalog.models.length, "every catalog model must be registered");
assert.ok(provider.config.oauth, "subscription login must be offered");
assert.equal(typeof provider.config.oauth?.login, "function");
assert.equal(typeof provider.config.oauth?.refreshToken, "function");
assert.deepEqual(commands, ["hyper"]);

const ids = (provider.config.models ?? []).map((model) => model.id);
assert.deepEqual(ids, catalog.models.map((model) => model.id), "registered models must follow the catalog order");

for (const model of catalog.models) {
	const config = toProviderModel(model);
	const compat = config.compat as OpenAICompletionsCompat;
	assert.equal(compat.maxTokensField, "max_tokens", `${model.id}: Hyper takes max_tokens`);
	assert.equal(compat.supportsStore, false, `${model.id}: Hyper has no response store`);
	assert.equal(compat.thinkingFormat, "openai", `${model.id}: reasoning goes through reasoning_effort`);
	assert.ok(config.contextWindow > 0 && config.maxTokens > 0, `${model.id}: limits must be positive`);
	assert.deepEqual(config.cost, model.cost, `${model.id}: cost must be the catalog price`);
	assert.deepEqual(
		config.input,
		model.vision ? ["text", "image"] : ["text"],
		`${model.id}: image input must follow vision support`,
	);

	if (!model.reasoning) {
		assert.equal(config.reasoning, false, `${model.id}: must not claim reasoning`);
		assert.equal(config.thinkingLevelMap, undefined, `${model.id}: must not offer thinking controls`);
		assert.equal(compat.supportsReasoningEffort, false, `${model.id}: must not send reasoning_effort`);
		continue;
	}

	assert.equal(config.reasoning, true, `${model.id}: must claim reasoning`);
	assert.equal(compat.supportsReasoningEffort, true, `${model.id}: must be allowed to send reasoning_effort`);
	const on = model.levels.filter((level) => level !== "none" && level !== "off");
	const offered = Object.entries(config.thinkingLevelMap ?? {})
		.filter(([, value]) => value !== null && value !== "none" && value !== "off")
		.map(([level]) => level);
	assert.deepEqual(offered.sort(), (on.length > 0 ? on : ["max"]).sort(), `${model.id}: offered levels must be the advertised ones`);
	assert.equal(
		config.thinkingLevelMap?.off,
		model.levels.includes("none") ? "none" : null,
		`${model.id}: the off level must follow an advertised none`,
	);
}

process.stdout.write(`ok: ${ids.length} models registered, key precedence and derivation checked\n`);