import type { PullRequestListEntry } from "@t3tools/contracts";
import { describe, expect, it } from "vite-plus/test";

import {
  filterPullRequestsByInvolvement,
  groupPullRequestsByInvolvement,
  matchesPullRequestQuery,
  mergePullRequestDiffStats,
  narrowPullRequestsToFilters,
  partitionPullRequestsWithPriority,
  readPullRequestListSnapshot,
  writePullRequestListSnapshot,
  rankPullRequestMatches,
  scorePullRequestMatch,
  withDiffStat,
  resolveProjectScope,
} from "./pullRequestList.logic";

const VIEWERS = { "github.com": "Bilal" } as const;
const NO_VIEWERS = {} as const;

function entry(overrides: Partial<PullRequestListEntry> & Pick<PullRequestListEntry, "number">) {
  return {
    provider: "github",
    host: "github.com",
    projectId: "project-1",
    projectTitle: "t3code",
    repository: "pingdotgg/t3code",
    title: "Add the pull requests page",
    url: `https://github.com/pingdotgg/t3code/pull/${overrides.number}`,
    author: { login: "octocat", name: null, avatarUrl: null },
    headBranch: `feat/branch-${overrides.number}`,
    baseBranch: "main",
    state: "open",
    isDraft: false,
    mergeability: "mergeable",
    additions: 1,
    deletions: 0,
    createdAt: "2026-07-01T00:00:00Z",
    updatedAt: "2026-07-02T00:00:00Z",
    viewerReviewRequested: false,
    labels: [],
    ...overrides,
  } as PullRequestListEntry;
}

describe("pull request involvement filtering", () => {
  const entries = [
    entry({ number: 1, author: { login: "Bilal", name: null, avatarUrl: null } }),
    entry({ number: 2, viewerReviewRequested: true }),
    entry({ number: 3 }),
  ];

  it("matches the viewer's own pull requests case-insensitively", () => {
    expect(
      filterPullRequestsByInvolvement(entries, VIEWERS, "authored").map((item) => item.number),
    ).toEqual([1]);
  });

  it("returns nothing for Authored when the viewer is unknown", () => {
    expect(filterPullRequestsByInvolvement(entries, NO_VIEWERS, "authored")).toEqual([]);
  });

  it("uses the server-computed review-request flag for Reviewing", () => {
    expect(
      filterPullRequestsByInvolvement(entries, VIEWERS, "reviewing").map((item) => item.number),
    ).toEqual([2]);
  });

  it("does not treat a matching login on another host as the viewer", () => {
    // The same name on GitLab is a different account, and its viewer is unknown here.
    const mixed = [
      entry({ number: 1, author: { login: "Bilal", name: null, avatarUrl: null } }),
      entry({
        number: 2,
        provider: "gitlab",
        host: "gitlab.com",
        author: { login: "Bilal", name: null, avatarUrl: null },
      }),
    ];
    expect(
      filterPullRequestsByInvolvement(mixed, VIEWERS, "authored").map((item) => item.number),
    ).toEqual([1]);
  });

  it("leaves the superset untouched for All", () => {
    expect(filterPullRequestsByInvolvement(entries, VIEWERS, "all")).toHaveLength(3);
  });

  it("keeps two hosts of one provider kind as two accounts", () => {
    // A GitHub Enterprise install is a different account from github.com, so the viewer for
    // one must not claim authorship of the other's change requests.
    const mixed = [
      entry({ number: 1, author: { login: "Bilal", name: null, avatarUrl: null } }),
      entry({
        number: 2,
        host: "github.acme.dev",
        author: { login: "Bilal", name: null, avatarUrl: null },
      }),
    ];
    expect(
      filterPullRequestsByInvolvement(mixed, VIEWERS, "authored").map((item) => item.number),
    ).toEqual([1]);
  });
});

describe("pull request grouping", () => {
  it("buckets authored above review-requested and drops empty groups", () => {
    const groups = groupPullRequestsByInvolvement(
      [
        entry({ number: 1, author: { login: "bilal", name: null, avatarUrl: null } }),
        entry({ number: 2, viewerReviewRequested: true }),
      ],
      VIEWERS,
    );
    expect(groups.map((group) => [group.key, group.entries.length])).toEqual([
      ["reviewRequested", 1],
      ["authored", 1],
    ]);
  });

  it("puts everything in Others when the viewer is unknown", () => {
    const groups = groupPullRequestsByInvolvement([entry({ number: 1 })], NO_VIEWERS);
    expect(groups.map((group) => group.key)).toEqual(["others"]);
  });

  it("counts an authored pull request once, even with a review request on it", () => {
    const groups = groupPullRequestsByInvolvement(
      [
        entry({
          number: 1,
          author: { login: "bilal", name: null, avatarUrl: null },
          viewerReviewRequested: true,
        }),
      ],
      VIEWERS,
    );
    expect(groups.map((group) => group.key)).toEqual(["authored"]);
  });
});

