import { describe, expect, it } from "vite-plus/test";

import { ProviderInstanceId, type ProviderOptionDescriptor } from "@t3tools/contracts";

import type { ModelOption, ProviderGroup } from "../../lib/modelOptions";
import { buildThreadSettingsMenu, type ThreadSettingsMenuEvent } from "./thread-settings-menu";

function modelOption(
  model: string,
  overrides: Partial<Pick<ModelOption, "isDefault" | "isLegacy" | "providerKey">> = {},
): ModelOption {
  const providerKey = overrides.providerKey ?? "codex";
  return {
    key: `${providerKey}:${model}`,
    label: model,
    subtitle: providerKey,
    providerKey,
    providerLabel: providerKey === "codex" ? "Codex" : "Claude",
    providerDriver: providerKey === "codex" ? "codex" : "claudeAgent",
    isDefault: overrides.isDefault ?? false,
    isLegacy: overrides.isLegacy ?? false,
    capabilities: null,
    selection: {
      instanceId: ProviderInstanceId.make(providerKey),
      model,
      options: [],
    },
  };
}

function group(models: ReadonlyArray<ModelOption>): ProviderGroup {
  const first = models[0];
  if (!first) {
    throw new Error("group requires at least one model");
  }
  return {
    providerKey: first.providerKey,
    providerLabel: first.providerLabel,
    models,
  };
}

const effortDescriptor: ProviderOptionDescriptor = {
  id: "effort",
  label: "Reasoning",
  type: "select",
  options: [
    { id: "low", label: "Low" },
    { id: "medium", label: "Medium", isDefault: true },
    { id: "high", label: "High" },
    { id: "ultrathink", label: "Ultrathink" },
    { id: "ultracode", label: "Ultracode" },
  ],
  currentValue: "high",
  promptInjectedValues: ["ultrathink"],
};

const fastModeDescriptor: ProviderOptionDescriptor = {
  id: "fastMode",
  label: "Fast mode",
  type: "boolean",
  currentValue: false,
};

function baseInput() {
  const models = [
    modelOption("gpt-current", { isDefault: true }),
    modelOption("gpt-next"),
    modelOption("gpt-old", { isLegacy: true }),
  ];
  return {
    providerGroups: [group(models)],
    selectedModel: models[0]?.selection ?? null,
    optionDescriptors: [effortDescriptor, fastModeDescriptor],
    runtimeMode: "auto",
  } as const;
}

function eventFor(menu: ReturnType<typeof buildThreadSettingsMenu>, id: string | undefined) {
  return id === undefined ? undefined : menu.events.get(id);
}

