import { randomBytes } from "node:crypto";

import type { Client, Row } from "@libsql/client";

// ---------------------------------------------------------------------------
// Invite codes — the join mechanism for a single-tenant instance.
//
// The instance closes open signup (the `user.create` gate in better-auth.ts)
// and lets people in ONLY by redeeming a per-user, single-use code. The code is
// the bearer credential: whoever holds it can self-register (with their own
// name/email/password) and lands as a real `member` of the one org. Unlike
// Better Auth's `invitation` table, a code is NOT bound to an email — the admin
// hands out a link, not an address.
//
// Stored in a raw libSQL table managed here (CREATE TABLE IF NOT EXISTS on
// boot), the same hand-rolled-SQL pattern the org/admin seed uses against the
// shared libSQL file. It is intentionally independent of both the fumadb
// versioned schema and Better Auth's migrator.
// ---------------------------------------------------------------------------

export type InviteRole = "admin" | "member";

export interface InviteCodeRow {
  readonly id: string;
  readonly code: string;
  readonly role: InviteRole;
  readonly label: string | null;
  readonly createdBy: string;
  readonly createdAt: string;
  readonly expiresAt: string | null;
  readonly usedBy: string | null;
  readonly usedByEmail: string | null;
  readonly usedAt: string | null;
}

// Unambiguous alphabet (no 0/O/1/I/l) so a code is easy to read and type.
const ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";

// 12 chars grouped as XXXX-XXXX-XXXX — easy to read aloud or paste.
const generateCode = (): string => {
  const bytes = randomBytes(12);
  const chars = Array.from(bytes, (b) => ALPHABET[b % ALPHABET.length]);
  return [chars.slice(0, 4), chars.slice(4, 8), chars.slice(8, 12)]
    .map((g) => g.join(""))
    .join("-");
};

const toRow = (raw: Row): InviteCodeRow => ({
  id: String(raw.id),
  code: String(raw.code),
  role: raw.role === "admin" ? "admin" : "member",
  label: raw.label == null ? null : String(raw.label),
  createdBy: String(raw.created_by),
  createdAt: String(raw.created_at),
  expiresAt: raw.expires_at == null ? null : String(raw.expires_at),
  usedBy: raw.used_by == null ? null : String(raw.used_by),
  usedByEmail: raw.used_by_email == null ? null : String(raw.used_by_email),
  usedAt: raw.used_at == null ? null : String(raw.used_at),
});

export const ensureInviteCodeTable = async (client: Client): Promise<void> => {
  await client.execute(`
    CREATE TABLE IF NOT EXISTS invite_code (
      id            TEXT PRIMARY KEY,
      code          TEXT NOT NULL UNIQUE,
      role          TEXT NOT NULL DEFAULT 'member',
      label         TEXT,
      created_by    TEXT NOT NULL,
      created_at    TEXT NOT NULL,
      expires_at    TEXT,
      used_by       TEXT,
      used_by_email TEXT,
      used_at       TEXT
    )
  `);
};

export interface CreateInviteCodeInput {
  readonly createdBy: string;
  readonly role?: InviteRole;
  readonly label?: string | null;
  readonly expiresAt?: string | null;
}

export const createInviteCode = async (
  client: Client,
  input: CreateInviteCodeInput,
): Promise<InviteCodeRow> => {
  const row: InviteCodeRow = {
    id: randomBytes(16).toString("hex"),
    code: generateCode(),
    role: input.role ?? "member",
    label: input.label ?? null,
    createdBy: input.createdBy,
    createdAt: new Date().toISOString(),
    expiresAt: input.expiresAt ?? null,
    usedBy: null,
    usedByEmail: null,
    usedAt: null,
  };
  await client.execute({
    sql: `INSERT INTO invite_code (id, code, role, label, created_by, created_at, expires_at)
          VALUES (?, ?, ?, ?, ?, ?, ?)`,
    args: [row.id, row.code, row.role, row.label, row.createdBy, row.createdAt, row.expiresAt],
  });
  return row;
};

// Newest first; the admin page renders pending + used together.
export const listInviteCodes = async (client: Client): Promise<readonly InviteCodeRow[]> => {
  const result = await client.execute("SELECT * FROM invite_code ORDER BY created_at DESC");
  return result.rows.map(toRow);
};

// Revoke = delete a pending (unused) code. Used codes are kept as an audit row
// (their membership already exists); deleting one would not remove the member.
export const revokeInviteCode = async (client: Client, id: string): Promise<void> => {
  await client.execute({
    sql: "DELETE FROM invite_code WHERE id = ? AND used_at IS NULL",
    args: [id],
  });
};

// A code is redeemable when it exists, is unused, and is unexpired.
export const findRedeemableCode = async (
  client: Client,
  code: string,
): Promise<InviteCodeRow | null> => {
  const result = await client.execute({
    sql: "SELECT * FROM invite_code WHERE code = ? AND used_at IS NULL",
    args: [code.trim().toUpperCase()],
  });
  const raw = result.rows[0];
  if (!raw) return null;
  const row = toRow(raw);
  if (row.expiresAt && Date.parse(row.expiresAt) < Date.now()) return null;
  return row;
};

// Mark a code consumed. The `used_at IS NULL` guard makes this the single-use
// gate even under a race: rowsAffected === 0 means someone redeemed it first.
export const consumeInviteCode = async (
  client: Client,
  code: string,
  by: { usedBy: string; usedByEmail: string },
): Promise<boolean> => {
  const result = await client.execute({
    sql: `UPDATE invite_code SET used_by = ?, used_by_email = ?, used_at = ?
          WHERE code = ? AND used_at IS NULL`,
    args: [by.usedBy, by.usedByEmail, new Date().toISOString(), code.trim().toUpperCase()],
  });
  return result.rowsAffected > 0;
};