/**
 * Postgres count() returns bigint, which the driver hands back as a STRING.
 *
 * Drizzle's `sql<number>` is a compile-time cast only — it does not coerce at
 * runtime — so `sql<number>`count(*)`` yields "0", not 0. Every consumer that
 * compared with === or did arithmetic was silently broken:
 *
 *   - onboarding.tsx: `repoCount === 0` is "0" === 0 → false, so the entire
 *     first-run branch was unreachable and brand-new users never saw the
 *     getting-started flow.
 *   - notifications.tsx: `unreadCount === 0` → the "You are all caught up"
 *     state could never render.
 *   - inbox.tsx: GET /api/inbox/count returned a JSON string, diverging from
 *     /api/notifications/count which returns a number.
 *   - pulls.tsx previously rendered "0"+"0"+"0" as "000" (fixed earlier).
 *
 * The established fix in this codebase is `count(*)::int` — already used at
 * 100+ sites. These stragglers are now consistent with it.
 */

import { describe, expect, it } from "bun:test";
import { readdirSync, readFileSync, statSync } from "fs";
import { join } from "path";

function walk(dir: string): string[] {
  const out: string[] = [];
  for (const e of readdirSync(dir)) {
    const p = join(dir, e);
    if (statSync(p).isDirectory()) {
      if (e === "__tests__") continue;
      out.push(...walk(p));
    } else if (e.endsWith(".ts") || e.endsWith(".tsx")) out.push(p);
  }
  return out;
}

const FILES = walk("src");

describe("no uncast bigint aggregates typed as number", () => {
  it("every sql<number>count(*) casts to ::int", () => {
    const offenders: string[] = [];
    for (const f of FILES) {
      const src = readFileSync(f, "utf8");
      src.split("\n").forEach((line, i) => {
        // Typed as number but no cast — the exact bug shape.
        if (/sql<number>`\s*count\(\*\)\s*`/.test(line)) {
          offenders.push(`${f.replace(/\\/g, "/")}:${i + 1}`);
        }
      });
    }
    expect(offenders).toEqual([]);
  });

  it("no sql<number> wraps count()/sum() of a column without a cast either", () => {
    const offenders: string[] = [];
    for (const f of FILES) {
      const src = readFileSync(f, "utf8");
      src.split("\n").forEach((line, i) => {
        const m = line.match(/sql<number>`([^`]*)`/);
        if (!m) return;
        const expr = m[1];
        if (!/\b(count|sum)\s*\(/i.test(expr)) return;
        if (expr.includes("::")) return; // cast present
        offenders.push(`${f.replace(/\\/g, "/")}:${i + 1} → ${expr.trim()}`);
      });
    }
    expect(offenders).toEqual([]);
  });
});

describe("the specific consumers that were broken", () => {
  it("onboarding's first-run branch can now be reached", () => {
    const src = readFileSync("src/routes/onboarding.tsx", "utf8");
    expect(src).toContain("count(*)::int");
    // The comparison itself is fine once the value is a real number.
    expect(src).toContain("repoCount === 0");
  });

  it("notifications' all-caught-up branch can now be reached", () => {
    const src = readFileSync("src/routes/notifications.tsx", "utf8");
    expect(src).toContain("count(*)::int");
    expect(src).toContain("unreadCount === 0");
  });

  it("inbox's count endpoint returns a number", () => {
    const src = readFileSync("src/routes/inbox.tsx", "utf8");
    expect(src).toContain("count(*)::int");
  });
});

describe("ORDER BY aggregates are deliberately left alone", () => {
  it("bare sql`count(*)` in an orderBy is not flagged", () => {
    // Sorting on bigint is correct; only *selected* values reach JS and need
    // the cast. Keeping these uncast avoids churn with no behaviour change.
    const pulls = readFileSync("src/routes/pulls.tsx", "utf8");
    expect(pulls).toContain("desc(sql`count(*)`)");
  });
});