// UNIT test for the server-side tab-order normalizer. Not part of the nix-gated client suite
// (that derivation builds ./client only); run locally with `bun test server/services`.
import { describe, test, expect } from "bun:test";
import { reconcileTabOrder, sameIds, type OrderedSession } from "./tabOrder";

const s = (sessionId: string, createdAt: string): OrderedSession => ({ sessionId, createdAt });

describe("reconcileTabOrder", () => {
  test("unset order → seeds by creation order (oldest first)", () => {
    const sessions = [
      s("new", "2026-01-03T00:00:00Z"),
      s("old", "2026-01-01T00:00:00Z"),
      s("mid", "2026-01-02T00:00:00Z"),
    ];
    expect(reconcileTabOrder(undefined, sessions)).toEqual(["old", "mid", "new"]);
    expect(reconcileTabOrder([], sessions)).toEqual(["old", "mid", "new"]);
  });

  test("keeps the stored arrangement and appends a new session at the end", () => {
    // User dragged to [c, a, b]; then created "new" (latest createdAt) → appends.
    const stored = ["c", "a", "b"];
    const sessions = [
      s("a", "2026-01-01T00:00:00Z"),
      s("b", "2026-01-02T00:00:00Z"),
      s("c", "2026-01-03T00:00:00Z"),
      s("new", "2026-01-04T00:00:00Z"),
    ];
    expect(reconcileTabOrder(stored, sessions)).toEqual(["c", "a", "b", "new"]);
  });

  test("appends multiple missing sessions in creation order, after the kept ones", () => {
    const stored = ["b"];
    const sessions = [
      s("a", "2026-01-01T00:00:00Z"),
      s("b", "2026-01-02T00:00:00Z"),
      s("c", "2026-01-03T00:00:00Z"),
    ];
    // "b" kept in place; unknown "a","c" appended oldest-first.
    expect(reconcileTabOrder(stored, sessions)).toEqual(["b", "a", "c"]);
  });

  test("prunes ids of sessions that no longer exist", () => {
    const stored = ["gone", "b", "a"];
    const sessions = [s("a", "2026-01-01T00:00:00Z"), s("b", "2026-01-02T00:00:00Z")];
    expect(reconcileTabOrder(stored, sessions)).toEqual(["b", "a"]);
  });

  test("equal createdAt falls back to a stable id tiebreak (never arbitrary)", () => {
    const sessions = [s("b", "2026-01-01T00:00:00Z"), s("a", "2026-01-01T00:00:00Z")];
    expect(reconcileTabOrder(undefined, sessions)).toEqual(["a", "b"]);
  });

  test("no sessions → empty order", () => {
    expect(reconcileTabOrder(["a", "b"], [])).toEqual([]);
    expect(reconcileTabOrder(undefined, [])).toEqual([]);
  });

  test("already canonical → returned unchanged (drives the skip-write check)", () => {
    const stored = ["a", "b"];
    const sessions = [s("a", "2026-01-01T00:00:00Z"), s("b", "2026-01-02T00:00:00Z")];
    const out = reconcileTabOrder(stored, sessions);
    expect(out).toEqual(["a", "b"]);
    expect(sameIds(stored, out)).toBe(true);
  });
});

describe("sameIds", () => {
  test("positional equality", () => {
    expect(sameIds(["a", "b"], ["a", "b"])).toBe(true);
    expect(sameIds(["a", "b"], ["b", "a"])).toBe(false);
    expect(sameIds(["a"], ["a", "b"])).toBe(false);
  });
  test("undefined stored is never equal (an unset workstream must be initialized)", () => {
    expect(sameIds(undefined, [])).toBe(false);
    expect(sameIds(undefined, ["a"])).toBe(false);
  });
});