describe("pull request search", () => {
  const target = entry({
    number: 4711,
    title: "Restore sidebar actions",
    headBranch: "fix/sidebar",
  });

  it("matches the number with or without the leading hash", () => {
    expect(matchesPullRequestQuery(target, "#4711")).toBe(true);
    expect(matchesPullRequestQuery(target, "4711")).toBe(true);
  });

  it("matches title, branch and author case-insensitively", () => {
    expect(matchesPullRequestQuery(target, "SIDEBAR")).toBe(true);
    expect(matchesPullRequestQuery(target, "fix/side")).toBe(true);
    expect(matchesPullRequestQuery(target, "octocat")).toBe(true);
  });

  it("ignores surrounding whitespace and rejects non-matches", () => {
    expect(matchesPullRequestQuery(target, "   ")).toBe(true);
    expect(matchesPullRequestQuery(target, "kanban")).toBe(false);
  });
});

describe("carrying rows already read into filters nothing has answered yet", () => {
  const rows = [
    entry({ number: 1 }),
    entry({ number: 2, state: "merged" }),
    entry({ number: 3, state: "closed" }),
    entry({ number: 4, host: "github.acme.dev" }),
    entry({ number: 5, projectId: "project-2" as PullRequestListEntry["projectId"] }),
  ];
  const everything = { state: "all", projectId: undefined, host: undefined } as const;

  it("never lets a merged pull request sit under Open", () => {
    expect(
      narrowPullRequestsToFilters(rows, { ...everything, state: "open" }).map((row) => row.number),
    ).toEqual([1, 4, 5]);
  });

  it("keeps only the state that was asked for", () => {
    expect(
      narrowPullRequestsToFilters(rows, { ...everything, state: "merged" }).map(
        (row) => row.number,
      ),
    ).toEqual([2]);
  });

  it("narrows to one host, which two installs of one kind cannot share", () => {
    expect(
      narrowPullRequestsToFilters(rows, { ...everything, host: "github.acme.dev" }).map(
        (row) => row.number,
      ),
    ).toEqual([4]);
  });

  it("narrows to one project", () => {
    expect(
      narrowPullRequestsToFilters(rows, { ...everything, projectId: "project-2" }).map(
        (row) => row.number,
      ),
    ).toEqual([5]);
  });

  it("holds on to everything when nothing narrows it", () => {
    expect(narrowPullRequestsToFilters(rows, everything)).toEqual(rows);
  });
});

describe("resolveProjectScope", () => {
  const projects = [{ id: "p1" }, { id: "p2" }];

  it("keeps an id the environment has", () => {
    expect(resolveProjectScope("p2", projects, true)).toBe("p2");
  });

  it("drops an id from another environment", () => {
    expect(resolveProjectScope("p9", projects, false)).toBe("p9");
    expect(resolveProjectScope("p9", projects, true)).toBeUndefined();
  });

  it("drops an id once the environment is known to have no projects", () => {
    expect(resolveProjectScope("p9", [], true)).toBeUndefined();
  });

  it("keeps an id while the projects are still unknown", () => {
    // Dropping here would list every project for a moment before narrowing back down.
    expect(resolveProjectScope("p9", [], false)).toBe("p9");
  });
});

