import { describe, it, expect } from "vitest";
import {
  composeSearchGroups,
  DEFAULT_GROUP_ORDER,
  groupsForScope,
  moveGroup,
  normalizeGroupOrder,
  reorderGroups,
  resolveSearchScope,
  scopeItemTypes,
  type SearchGroupId,
} from "./searchScope";

describe("resolveSearchScope", () => {
  it("scopes music routes to music", () => {
    expect(resolveSearchScope("/library/music")).toBe("music");
    expect(resolveSearchScope("/library/music/albums")).toBe("music");
    expect(resolveSearchScope("/library/music/artists")).toBe("music");
    expect(resolveSearchScope("/library/music/genres")).toBe("music");
    expect(resolveSearchScope("/library/music/playlists")).toBe("music");
    expect(resolveSearchScope("/library/music/tracks")).toBe("music");
  });

  it("scopes movie routes to movies", () => {
    expect(resolveSearchScope("/library/movies")).toBe("movies");
    expect(resolveSearchScope("/library/movies/all")).toBe("movies");
    expect(resolveSearchScope("/library/movies/genres")).toBe("movies");
  });

  it("scopes tv routes to tv", () => {
    expect(resolveSearchScope("/library/tv")).toBe("tv");
    expect(resolveSearchScope("/library/tv/shows")).toBe("tv");
  });

  it("treats /library/shows as tv", () => {
    // The TV genre page lives under `shows`, not `tv`.
    expect(resolveSearchScope("/library/shows/genres")).toBe("tv");
    expect(resolveSearchScope("/library/shows")).toBe("tv");
  });

  it("falls back to all for home, library root, search and unknown routes", () => {
    expect(resolveSearchScope("/")).toBe("all");
    expect(resolveSearchScope("/library")).toBe("all");
    expect(resolveSearchScope("/search")).toBe("all");
    expect(resolveSearchScope("/settings")).toBe("all");
    expect(resolveSearchScope("/downloads")).toBe("all");
    expect(resolveSearchScope("/library/abc123")).toBe("all");
    expect(resolveSearchScope("/nonsense/route")).toBe("all");
  });

  it("tolerates trailing slashes, query strings and hashes", () => {
    expect(resolveSearchScope("/library/music/")).toBe("music");
    expect(resolveSearchScope("/library/tv?foo=1")).toBe("tv");
    expect(resolveSearchScope("/library/movies#top")).toBe("movies");
    expect(resolveSearchScope("")).toBe("all");
  });

  it("does not match a prefix that is only a partial segment", () => {
    expect(resolveSearchScope("/library/musicvideos")).toBe("all");
  });
});

describe("scopeItemTypes", () => {
  it("omits the key entirely for the all scope", () => {
    // `all` must send no includeItemTypes — an explicit union would silently
    // drop types nobody enumerated (Person, folders).
    expect(scopeItemTypes("all")).toBeUndefined();
  });

  it("maps each narrow scope to its item types", () => {
    expect(scopeItemTypes("music")).toEqual(["MusicAlbum", "MusicArtist", "Audio", "Playlist"]);
    expect(scopeItemTypes("movies")).toEqual(["Movie"]);
    expect(scopeItemTypes("tv")).toEqual(["Series", "Episode"]);
  });

  it("returns a fresh array callers cannot mutate into the table", () => {
    const first = scopeItemTypes("movies")!;
    first.push("Series");
    expect(scopeItemTypes("movies")).toEqual(["Movie"]);
  });
});

describe("normalizeGroupOrder", () => {
  it("returns the default for missing or non-array input", () => {
    expect(normalizeGroupOrder(null)).toEqual([...DEFAULT_GROUP_ORDER]);
    expect(normalizeGroupOrder(undefined)).toEqual([...DEFAULT_GROUP_ORDER]);
    expect(normalizeGroupOrder("nonsense")).toEqual([...DEFAULT_GROUP_ORDER]);
    expect(normalizeGroupOrder({})).toEqual([...DEFAULT_GROUP_ORDER]);
  });

  it("drops ids that no longer exist", () => {
    expect(normalizeGroupOrder(["movies", "podcasts", "songs"])).toEqual([
      "movies",
      "songs",
      "albums",
      "artists",
      "tvShows",
    ]);
  });

  it("appends groups a stored order does not mention", () => {
    // A user upgrading from a build with fewer groups must not lose the new ones.
    expect(normalizeGroupOrder(["movies", "songs"])).toEqual([
      "movies",
      "songs",
      "albums",
      "artists",
      "tvShows",
    ]);
  });

  it("de-duplicates repeated ids", () => {
    expect(normalizeGroupOrder(["songs", "songs", "movies"])).toEqual([
      "songs",
      "movies",
      "albums",
      "artists",
      "tvShows",
    ]);
  });

  it("preserves a complete valid order unchanged", () => {
    const order: SearchGroupId[] = ["tvShows", "movies", "artists", "albums", "songs"];
    expect(normalizeGroupOrder(order)).toEqual(order);
  });
});

