import { describe, expect, it } from "vitest";

import { matchesTeamSearch, searchTeams, sortTeamsByDps } from "./team-search";

const team = {
  team: ["Vaporize Team"],
  character: ["Mualani"],
  weapon: ["Surf's Up"],
  artifact: ["Obsidian Codex", "Scroll of the Hero"],
};

describe("team search", () => {
  it("searches every category when the target is all", () => {
    expect(matchesTeamSearch(team, "surf", "all")).toBe(true);
    expect(matchesTeamSearch(team, "mualani", "all")).toBe(true);
  });

  it("only searches the selected target", () => {
    expect(matchesTeamSearch(team, "vaporize", "team")).toBe(true);
    expect(matchesTeamSearch(team, "obsidian", "team")).toBe(false);
    expect(matchesTeamSearch(team, "obsidian", "artifact")).toBe(true);
  });

  it("ignores case and surrounding whitespace", () => {
    expect(matchesTeamSearch(team, "  HERO  ", "artifact")).toBe(true);
  });

  it("matches every team when the query is empty", () => {
    expect(matchesTeamSearch(team, "  ", "weapon")).toBe(true);
  });

  it("sorts every team by DPS and preserves order for ties", () => {
    const teams = [
      { name: "middle", rotationSeconds: 10, members: [{ damage: 100 }] },
      { name: "best", rotationSeconds: 5, members: [{ damage: 100 }] },
      { name: "tie", rotationSeconds: 20, members: [{ damage: 200 }] },
    ];
    expect(sortTeamsByDps(teams, "best").map((item) => item.name)).toEqual(["best", "middle", "tie"]);
    expect(sortTeamsByDps(teams, "worst").map((item) => item.name)).toEqual(["middle", "tie", "best"]);
    expect(sortTeamsByDps(teams, null).map((item) => item.name)).toEqual(["middle", "best", "tie"]);
  });
});

describe("team fuzzy fallback", () => {
  it("matches typos only in the selected category", () => {
    expect(searchTeams([team], (item) => item, "mulani", "character")).toEqual({ items: [team], fuzzy: true });
    expect(searchTeams([team], (item) => item, "mulani", "artifact").items).toEqual([]);
    expect(searchTeams([team], (item) => item, "mulani", "all").items).toEqual([team]);
  });

  it("decides fallback across all eligible teams", () => {
    const direct = { ...team, character: ["Mulani"] };
    expect(searchTeams([team, direct], (item) => item, "mulani", "all")).toEqual({ items: [direct], fuzzy: false });
    expect(searchTeams([team], (item) => item, "", "all")).toEqual({ items: [team], fuzzy: false });
    expect(searchTeams([], (item) => item, "mulani", "all")).toEqual({ items: [], fuzzy: false });
  });

  it("does not allow direct queries to span separate names", () => {
    const values = { ...team, character: ["Jean", "Mualani"] };
    expect(searchTeams([values], (item) => item, "Jean Mualani", "character").items).toEqual([]);
  });

  it("applies DPS ordering after fuzzy matching and preserves fuzzy ranking without sorting", () => {
    const teams = [
      { ...team, character: ["Mualani"], rotationSeconds: 10, members: [{ damage: 100 }] },
      { ...team, character: ["Muloni"], rotationSeconds: 5, members: [{ damage: 100 }] },
    ];
    const matches = searchTeams(teams, (item) => item, "mulani", "character").items;
    expect(sortTeamsByDps(matches, "best")).toEqual([teams[1], teams[0]]);
    expect(sortTeamsByDps(matches, null)).toEqual(teams);
  });
});