import { DatabaseSync, type SQLInputValue, type StatementSync } from "node:sqlite";

type BoundValue = ArrayBuffer | ArrayBufferView | bigint | boolean | null | number | string;

const databases = new Map<string, D1Database>();

function sqliteValue(value: BoundValue): SQLInputValue {
  if (typeof value === "boolean") return value ? 1 : 0;
  if (value instanceof ArrayBuffer) return new Uint8Array(value);
  if (ArrayBuffer.isView(value)) return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
  return value;
}

function meta(duration: number, changes: bigint | number = 0, lastRowId: bigint | number = 0) {
  const numericChanges = Number(changes);
  return {
    changed_db: numericChanges > 0,
    changes: numericChanges,
    duration,
    last_row_id: Number(lastRowId),
    rows_read: 0,
    rows_written: numericChanges,
    size_after: 0,
  };
}

class NodeD1Statement {
  constructor(
    private readonly statement: StatementSync,
    private readonly values: BoundValue[] = [],
  ) {}

  bind(...values: BoundValue[]) {
    return new NodeD1Statement(this.statement, values);
  }

  private parameters() {
    return this.values.map(sqliteValue);
  }

  private rows() {
    return this.statement.all(...this.parameters()) as Record<string, unknown>[];
  }

  async first(column?: string) {
    const row = this.rows()[0] || null;
    if (!row || column === undefined) return row;
    if (!(column in row)) throw new Error(`Column ${column} is unavailable.`);
    return row[column];
  }

  async run() {
    const started = performance.now();
    const result = this.statement.run(...this.parameters());
    return { success: true, results: [], meta: meta(performance.now() - started, result.changes, result.lastInsertRowid) };
  }

  async all() {
    const started = performance.now();
    const results = this.rows();
    return { success: true, results, meta: meta(performance.now() - started) };
  }

  async raw(options?: { columnNames?: boolean }) {
    const columns = this.statement.columns().map((column) => column.name);
    this.statement.setReturnArrays(true);
    let rows: unknown[][];
    try {
      rows = this.statement.all(...this.parameters()) as unknown as unknown[][];
    } finally {
      this.statement.setReturnArrays(false);
    }
    return options?.columnNames ? [columns, ...rows] : rows;
  }
}

class NodeD1Database {
  private readonly database: DatabaseSync;

  constructor(path: string) {
    this.database = new DatabaseSync(path);
    this.database.exec("PRAGMA foreign_keys = ON; PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 5000;");
  }

  prepare(query: string) {
    return new NodeD1Statement(this.database.prepare(query));
  }

  async batch(statements: NodeD1Statement[]) {
    this.database.exec("BEGIN IMMEDIATE");
    try {
      const results = [];
      for (const statement of statements) results.push(await statement.all());
      this.database.exec("COMMIT");
      return results;
    } catch (error) {
      this.database.exec("ROLLBACK");
      throw error;
    }
  }

  async exec(query: string) {
    const started = performance.now();
    this.database.exec(query);
    return { count: 1, duration: performance.now() - started };
  }
}

export function getNodeD1Database(path: string) {
  let database = databases.get(path);
  if (!database) {
    database = new NodeD1Database(path) as unknown as D1Database;
    databases.set(path, database);
  }
  return database;
}