describe("buildThreadSettingsMenu", () => {
  it("orders the top level as model, options, runtime", () => {
    const menu = buildThreadSettingsMenu(baseInput());

    expect(menu.actions.map((action) => action.title)).toEqual([
      "Model",
      "Reasoning",
      "Fast mode",
      "Runtime",
    ]);
  });

  it("summarizes the current choice on each submenu row", () => {
    const menu = buildThreadSettingsMenu(baseInput());

    expect(menu.actions.find((action) => action.title === "Model")?.subtitle).toBe("gpt-current");
    expect(menu.actions.find((action) => action.title === "Reasoning")?.subtitle).toBe("High");
    expect(menu.actions.find((action) => action.title === "Runtime")?.subtitle).toBe("Auto");
  });

  it("checkmarks the selected model and resolves selection events", () => {
    const menu = buildThreadSettingsMenu(baseInput());

    const modelItems = menu.actions.find((action) => action.title === "Model")?.subactions ?? [];
    const current = modelItems.find((action) => action.title === "gpt-current");
    expect(current?.state).toBe("on");
    expect(current?.subtitle).toBe("Default");
    expect(modelItems.find((action) => action.title === "gpt-next")?.state).toBe("off");

    const event = eventFor(menu, modelItems.find((action) => action.title === "gpt-next")?.id);
    expect(event?.type).toBe("select-model");
    expect(event?.type === "select-model" ? event.option.selection.model : null).toBe("gpt-next");
  });

  it("folds unselected legacy models behind a nested submenu", () => {
    const menu = buildThreadSettingsMenu(baseInput());

    const modelItems = menu.actions.find((action) => action.title === "Model")?.subactions ?? [];
    expect(modelItems.map((action) => action.title)).toEqual([
      "gpt-current",
      "gpt-next",
      "Legacy Models",
    ]);
    expect(
      modelItems
        .find((action) => action.title === "Legacy Models")
        ?.subactions?.map((action) => action.title),
    ).toEqual(["gpt-old"]);
  });

  it("keeps a selected legacy model in the main list", () => {
    const input = baseInput();
    const legacy = input.providerGroups[0]?.models.find((model) => model.isLegacy);
    const menu = buildThreadSettingsMenu({
      ...input,
      selectedModel: legacy?.selection ?? null,
    });

    const modelItems = menu.actions.find((action) => action.title === "Model")?.subactions ?? [];
    expect(modelItems.map((action) => action.title)).toEqual([
      "gpt-current",
      "gpt-next",
      "gpt-old",
    ]);
    expect(modelItems.find((action) => action.title === "gpt-old")?.state).toBe("on");
  });

  it("hides prompt-injected and workflow-trigger efforts but still summarizes them", () => {
    const menu = buildThreadSettingsMenu({
      ...baseInput(),
      optionDescriptors: [{ ...effortDescriptor, currentValue: "ultracode" }],
    });

    const reasoning = menu.actions.find((action) => action.title === "Reasoning");
    expect(reasoning?.subactions?.map((action) => action.title)).toEqual(["Low", "Medium", "High"]);
    // The hidden value stays visible as the current summary; it just can't be
    // picked from the phone.
    expect(reasoning?.subtitle).toBe("Ultracode");
    expect(reasoning?.subactions?.every((action) => action.state === "off")).toBe(true);
  });

  it("resolves select-option and runtime events with checkmarked current values", () => {
    const menu = buildThreadSettingsMenu(baseInput());

    const reasoningItems =
      menu.actions.find((action) => action.title === "Reasoning")?.subactions ?? [];
    expect(reasoningItems.find((action) => action.title === "High")?.state).toBe("on");
    expect(eventFor(menu, reasoningItems.find((action) => action.title === "Low")?.id)).toEqual({
      type: "set-option",
      optionId: "effort",
      value: "low",
    });

    const runtimeItems =
      menu.actions.find((action) => action.title === "Runtime")?.subactions ?? [];
    expect(runtimeItems.find((action) => action.title === "Auto")?.state).toBe("on");
    expect(
      eventFor(menu, runtimeItems.find((action) => action.title === "Full access")?.id),
    ).toEqual({ type: "set-runtime", mode: "full-access" });
  });

  it("toggles boolean options with the inverted current value", () => {
    const menu = buildThreadSettingsMenu(baseInput());

    const fastMode = menu.actions.find((action) => action.title === "Fast mode");
    expect(fastMode?.state).toBe("off");
    expect(fastMode?.subactions).toBeUndefined();
    expect(eventFor(menu, fastMode?.id)).toEqual({
      type: "set-option",
      optionId: "fastMode",
      value: true,
    });

    const enabled = buildThreadSettingsMenu({
      ...baseInput(),
      optionDescriptors: [{ ...fastModeDescriptor, currentValue: true }],
    });
    const enabledRow = enabled.actions.find((action) => action.title === "Fast mode");
    expect(enabledRow?.state).toBe("on");
    expect(eventFor(enabled, enabledRow?.id)).toEqual({
      type: "set-option",
      optionId: "fastMode",
      value: false,
    });
  });

  it("keeps the menu presented only for top-level toggles", () => {
    const menu = buildThreadSettingsMenu(baseInput());

    // Root-level boolean toggles refresh in place with clean chrome, so they
    // keep the menu presented.
    expect(
      menu.actions.find((action) => action.title === "Fast mode")?.attributes?.keepsMenuPresented,
    ).toBe(true);

    // Picks inside nested submenus close the menu: staying presented leaves
    // the submenu on screen with an expanded-submenu header, and the
    // bottom-anchored collapse back out drops by the levels' height delta.
    const expected = undefined;
    const modelItems = menu.actions.find((action) => action.title === "Model")?.subactions ?? [];
    const reasoningItems =
      menu.actions.find((action) => action.title === "Reasoning")?.subactions ?? [];
    const runtimeItems =
      menu.actions.find((action) => action.title === "Runtime")?.subactions ?? [];
    const nestedPicks = [...modelItems, ...reasoningItems, ...runtimeItems].filter(
      (action) => action.subactions === undefined,
    );
    expect(nestedPicks.length).toBeGreaterThan(0);
    expect(nestedPicks.every((action) => action.attributes?.keepsMenuPresented === expected)).toBe(
      true,
    );
  });

  it("sections models by provider only when multiple groups are offered", () => {
    const codexModels = [modelOption("gpt-current", { isDefault: true })];
    const claudeModels = [modelOption("fable-5", { providerKey: "claude" })];
    const menu = buildThreadSettingsMenu({
      providerGroups: [group(codexModels), group(claudeModels)],
      selectedModel: codexModels[0]?.selection ?? null,
      optionDescriptors: [],
      runtimeMode: "auto",
    });

    const modelItems = menu.actions.find((action) => action.title === "Model")?.subactions ?? [];
    expect(
      modelItems.map((action) => ({ title: action.title, inline: action.displayInline ?? false })),
    ).toEqual([
      { title: "Codex", inline: true },
      { title: "Claude", inline: true },
    ]);
    const claudeSection = modelItems.find((action) => action.title === "Claude");
    expect(claudeSection?.subactions?.map((action) => action.title)).toEqual(["fable-5"]);
  });

  const eventTypes = (menu: ReturnType<typeof buildThreadSettingsMenu>) => {
    const types = new Set<ThreadSettingsMenuEvent["type"]>();
    for (const event of menu.events.values()) {
      types.add(event.type);
    }
    return types;
  };

  it("registers an event for every leaf action id", () => {
    const menu = buildThreadSettingsMenu(baseInput());
    const leafIds: string[] = [];
    const collect = (items: ReadonlyArray<{ id?: string; subactions?: unknown[] }>) => {
      for (const item of items) {
        if (Array.isArray(item.subactions) && item.subactions.length > 0) {
          collect(item.subactions as ReadonlyArray<{ id?: string; subactions?: unknown[] }>);
        } else if (item.id !== undefined) {
          leafIds.push(item.id);
        }
      }
    };
    collect(menu.actions);

    for (const id of leafIds) {
      expect(menu.events.get(id), `missing event for ${id}`).toBeDefined();
    }
    expect(eventTypes(menu)).toEqual(new Set(["select-model", "set-option", "set-runtime"]));
  });
});