import { describe, expect, it } from "vitest";
import { applyDerivedStatusFilter } from "@/lib/employee-status-filter";
import { todayIso } from "@/lib/format";
import { deriveStatusAsOf } from "@/lib/reports";
import type { EmploymentStatus } from "@/lib/supabase/types";
import { adminClient } from "./helpers";

// lib/employee-status-filter.ts is a SQL restatement of deriveStatusAsOf():
// the employee list pages in the database and cannot derive status in JS, so
// the same rule exists twice. Two copies of a rule drift, and the drift is
// invisible — a dashboard tile and the list it links to just quietly show
// different numbers.
//
// Only a real database can settle it, so this runs both over the whole
// seeded roster and demands the same set of ids.
describe("derived status filter matches deriveStatusAsOf", () => {
  const asOf = todayIso();

  async function idsFromDatabase(statuses: EmploymentStatus[]): Promise<Set<string>> {
    const query = adminClient.from("employees").select("id");
    const { data, error } = await applyDerivedStatusFilter(query, statuses, asOf);
    if (error) throw new Error(error.message);
    return new Set((data ?? []).map((r) => r.id));
  }

  async function idsFromDerivation(statuses: EmploymentStatus[]): Promise<Set<string>> {
    const { data, error } = await adminClient
      .from("employees")
      .select("id, entry_date, exit_date, karenz_start_date, karenz_return_date");
    if (error) throw new Error(error.message);
    return new Set((data ?? []).filter((e) => statuses.includes(deriveStatusAsOf(e, asOf))).map((e) => e.id));
  }

  async function expectSameSet(statuses: EmploymentStatus[]) {
    const [fromDb, fromJs] = await Promise.all([idsFromDatabase(statuses), idsFromDerivation(statuses)]);

    const onlyInDb = [...fromDb].filter((id) => !fromJs.has(id));
    const onlyInJs = [...fromJs].filter((id) => !fromDb.has(id));

    expect({ statuses, onlyInDb: onlyInDb.slice(0, 5), onlyInJs: onlyInJs.slice(0, 5) }).toEqual({
      statuses,
      onlyInDb: [],
      onlyInJs: [],
    });
    // Guards against a filter so narrow it matches nothing and passes
    // trivially.
    expect(fromJs.size).toBeGreaterThan(0);
  }

  it("agrees for Aktiv + Karenz — the definition the dashboard headcount uses", async () => {
    await expectSameSet(["Aktiv", "Karenz"]);
  });

  it("agrees for Aktiv alone", async () => {
    await expectSameSet(["Aktiv"]);
  });

  it("agrees for Karenz alone", async () => {
    await expectSameSet(["Karenz"]);
  });

  it("agrees for Geplant", async () => {
    await expectSameSet(["Geplant"]);
  });

  it("agrees for Ausgetreten", async () => {
    await expectSameSet(["Ausgetreten"]);
  });

  it("returns everyone when no status is selected", async () => {
    const { count: total } = await adminClient.from("employees").select("id", { count: "exact", head: true });
    const { count: filtered } = await applyDerivedStatusFilter(
      adminClient.from("employees").select("id", { count: "exact", head: true }),
      [],
      asOf
    );
    expect(filtered).toBe(total);
  });
});