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

import { environmentThemeDefinition, publishedThemeDefinitions } from "./useEnvironmentTheme";
import {
  getDefaultThemeColors,
  getThemeDefinition,
  installCustomTheme,
  invalidateCustomThemes,
  setEnvironmentThemes,
  THEME_COLOR_ROLES,
} from "../themePalette";

const NIGHTFALL_THEME = {
  id: "nightfall",
  name: "Nightfall",
  appearance: "dark",
  canvas: "#1a1b26",
  accent: "#7aa2f7",
} as const;

afterEach(() => {
  setEnvironmentThemes([]);
});

describe("environment themes", () => {
  it("generates every role from the two published seeds", () => {
    const theme = environmentThemeDefinition(NIGHTFALL_THEME);

    expect(theme.id).toBe("nightfall");
    expect(theme.label).toBe("Nightfall");
    expect(theme.appearance).toBe("dark");
    for (const role of THEME_COLOR_ROLES) {
      expect(theme.colors[role], `missing ${role}`).toBeTruthy();
    }
  });

  it("layers published roles over the generated palette", () => {
    const generated = environmentThemeDefinition(NIGHTFALL_THEME);
    const overridden = environmentThemeDefinition({
      ...NIGHTFALL_THEME,
      colors: { terminalSelection: "#292e42", error: "#f7768e" },
    });

    expect(overridden.colors.terminalSelection).not.toBe(generated.colors.terminalSelection);
    expect(overridden.colors.error).not.toBe(generated.colors.error);
    // Roles the machine did not publish keep the generated value.
    expect(overridden.colors.sidebar).toBe(generated.colors.sidebar);
  });

  // The standard exported theme file — the Download button's output — is a
  // valid published theme, so any shared theme can be dropped into the
  // machine's themes directory as-is.
  it("renders an exported theme file on the stock defaults", () => {
    const theme = environmentThemeDefinition({
      id: "shared-light",
      version: 1,
      name: "Shared Light",
      appearance: "light",
      colors: { canvas: "oklch(0.95 0.01 250)", accent: "#1e66f5" },
      variants: { dark: { canvas: "#1a1b26" } },
    });

    expect(theme.label).toBe("Shared Light");
    expect(theme.colors.accent).toBeTruthy();
    expect(theme.variants?.dark?.canvas).toBeTruthy();
    for (const role of THEME_COLOR_ROLES) {
      expect(theme.colors[role], `missing ${role}`).toBeTruthy();
      expect(theme.variants?.dark?.[role], `missing dark ${role}`).toBeTruthy();
    }
  });

  // The generator follows the seed canvas's luminance, so a dark theme's
  // seeds must never produce its light variant: the variant builds on that
  // appearance's stock defaults instead.
  it("builds a seeded theme's variant on the variant appearance's defaults", () => {
    const theme = environmentThemeDefinition({
      ...NIGHTFALL_THEME,
      variants: { light: { canvas: "#eff1f5" } },
    });

    const lightDefaults = getDefaultThemeColors("light");
    expect(theme.variants?.light?.text).toBe(lightDefaults.text);
    expect(theme.variants?.light?.canvas).not.toBe(theme.colors.canvas);
  });

  // A published `t3-iris.json` would show its palette on a card that applies
  // the built-in, and a published `dark.json` would capture everyone whose
  // stored preference is the stock "dark". Reserved ids never become cards.
  it("drops published themes with reserved ids", () => {
    const definitions = publishedThemeDefinitions([
      NIGHTFALL_THEME,
      { ...NIGHTFALL_THEME, id: "t3-iris", name: "Impostor Iris" },
      { ...NIGHTFALL_THEME, id: "ocean", name: "Impostor Ocean" },
      { ...NIGHTFALL_THEME, id: "dark", name: "Impostor Dark" },
    ]);

    expect(definitions.map((definition) => definition.id)).toEqual(["nightfall"]);
  });

  it("drops published palettes with no usable colors", () => {
    const theme = { id: "invalid", name: "Invalid", appearance: "dark" } as const;
    const definitions = publishedThemeDefinitions([
      { ...theme, colors: { canvas: "not-a-color" } },
      { ...theme, id: "unknown-roles", colors: { futureRole: "#ffffff" } },
      {
        ...theme,
        id: "ignored-variant",
        colors: { canvas: "not-a-color" },
        variants: { dark: { canvas: "#112233" } },
      },
    ]);

    expect(definitions).toEqual([]);
  });

  it("keeps seeds, partial palettes, and usable alternate appearances", () => {
    const theme = { name: "Shared", appearance: "dark" } as const;
    const definitions = publishedThemeDefinitions([
      NIGHTFALL_THEME,
      {
        ...theme,
        id: "partial",
        colors: { canvas: "not-a-color", text: "#ffffff", futureRole: "#ffffff" },
      },
      {
        ...theme,
        id: "light-variant",
        colors: { canvas: "not-a-color" },
        variants: { light: { canvas: "#eff1f5" } },
      },
    ]);

    expect(definitions.map((definition) => definition.id)).toEqual([
      "nightfall",
      "partial",
      "light-variant",
    ]);
  });

  // A machine may publish roles a newer client added; an older one has to
  // ignore them rather than render a broken palette.
  it("ignores published roles this build does not render", () => {
    const theme = environmentThemeDefinition({
      ...NIGHTFALL_THEME,
      colors: { notARole: "#ff0000", text: "#ffffff" },
    });

    expect(theme.colors).not.toHaveProperty("notARole");
    for (const role of THEME_COLOR_ROLES) {
      expect(theme.colors[role], `missing ${role}`).toBeTruthy();
    }
  });

  // ThemeEditorPanel opens Duplicate in the guided editor for managed themes,
  // and the guided editor regenerates from canvas and accent -- which would
  // discard any role the machine tuned by hand.
  it("marks only the pure seeded form as managed", () => {
    expect(environmentThemeDefinition(NIGHTFALL_THEME).managed).toBe(true);
    expect(
      environmentThemeDefinition({ ...NIGHTFALL_THEME, colors: { error: "#f7768e" } }).managed,
    ).toBeUndefined();
    expect(
      environmentThemeDefinition({
        id: "shared-light",
        version: 1,
        name: "Shared Light",
        appearance: "light",
        colors: { canvas: "#eff1f5", accent: "#1e66f5" },
      }).managed,
    ).toBeUndefined();
  });

  it("resolves published ids only while the machine publishes them", () => {
    expect(getThemeDefinition("nightfall")).toBe(null);

    setEnvironmentThemes([environmentThemeDefinition(NIGHTFALL_THEME)]);
    expect(getThemeDefinition("nightfall")?.label).toBe("Nightfall");

    // The palettes are never saved, so they have to disappear with the
    // machine that published them rather than linger as stale entries.
    setEnvironmentThemes([]);
    expect(getThemeDefinition("nightfall")).toBe(null);
  });

  // Published ids share one namespace with the user's saved themes, and the
  // user was here first: their theme keeps working even if the machine later
  // publishes under the same id.
  it("lets a theme the user saved win an id collision", () => {
    const store = new Map<string, string>();
    vi.stubGlobal("window", {
      addEventListener: vi.fn(),
      removeEventListener: vi.fn(),
      localStorage: {
        getItem: (key: string) => store.get(key) ?? null,
        setItem: (key: string, value: string) => store.set(key, value),
        removeItem: (key: string) => store.delete(key),
      },
    });
    invalidateCustomThemes();
    try {
      const environment = environmentThemeDefinition(NIGHTFALL_THEME);
      setEnvironmentThemes([environment]);
      installCustomTheme({ ...environment, label: "My Nightfall" });

      expect(getThemeDefinition("nightfall")?.label).toBe("My Nightfall");
    } finally {
      vi.unstubAllGlobals();
      invalidateCustomThemes();
    }
    expect(getThemeDefinition("nightfall")?.label).toBe("Nightfall");
  });
});