import assert from "node:assert/strict";
import test from "node:test";

import {
  MODEL_PROFILE_KEYS,
  MODEL_PROFILES,
  resolveModelProfile,
  resolveModelId,
} from "../lib/ai/model-profiles";
import type { ModelProfileKey } from "../lib/ai/model-profiles";

type AssertNoExtraProfiles = Array<
  (typeof MODEL_PROFILE_KEYS)[number]
>;

const assertNoExtraProfiles: AssertNoExtraProfiles = [
  "classification",
  "multimodalAudit",
  "germanCopy",
  "qualityReview",
];

test("all required model profiles exist", () => {
  const keys = Object.keys(MODEL_PROFILES).sort();

  assert.deepEqual(keys, [...assertNoExtraProfiles].sort());
});

test("each profile includes required contract fields", () => {
  const profileEntries = Object.entries(MODEL_PROFILES) as Array<
    [ModelProfileKey, unknown]
  >;

  for (const [key, rawProfile] of profileEntries) {
    const profile = rawProfile as {
      modelId: string;
      temperature: number;
      maxTokens: number;
      supportsImages: boolean;
      stage: string;
      envOverrideKey: string;
    };

    assert.equal(typeof profile.modelId, "string", `${key} modelId`);
    assert.equal(
      profile.modelId.length > 0,
      true,
      `${key} modelId should be non-empty`,
    );
    assert.equal(typeof profile.temperature, "number", `${key} temperature`);
    assert.equal(typeof profile.maxTokens, "number", `${key} maxTokens`);
    assert.equal(
      Number.isFinite(profile.temperature),
      true,
      `${key} temperature numeric`,
    );
    assert.equal(
      Number.isInteger(profile.maxTokens),
      true,
      `${key} maxTokens integer`,
    );
    assert.equal(
      typeof profile.supportsImages,
      "boolean",
      `${key} supportsImages`,
    );
    assert.equal(typeof profile.stage, "string", `${key} stage`);
    assert.equal(profile.stage.length > 0, true, `${key} stage label`);
    assert.equal(typeof profile.envOverrideKey, "string", `${key} env override`);
    assert.equal(profile.envOverrideKey.length > 0, true, `${key} env key`);
  }
});

test("multimodal profile explicitly supports images", () => {
  assert.equal(MODEL_PROFILES.multimodalAudit.supportsImages, true);
});

test("non-multimodal profiles disable image support", () => {
  assert.equal(MODEL_PROFILES.classification.supportsImages, false);
  assert.equal(MODEL_PROFILES.germanCopy.supportsImages, false);
  assert.equal(MODEL_PROFILES.qualityReview.supportsImages, false);
});

test("model IDs can be overridden via dedicated env variables", () => {
  assert.equal(
    resolveModelId("classification", {
      OPENROUTER_MODEL_CLASSIFICATION: "custom/classification",
    }),
    "custom/classification",
  );
  assert.equal(
    resolveModelId("multimodalAudit", {
      OPENROUTER_MODEL_MULTIMODAL_AUDIT: "custom/multimodal",
    }),
    "custom/multimodal",
  );
  assert.equal(
    resolveModelId("germanCopy", {
      OPENROUTER_MODEL_GERMAN_COPY: "custom/german",
    }),
    "custom/german",
  );
  assert.equal(
    resolveModelId("qualityReview", {
      OPENROUTER_MODEL_QUALITY_REVIEW: "custom/quality",
    }),
    "custom/quality",
  );
});

test("ENV overrides are ignored when empty", () => {
  assert.equal(
    resolveModelId("classification", {
      OPENROUTER_MODEL_CLASSIFICATION: "",
    }),
    MODEL_PROFILES.classification.modelId,
  );
});

test("resolveModelProfile returns profile config including runtime values", () => {
  const profile = resolveModelProfile("qualityReview", {
    OPENROUTER_MODEL_QUALITY_REVIEW: "custom/quality-review-profile",
  });

  assert.equal(profile.stage, "qualityReview");
  assert.equal(profile.maxTokens, MODEL_PROFILES.qualityReview.maxTokens);
  assert.equal(profile.temperature, MODEL_PROFILES.qualityReview.temperature);
  assert.equal(profile.supportsImages, MODEL_PROFILES.qualityReview.supportsImages);
  assert.equal(profile.modelId, "custom/quality-review-profile");
});