import { describe, expect, it } from "vitest";
import { formatSvnr, isValidSvnr, normalizeSvnr, requiresAustrianSvnr, svnrCheckDigit, validateSvnr } from "@/lib/svnr";

// Weights 3,7,9 on the serial and 5,8,4,2,1,6 on TTMMJJ; sum mod 11 is the
// check digit. Worked through by hand for "123? 010180":
//   3·1 + 7·2 + 9·3  = 44   (serial)
//   5·0 + 8·1 + 4·0 + 2·1 + 1·8 + 6·0 = 18   (010180)
//   62 mod 11 = 7        → 1237 010180
const VALID = "1237 010180";

describe("svnrCheckDigit", () => {
  it("computes the documented check digit", () => {
    expect(svnrCheckDigit("1230010180")).toBe(7);
  });

  it("computes it independently of the digit already in that slot", () => {
    // The check position is skipped, so a wrong digit there cannot influence
    // the result — otherwise the check would validate itself.
    expect(svnrCheckDigit("1234010180")).toBe(7);
    expect(svnrCheckDigit("1239010180")).toBe(7);
  });

  it("computes 3 for serial 432 on the same date", () => {
    // 3·4 + 7·3 + 9·2 = 51; 51 + 18 = 69; 69 mod 11 = 3
    expect(svnrCheckDigit("4320010180")).toBe(3);
  });

  it("returns null for a serial that would need a check digit of 10", () => {
    // 9·4 = 36; 36 + 18 = 54; 54 mod 11 = 10 — never issued, since there is
    // no single digit for it.
    expect(svnrCheckDigit("0040010180")).toBeNull();
  });
});

describe("validateSvnr", () => {
  it("accepts a well-formed number", () => {
    expect(validateSvnr(VALID)).toBeNull();
    expect(isValidSvnr(VALID)).toBe(true);
  });

  it("accepts it regardless of spacing or separators", () => {
    for (const variant of ["1237010180", "1237 010180", "1237-010180", "1237.010180", " 1237  010180 "]) {
      expect(validateSvnr(variant), variant).toBeNull();
    }
  });

  it("rejects a wrong check digit", () => {
    expect(validateSvnr("1234 010180")).toBe("checksum");
  });

  it("rejects a serial whose check digit would be 10", () => {
    expect(validateSvnr("0040 010180")).toBe("checksum");
  });

  it("rejects anything that is not ten digits", () => {
    for (const bad of ["", "123701018", "12370101801", "1237 01018X", "abcdefghij"]) {
      expect(validateSvnr(bad), bad).toBe("length");
    }
  });

  it("rejects the unissued 000 serial", () => {
    expect(validateSvnr("0007 010180")).toBe("serial");
  });

  it("rejects an impossible date tail", () => {
    // Month 13 and day 32 never occur; the checksum is irrelevant once the
    // tail cannot be a date at all.
    expect(validateSvnr("1237 011380")).toBe("date");
    expect(validateSvnr("1237 320180")).toBe("date");
    expect(validateSvnr("1237 310280")).toBe("date");
  });

  it("allows 29 February, which a two-digit year cannot disambiguate", () => {
    // 3·1+7·2+9·3 = 44; 5·2+8·9+4·0+2·2+1·8+6·0 = 10+72+0+4+8 = 94; 138 mod 11 = 6
    expect(validateSvnr("1236 290280")).toBeNull();
  });
});

describe("cross-check against the stored birth date", () => {
  it("passes when the tail matches", () => {
    expect(validateSvnr(VALID, "1980-01-01")).toBeNull();
  });

  it("catches a transposed birth date the checksum cannot", () => {
    expect(validateSvnr(VALID, "1980-01-02")).toBe("birthDateMismatch");
    expect(validateSvnr(VALID, "1981-01-01")).toBe("birthDateMismatch");
  });

  it("skips the cross-check when no birth date is known", () => {
    expect(validateSvnr(VALID, null)).toBeNull();
    expect(validateSvnr(VALID, undefined)).toBeNull();
  });
});

describe("helpers", () => {
  it("normalises and formats", () => {
    expect(normalizeSvnr("1237 010180")).toBe("1237010180");
    expect(formatSvnr("1237010180")).toBe("1237 010180");
  });

  it("leaves non-canonical input alone when formatting", () => {
    expect(formatSvnr("12")).toBe("12");
  });

  it("applies only to Austrian locations", () => {
    expect(requiresAustrianSvnr("Österreich")).toBe(true);
    for (const c of ["Deutschland", "Tschechien", "Slowenien", null, undefined]) {
      expect(requiresAustrianSvnr(c)).toBe(false);
    }
  });
});