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

import {
  FOUNDATION_FLAG,
  FRIENDLY_MODES_FLAG,
  MODE_ORDER,
  buildModeRequest,
  createFriendlyModesAdapter,
  friendlyModesEnabled,
  normalizeAdvancedRoutes,
  normalizeMode,
  normalizeModeCatalog,
  normalizeResolvedRoute,
} from "../../dockerfiles/hermes-webui-hux/modes/model.ts";

const constraints = (providers, localOnly = false) => ({
  providers,
  local_only: localOnly,
  effort: { min: "low", max: "high" },
  tools: {
    web: "allowed",
    shell: "allowed",
    artifacts: "allowed",
    delegate: "allowed",
  },
  memory: { read: true, write: true },
  citations_required: false,
  retention: "default",
});

const labels = {
  fast: "Fast",
  thoughtful: "Thoughtful",
  research: "Research",
  create: "Create",
  private: "Private",
};

function mode(name, extra = {}) {
  const isPrivate = name === "private";
  return {
    schema: "hux.mode.v1",
    mode: name,
    label: labels[name],
    intent: `${labels[name]} response intent`,
    constraints: constraints(
      isPrivate ? ["local"] : ["claude", "codex"],
      isPrivate,
    ),
    switchyard: { route_id: `atlas/auto/${name}` },
    ...extra,
  };
}

const catalog = () => MODE_ORDER.map((name) => mode(name));

test("friendly modes remain default-off and depend on HUX foundation", () => {
  assert.equal(friendlyModesEnabled(), false);
  assert.equal(friendlyModesEnabled([]), false);
  assert.equal(friendlyModesEnabled([FOUNDATION_FLAG]), false);
  assert.equal(friendlyModesEnabled([FRIENDLY_MODES_FLAG]), false);
  assert.equal(
    friendlyModesEnabled([FOUNDATION_FLAG, FRIENDLY_MODES_FLAG]),
    true,
  );
});

