/**
 * PAT expiration.
 *
 * The api_tokens.expires_at column has existed since the table was created,
 * but nothing ever wrote to it: the create form had no expiry control and the
 * POST handler never set the field, so every token ever issued was stored with
 * expires_at = NULL. All three auth paths read that as "never expires", so
 * PATs were effectively immortal and could not be rotated on a schedule.
 *
 * These cover the parsing rules and, crucially, that a rejected expiry never
 * degrades into "no expiration".
 */

import { describe, expect, it } from "bun:test";
import { parseExpiry, INVALID_EXPIRY } from "../routes/tokens";

const NOW = new Date("2026-07-27T09:00:00.000Z");
const DAY = 86_400_000;

describe("parseExpiry — presets", () => {
  for (const days of [7, 30, 60, 90]) {
    it(`"${days}" → ${days} days from now`, () => {
      const got = parseExpiry(String(days), "", NOW);
      expect(got).toBeInstanceOf(Date);
      expect((got as Date).getTime()).toBe(NOW.getTime() + days * DAY);
    });
  }

  it('"never" → null (no expiration)', () => {
    expect(parseExpiry("never", "", NOW)).toBeNull();
  });

  it("a blank choice defaults to 30 days, NOT to no-expiration", () => {
    const got = parseExpiry("", "", NOW);
    expect(got).toBeInstanceOf(Date);
    expect((got as Date).getTime()).toBe(NOW.getTime() + 30 * DAY);
  });
});

describe("parseExpiry — custom date", () => {
  it("accepts a future yyyy-mm-dd and anchors to end-of-day UTC", () => {
    const got = parseExpiry("custom", "2026-08-15", NOW);
    expect(got).toBeInstanceOf(Date);
    expect((got as Date).toISOString()).toBe("2026-08-15T23:59:59.999Z");
  });

  it("end-of-day anchoring keeps today's date usable, not instantly dead", () => {
    // A user picking "today" should get the rest of the day, not a token that
    // expired at 00:00 this morning.
    const got = parseExpiry("custom", "2026-07-27", NOW);
    expect(got).toBeInstanceOf(Date);
    expect((got as Date).getTime()).toBeGreaterThan(NOW.getTime());
  });

  it("rejects a past date", () => {
    expect(parseExpiry("custom", "2026-07-01", NOW)).toBe(INVALID_EXPIRY);
  });

  it("rejects a blank custom date", () => {
    expect(parseExpiry("custom", "", NOW)).toBe(INVALID_EXPIRY);
  });

  it("rejects garbage", () => {
    expect(parseExpiry("custom", "not-a-date", NOW)).toBe(INVALID_EXPIRY);
  });
});

describe("parseExpiry — rejected input never becomes 'no expiration'", () => {
  // The whole point of the INVALID_EXPIRY sentinel. If these returned null the
  // caller would happily mint an immortal token from input it had rejected.
  for (const bad of ["0", "-30", "1.5", "abc"]) {
    it(`"${bad}" is rejected, not treated as never-expires`, () => {
      const got = parseExpiry(bad, "", NOW);
      expect(got).toBe(INVALID_EXPIRY);
      expect(got).not.toBeNull();
    });
  }
});

describe("expiry enforcement contract", () => {
  it("all three auth paths null-guard expiresAt before comparing", async () => {
    // Guards against a regression where someone drops the `row.expiresAt &&`
    // check: `new Date(null) < new Date()` is 1970 < now === true, which would
    // instantly reject every no-expiration token in existence.
    const { readFileSync } = await import("fs");
    const paths = [
      "src/middleware/api-auth.ts",
      "src/middleware/auth.ts",
      "src/lib/git-push-auth.ts",
    ];
    for (const p of paths) {
      const src = readFileSync(p, "utf8");
      expect(src).toContain("expiresAt &&");
    }
  });
});