describe("ranking what a search found", () => {
  const row = (overrides: Partial<PullRequestListEntry> & { number?: number }) =>
    entry({ number: 1, ...overrides });

  it("puts the pull request whose title says it above one that merely mentions it", () => {
    const titled = row({
      number: 1,
      title: "Add the welcome wizard",
      updatedAt: "2026-07-01T00:00:00Z",
    });
    const mentioned = row({
      number: 2,
      title: "Unrelated work",
      updatedAt: "2026-08-01T00:00:00Z",
    });
    expect(
      rankPullRequestMatches([mentioned, titled], "welcome wizard").map((entry) => entry.number),
    ).toEqual([1, 2]);
  });

  it("finds the words in any order, which is how people type them", () => {
    // Substrings count, so "welcomes" answers "welcome" — a search is not a spelling test.
    expect(
      scorePullRequestMatch(row({ title: "The wizard that welcomes" }), "welcome wizard"),
    ).toBe(70);
    expect(
      scorePullRequestMatch(row({ title: "Wizard for the welcome flow" }), "welcome wizard"),
    ).toBe(70);
    // One of the two words is a mention, not an answer, and ranks under both.
    expect(scorePullRequestMatch(row({ title: "A wizard, of sorts" }), "welcome wizard")).toBe(30);
  });

  it("answers a number with the pull request that has it, and nothing else", () => {
    expect(scorePullRequestMatch(row({ number: 42 }), "#42")).toBe(100);
    expect(scorePullRequestMatch(row({ number: 42 }), "43")).toBe(0);
  });

  it("keeps recency where nothing tells two results apart", () => {
    const older = row({ number: 1, title: "no match here", updatedAt: "2026-07-01T00:00:00Z" });
    const newer = row({ number: 2, title: "none here either", updatedAt: "2026-08-01T00:00:00Z" });
    expect(rankPullRequestMatches([older, newer], "wizard").map((entry) => entry.number)).toEqual([
      2, 1,
    ]);
  });

  it("leaves a listing with no search in the order it arrived", () => {
    const first = row({ number: 1, updatedAt: "2026-07-01T00:00:00Z" });
    const second = row({ number: 2, updatedAt: "2026-08-01T00:00:00Z" });
    expect(rankPullRequestMatches([first, second], "  ")).toEqual([first, second]);
  });
});

describe("line counts that arrive after the rows", () => {
  const stats = new Map([["project-1 7", { additions: 42, deletions: 3 }]]);

  it("fills in a row whose host left the counts for later", () => {
    const row = entry({ number: 7, additions: 0, deletions: 0 });
    expect(withDiffStat(row, stats)).toEqual({ ...row, additions: 42, deletions: 3 });
  });

  it("leaves a row the host already counted alone", () => {
    const row = entry({ number: 7, additions: 1, deletions: 1 });
    expect(withDiffStat(row, stats)).toBe(row);
  });

  it("leaves a row whose counts have not arrived as it is", () => {
    const row = entry({ number: 9, additions: 0, deletions: 0 });
    expect(withDiffStat(row, stats)).toBe(row);
  });
});

describe("merging line counts across keyed stats queries", () => {
  it("keeps counts already held while a fresh batch says nothing about them", () => {
    const held = mergePullRequestDiffStats(new Map(), [
      { projectId: "project-1", number: 1, additions: 10, deletions: 2 },
      { projectId: "project-1", number: 2, additions: 5, deletions: 1 },
    ]);
    // A third row appeared; its batch is still pending and contributes nothing yet.
    const merged = mergePullRequestDiffStats(held, []);
    expect(merged.get("project-1 1")).toEqual({ additions: 10, deletions: 2 });
    expect(merged.get("project-1 2")).toEqual({ additions: 5, deletions: 1 });
  });

  it("replaces a count once its replacement arrives, keeping its neighbours", () => {
    const held = mergePullRequestDiffStats(new Map(), [
      { projectId: "project-1", number: 1, additions: 10, deletions: 2 },
    ]);
    const merged = mergePullRequestDiffStats(held, [
      { projectId: "project-1", number: 1, additions: 11, deletions: 2 },
      { projectId: "project-1", number: 3, additions: 7, deletions: 0 },
    ]);
    expect(merged.get("project-1 1")).toEqual({ additions: 11, deletions: 2 });
    expect(merged.get("project-1 3")).toEqual({ additions: 7, deletions: 0 });
  });

  it("does not mutate the map it was handed", () => {
    const held = new Map([["project-1 1", { additions: 1, deletions: 1 }]]);
    mergePullRequestDiffStats(held, [
      { projectId: "project-1", number: 1, additions: 2, deletions: 2 },
    ]);
    expect(held.get("project-1 1")).toEqual({ additions: 1, deletions: 1 });
  });
});