test("valid catalog is canonical and automatic modes preserve both pools", () => {
  const normalized = normalizeModeCatalog(catalog());
  assert.ok(normalized);
  assert.deepEqual(normalized.map((item) => item.mode), MODE_ORDER);
  for (const intent of normalized.slice(0, -1)) {
    assert.deepEqual(intent.constraints.providers, ["codex", "claude"]);
    assert.equal(intent.constraints.local_only, false);
    assert.match(intent.switchyard.route_id, /^atlas\/auto\//);
    assert.equal("override_route_id" in intent.switchyard, false);
  }
  assert.deepEqual(normalized.at(-1).constraints.providers, ["local"]);
  assert.equal(normalized.at(-1).constraints.local_only, true);
});

test("catalog rejects missing, duplicate, and malformed entries", () => {
  assert.equal(normalizeModeCatalog({}), null);
  assert.equal(normalizeModeCatalog(catalog().slice(1)), null);
  assert.equal(normalizeModeCatalog([...catalog().slice(0, 4), mode("fast")]), null);
  assert.equal(normalizeModeCatalog([...catalog().slice(0, 4), null]), null);
});

test("mode validation is exact and fail-closed", () => {
  assert.equal(normalizeMode(null), null);
  assert.equal(normalizeMode({ ...mode("fast"), surprise: true }), null);
  assert.equal(normalizeMode({ ...mode("fast"), schema: "hux.mode.v0" }), null);
  assert.equal(normalizeMode({ ...mode("fast"), mode: "turbo" }), null);
  assert.equal(normalizeMode({ ...mode("fast"), label: "Claude Fast" }), null);
  assert.equal(normalizeMode({ ...mode("fast"), intent: "" }), null);
  assert.equal(normalizeMode({ ...mode("fast"), intent: "x".repeat(401) }), null);
  assert.equal(
    normalizeMode({ ...mode("fast"), switchyard: { route_id: "vendor/default" } }),
    null,
  );
  assert.equal(
    normalizeMode({
      ...mode("fast"),
      switchyard: { route_id: "atlas/auto/claude/fast" },
    }),
    null,
  );
  assert.equal(
    normalizeMode({ ...mode("fast"), intent: "Prefer OpenAI for this mode" }),
    null,
  );
  assert.equal(
    normalizeMode({
      ...mode("fast"),
      switchyard: {
        route_id: "atlas/auto/fast",
        override_route_id: "atlas/manual/codex/high",
      },
    }),
    null,
  );
});

test("constraint validation rejects provider bias and malformed nested policy", () => {
  const invalid = [
    constraints([], false),
    constraints(["codex"], false),
    constraints(["claude"], false),
    constraints(["codex", "codex"], false),
    constraints(["codex", "unknown"], false),
    { ...constraints(["codex", "claude"]), local_only: true },
    { ...constraints(["codex", "claude"]), effort: { min: "high", max: "low" } },
    { ...constraints(["codex", "claude"]), tools: null },
    {
      ...constraints(["codex", "claude"]),
      tools: { ...constraints([]).tools, web: "sometimes" },
    },
    { ...constraints(["codex", "claude"]), memory: { read: true } },
    { ...constraints(["codex", "claude"]), citations_required: "no" },
    { ...constraints(["codex", "claude"]), retention: "forever" },
    { ...constraints(["codex", "claude"]), secret: "value" },
  ];
  for (const value of invalid) {
    assert.equal(normalizeMode({ ...mode("fast"), constraints: value }), null);
  }
});

test("Private is strictly local-only while non-private can include local", () => {
  assert.equal(
    normalizeMode({ ...mode("private"), constraints: constraints(["codex"], true) }),
    null,
  );
  assert.equal(
    normalizeMode({ ...mode("private"), constraints: constraints(["local"], false) }),
    null,
  );
  assert.ok(
    normalizeMode({
      ...mode("research"),
      constraints: constraints(["local", "claude", "codex"]),
    }),
  );
});

test("advanced catalog keeps only bounded exact manual route choices", () => {
  const raw = [
    {
      route_id: "atlas/manual/codex/high",
      label: "Deep route",
      provider: "codex",
      effort: "high",
      local_only: false,
    },
    {
      route_id: "atlas/manual/local/private",
      label: "Local route",
      provider: "local",
      effort: "medium",
      local_only: true,
    },
    {
      route_id: "atlas/auto/claude/high",
      label: "Not a pin",
      provider: "claude",
      effort: "high",
      local_only: false,
    },
    {
      route_id: "atlas/manual/codex/high",
      label: "Duplicate",
      provider: "codex",
      effort: "high",
      local_only: false,
    },
    null,
  ];
  assert.deepEqual(normalizeAdvancedRoutes({}), []);
  assert.deepEqual(
    normalizeAdvancedRoutes(raw).map((choice) => choice.routeId),
    ["atlas/manual/codex/high", "atlas/manual/local/private"],
  );
});

test("exact pin is created only from an explicit compatible advanced choice", () => {
  const automatic = normalizeMode(mode("fast"));
  const privateMode = normalizeMode(mode("private"));
  const choices = normalizeAdvancedRoutes([
    {
      route_id: "atlas/manual/codex/high",
      label: "OpenAI high",
      provider: "codex",
      effort: "high",
      local_only: false,
    },
    {
      route_id: "atlas/manual/local/private",
      label: "Local",
      provider: "local",
      effort: "medium",
      local_only: true,
    },
  ]);
  assert.deepEqual(buildModeRequest(automatic), automatic);
  assert.equal(buildModeRequest(null), null);
  assert.equal(buildModeRequest(automatic, "atlas/manual/unknown", choices), null);
  assert.equal(
    buildModeRequest(automatic, "atlas/manual/local/private", choices),
    null,
  );
  assert.equal(
    buildModeRequest(privateMode, "atlas/manual/codex/high", choices),
    null,
  );
  assert.equal(
    buildModeRequest(privateMode, "atlas/manual/local/private", choices)
      .switchyard.override_route_id,
    "atlas/manual/local/private",
  );
  assert.equal(
    buildModeRequest(automatic, "atlas/manual/codex/high", choices).switchyard
      .override_route_id,
    "atlas/manual/codex/high",
  );
});

test("resolved route disclosure validates the shared hux.v1 route shape", () => {
  assert.deepEqual(
    normalizeResolvedRoute({
      requested: "fast",
      resolved_target: "route/codex/luna/low",
      provider: "codex",
      effort: "low",
    }),
    {
      requested: "fast",
      target: "route/codex/luna/low",
      provider: "codex",
      effort: "low",
    },
  );
  assert.deepEqual(normalizeResolvedRoute({ requested: "private" }), {
    requested: "private",
    target: undefined,
    provider: undefined,
    effort: undefined,
  });
  for (const invalid of [
    null,
    {},
    { requested: "" },
    { requested: "fast", provider: "gemini" },
    { requested: "fast", effort: "ultra" },
    { requested: "fast", raw: "secret" },
    { requested: "fast", resolved_target: 7 },
  ]) {
    assert.equal(normalizeResolvedRoute(invalid), null);
  }
});

test("foundation adapter preserves version, flags, endpoint, and validators", () => {
  const calls = [];
  const foundation = {
    apiVersion: "hux.v1",
    enabled: (flag) => flag === FOUNDATION_FLAG || flag === FRIENDLY_MODES_FLAG,
    endpoint: (path) => (calls.push(path), `/hux/v1${path}`),
  };
  const adapter = createFriendlyModesAdapter(foundation);
  assert.equal(adapter.apiVersion, "hux.v1");
  assert.equal(adapter.enabled(), true);
  assert.equal(adapter.endpoint(), "/hux/v1/modes");
  assert.deepEqual(calls, ["/modes"]);
  assert.ok(adapter.adaptCatalog(catalog()));
  assert.equal(adapter.adaptResolvedRoute({}), null);
  assert.ok(adapter.buildRequest(normalizeMode(mode("fast"))));
  assert.throws(() => createFriendlyModesAdapter(null), TypeError);
  assert.throws(
    () => createFriendlyModesAdapter({ ...foundation, apiVersion: "hux.v0" }),
    TypeError,
  );
  assert.equal(
    createFriendlyModesAdapter({ ...foundation, enabled: () => false }).enabled(),
    false,
  );
});