import assert from "node:assert/strict";
import test from "node:test";
import { ProviderModelMismatchError } from "./errors";
import {
    getModelDefaultProvider,
    inferenceProviderToLegacy,
    normalizeRequestProvider,
    resolveInferenceProvider,
    validateProviderModelPair,
} from "./resolveProvider";
import { resetInferenceManifestCache } from "./config";

test.beforeEach(() => {
    resetInferenceManifestCache();
    delete process.env.INFERENCE_MANIFEST_PATH;
});

test("normalizeRequestProvider maps legacy frontend aliases", () => {
    assert.equal(normalizeRequestProvider("openai-api"), "proxy-openai");
    assert.equal(normalizeRequestProvider("openai"), "proxy-openai");
    assert.equal(normalizeRequestProvider("gemini_sdk"), "google-genai");
    assert.equal(normalizeRequestProvider("gemini"), "google-genai");
});

test("explicit openai-api beats model registry default", () => {
    const provider = resolveInferenceProvider({
        explicitRequestProvider: "openai-api",
        model: "gemini-3-flash-agent-high",
        featureId: "chat",
    });
    assert.equal(provider, "proxy-openai");
});

test("feature override applies when explicit provider is absent", () => {
    const provider = resolveInferenceProvider({
        model: "gemini-3-flash-agent-high",
        featureId: "python-review",
    });
    assert.equal(provider, "proxy-openai");
});

test("model registry default applies when feature override is absent", () => {
    assert.equal(
        getModelDefaultProvider("gemini-3.5-flash-high"),
        "proxy-openai",
    );
    assert.equal(
        getModelDefaultProvider("gemini-3-flash-agent-high"),
        "proxy-openai",
    );
});

test("manifest default provider applies for unknown models", () => {
    const provider = resolveInferenceProvider({
        model: "unknown-model-id",
    });
    assert.equal(provider, "proxy-openai");
});

test("explicit provider incompatible with model throws mismatch error", () => {
    assert.throws(
        () =>
            resolveInferenceProvider({
                explicitRequestProvider: "gemini_sdk",
                model: "gemini-3.5-flash-high",
            }),
        ProviderModelMismatchError,
    );
});

test("validateProviderModelPair returns structured mismatch result", () => {
    const result = validateProviderModelPair({
        model: "gemini-3.5-flash-high",
        inferenceProvider: "gemini_sdk",
        featureId: "chat",
    });
    assert.deepEqual(result, { ok: false, error: "provider_model_mismatch" });
});

test("default frontend chat payload is accepted", () => {
    const result = validateProviderModelPair({
        model: "gemini-3.5-flash-high",
        inferenceProvider: "openai-api",
        featureId: "chat",
    });
    assert.equal(result.ok, true);
    if (result.ok) {
        assert.equal(result.provider, "proxy-openai");
        assert.equal(inferenceProviderToLegacy(result.provider), "openai");
    }
});

test("unknown explicit provider is rejected", () => {
    assert.throws(
        () =>
            resolveInferenceProvider({
                explicitRequestProvider: "anthropic-direct",
                model: "gemini-3-flash-agent-high",
            }),
        ProviderModelMismatchError,
    );
});