describe("groupsForScope", () => {
  it("returns every group in saved order for the all scope", () => {
    expect(groupsForScope("all", ["movies", "songs", "tvShows", "albums", "artists"])).toEqual([
      "movies",
      "songs",
      "tvShows",
      "albums",
      "artists",
    ]);
  });

  it("keeps only in-scope groups, in saved order", () => {
    const order: SearchGroupId[] = ["artists", "movies", "albums", "tvShows", "songs"];
    expect(groupsForScope("music", order)).toEqual(["artists", "albums", "songs"]);
    expect(groupsForScope("movies", order)).toEqual(["movies"]);
    expect(groupsForScope("tv", order)).toEqual(["tvShows"]);
  });
});

describe("composeSearchGroups", () => {
  const results = [
    { id: "1", type: "Audio" },
    { id: "2", type: "MusicAlbum" },
    { id: "3", type: "Movie" },
    { id: "4", type: "Series" },
    { id: "5", type: "Episode" },
    { id: "6", type: "Person" },
  ];

  it("renders groups in the configured order", () => {
    const groups = composeSearchGroups(results, "all", [
      "tvShows",
      "movies",
      "songs",
      "albums",
      "artists",
    ]);
    expect(groups.map((g) => g.id)).toEqual(["tvShows", "movies", "songs", "albums"]);
  });

  it("omits empty groups", () => {
    // No artists in the fixture, so the artists group never renders.
    const groups = composeSearchGroups(results, "all", DEFAULT_GROUP_ORDER);
    expect(groups.map((g) => g.id)).not.toContain("artists");
  });

  it("drops out-of-scope groups", () => {
    expect(composeSearchGroups(results, "music", DEFAULT_GROUP_ORDER).map((g) => g.id)).toEqual([
      "songs",
      "albums",
    ]);
    expect(composeSearchGroups(results, "tv", DEFAULT_GROUP_ORDER).map((g) => g.id)).toEqual([
      "tvShows",
    ]);
  });

  it("groups series and episodes together under tvShows", () => {
    const groups = composeSearchGroups(results, "tv", DEFAULT_GROUP_ORDER);
    expect(groups[0].items.map((i) => i.id)).toEqual(["4", "5"]);
  });

  it("ignores item types that belong to no group", () => {
    const all = composeSearchGroups(results, "all", DEFAULT_GROUP_ORDER);
    expect(all.flatMap((g) => g.items).map((i) => i.id)).not.toContain("6");
  });

  it("narrowing then widening restores the full arrangement", () => {
    // Scope is a filter over the saved order, never a rewrite of it.
    const order: SearchGroupId[] = ["tvShows", "songs", "movies", "albums", "artists"];
    const wide = composeSearchGroups(results, "all", order).map((g) => g.id);
    composeSearchGroups(results, "music", order);
    expect(composeSearchGroups(results, "all", order).map((g) => g.id)).toEqual(wide);
    expect(wide).toEqual(["tvShows", "songs", "movies", "albums"]);
  });

  it("survives a stored order containing an unknown id", () => {
    const groups = composeSearchGroups(results, "all", [
      "podcasts",
      "movies",
    ] as unknown as SearchGroupId[]);
    expect(groups.map((g) => g.id)).toEqual(["movies", "songs", "albums", "tvShows"]);
  });

  it("handles items with a missing type", () => {
    const groups = composeSearchGroups(
      [{ id: "x", type: null }, { id: "y" }] as { id: string; type?: string | null }[],
      "all",
      DEFAULT_GROUP_ORDER
    );
    expect(groups).toEqual([]);
  });
});

describe("moveGroup", () => {
  const order: SearchGroupId[] = ["songs", "albums", "artists", "movies", "tvShows"];

  it("moves a group up", () => {
    expect(moveGroup(order, "artists", -1)).toEqual([
      "songs",
      "artists",
      "albums",
      "movies",
      "tvShows",
    ]);
  });

  it("moves a group down", () => {
    expect(moveGroup(order, "songs", 1)).toEqual([
      "albums",
      "songs",
      "artists",
      "movies",
      "tvShows",
    ]);
  });

  it("is a no-op at the boundaries", () => {
    expect(moveGroup(order, "songs", -1)).toEqual(order);
    expect(moveGroup(order, "tvShows", 1)).toEqual(order);
  });

  it("is a no-op for an unknown id", () => {
    expect(moveGroup(order, "podcasts" as SearchGroupId, 1)).toEqual(order);
  });

  it("does not mutate the input", () => {
    const input = [...order];
    moveGroup(input, "songs", 1);
    expect(input).toEqual(order);
  });
});

describe("reorderGroups", () => {
  const order: SearchGroupId[] = ["songs", "albums", "artists", "movies", "tvShows"];

  it("moves an item from one index to another", () => {
    expect(reorderGroups(order, 0, 4)).toEqual([
      "albums",
      "artists",
      "movies",
      "tvShows",
      "songs",
    ]);
    expect(reorderGroups(order, 4, 0)).toEqual([
      "tvShows",
      "songs",
      "albums",
      "artists",
      "movies",
    ]);
  });

  it("is a no-op for equal or out-of-range indices", () => {
    expect(reorderGroups(order, 2, 2)).toEqual(order);
    expect(reorderGroups(order, -1, 2)).toEqual(order);
    expect(reorderGroups(order, 0, 9)).toEqual(order);
  });
});