describe("partitioning with the hosts' own priority reads", () => {
  const authoredRow = (number: number, updatedAt: string) =>
    entry({ number, updatedAt, author: { login: "Bilal", name: null, avatarUrl: null } });

  it("keeps Others in feed order when a continuation lands an authored row already partitioned", () => {
    const older = entry({ number: 1, updatedAt: "2026-07-05T00:00:00Z" });
    const newer = entry({ number: 2, updatedAt: "2026-07-06T00:00:00Z" });
    const mine = authoredRow(3, "2026-07-04T00:00:00Z");
    // The authored partition already holds the row the continuation carries.
    const groups = partitionPullRequestsWithPriority([newer, older, mine], [mine], []);
    expect(groups.map((group) => group.key)).toEqual(["authored", "others"]);
    expect(groups[1]!.entries.map((item) => item.number)).toEqual([2, 1]);
    expect(groups[0]!.entries.map((item) => item.number)).toEqual([3]);
  });

  it("appends an authored row the partition page missed to Others rather than moving it up", () => {
    const shown = entry({ number: 1, updatedAt: "2026-07-06T00:00:00Z" });
    const olderMine = authoredRow(9, "2026-01-01T00:00:00Z");
    const groups = partitionPullRequestsWithPriority([shown, olderMine], [], []);
    expect(groups).toHaveLength(1);
    expect(groups[0]!.entries.map((item) => item.number)).toEqual([1, 9]);
  });

  it("gives authored precedence over review-requested and orders partitions by recency", () => {
    const both = authoredRow(1, "2026-07-01T00:00:00Z");
    const requested = entry({
      number: 2,
      viewerReviewRequested: true,
      updatedAt: "2026-07-02T00:00:00Z",
    });
    const requestedOlder = entry({
      number: 3,
      viewerReviewRequested: true,
      updatedAt: "2026-06-02T00:00:00Z",
    });
    const groups = partitionPullRequestsWithPriority([], [both], [both, requestedOlder, requested]);
    expect(groups.map((group) => group.key)).toEqual(["reviewRequested", "authored"]);
    expect(groups[0]!.entries.map((item) => item.number)).toEqual([2, 3]);
    expect(groups[1]!.entries.map((item) => item.number)).toEqual([1]);
  });

  it("lets the feed's copy of a partitioned row replace the partition's", () => {
    const stale = authoredRow(1, "2026-07-01T00:00:00Z");
    const fresh = { ...stale, title: "Retitled" };
    const groups = partitionPullRequestsWithPriority([fresh], [stale], []);
    expect(groups[0]!.entries[0]!.title).toBe("Retitled");
  });
});

describe("the list snapshot across a reload", () => {
  const makeStorage = () => {
    const held = new Map<string, string>();
    return {
      getItem: (key: string) => held.get(key) ?? null,
      setItem: (key: string, value: string) => void held.set(key, value),
    };
  };
  const data = {
    entries: [entry({ number: 1 })],
    viewers: { "github.com": "Bilal" },
    providers: [],
    errors: [{ projectId: "project-1", message: "boom" }],
    truncated: true,
    nextCursors: { "pingdotgg/t3code": "cursor-1" },
  } as never;

  it("hydrates the retained rows so ghosts never replace them", () => {
    const storage = makeStorage();
    writePullRequestListSnapshot(storage, "env-1", { scope: "env-1:open:all::", data });
    const snapshot = readPullRequestListSnapshot(storage, "env-1");
    expect(snapshot?.scope).toBe("env-1:open:all::");
    expect(snapshot?.data.entries.map((item) => item.number)).toEqual([1]);
  });

  it("carries neither stale failures nor stale cursors", () => {
    const storage = makeStorage();
    writePullRequestListSnapshot(storage, "env-1", { scope: "s", data });
    const snapshot = readPullRequestListSnapshot(storage, "env-1");
    expect(snapshot?.data.errors).toEqual([]);
    expect(snapshot?.data.nextCursors).toEqual({});
  });

  it("answers nothing for another environment", () => {
    const storage = makeStorage();
    writePullRequestListSnapshot(storage, "env-1", { scope: "s", data });
    expect(readPullRequestListSnapshot(storage, "env-2")).toBeNull();
  });

  it("rejects a snapshot whose rows do not decode as entries", () => {
    const storage = makeStorage();
    storage.setItem(
      "t3.pullRequests.list:env-1",
      JSON.stringify({ scope: "s", data: { entries: [null] } }),
    );
    expect(readPullRequestListSnapshot(storage, "env-1")).toBeNull();
    storage.setItem(
      "t3.pullRequests.list:env-1",
      JSON.stringify({ scope: "s", data: { entries: [{ host: "github.com" }] } }),
    );
    expect(readPullRequestListSnapshot(storage, "env-1")).toBeNull();
  });

  it("shrugs off corrupt storage and no storage at all", () => {
    const storage = makeStorage();
    storage.setItem("t3.pullRequests.list:env-1", "{not json");
    expect(readPullRequestListSnapshot(storage, "env-1")).toBeNull();
    expect(readPullRequestListSnapshot(undefined, "env-1")).toBeNull();
  });
});