import { spawn } from "node:child_process";
import { existsSync } from "node:fs";
import { join } from "node:path";

export interface ThtConfig {
  thtBin: string;
  harnessDir: string;
  configPath: string;
}

export interface SessionRow {
  id: string;
  status: string;
  question: string;
  summary: string | null;
  created_at: string;
  updated_at: string | null;
  author: string | null;
}

export class ThtRunner {
  constructor(private cfg: ThtConfig) {}

  /**
   * Resolve the `-c <config>` args. If `workspace` is given AND a matching
   * `workspaces/<workspace>.yaml` exists under harnessDir, select it; otherwise
   * fall back to the default configPath.
   */
  private configArg(workspace?: string): string[] {
    if (workspace && existsSync(join(this.cfg.harnessDir, "workspaces", `${workspace}.yaml`))) {
      return ["-c", `workspaces/${workspace}.yaml`];
    }
    return ["-c", this.cfg.configPath];
  }

  run(args: string[], workspace?: string): Promise<{ code: number; stdout: string; stderr: string }> {
    return new Promise((resolve) => {
      const ch = spawn(this.cfg.thtBin, [...this.configArg(workspace), ...args], {
        cwd: this.cfg.harnessDir,
      });
      let stdout = "";
      let stderr = "";
      ch.stdout.on("data", (d: Buffer) => (stdout += d));
      ch.stderr.on("data", (d: Buffer) => (stderr += d));
      ch.on("close", (code) => resolve({ code: code ?? 0, stdout, stderr }));
    });
  }

  private async json<T>(args: string[], workspace?: string): Promise<T> {
    const { code, stdout, stderr } = await this.run(args, workspace);
    if (code !== 0) throw new Error(`tht ${args.join(" ")} exit ${code}: ${stderr.trim()}`);
    return JSON.parse(stdout) as T;
  }

  async sessionNew(o: {
    question: string;
    provider?: string;
    model?: string;
    thinking?: string;
    name?: string;
    workspace?: string;
  }) {
    const a = ["session", "new", o.question];
    for (const [f, v] of [
      ["--provider", o.provider],
      ["--model", o.model],
      ["--thinking", o.thinking],
      ["--name", o.name],
    ] as const) {
      if (v) a.push(f, v);
    }
    a.push("--json");
    return this.json<{ id: string }>(a, o.workspace);
  }

  sessionList() {
    return this.json<SessionRow[]>(["session", "list", "--json"]);
  }

  sessionShow(id: string) {
    return this.json<unknown>(["session", "show", id, "--json"]);
  }

  sqlPreview(id: string, p: { limit?: number; offset?: number }) {
    const a = ["sql", "preview", `sessions/${id}/sql_final.sql`, "--session", id, "--json"];
    if (p.limit != null) a.push("--limit", String(p.limit));
    if (p.offset != null) a.push("--offset", String(p.offset));
    return this.json<{
      columns: string[];
      rows: unknown[][];
      execution_ms: number;
      truncated: boolean;
    }>(a);
  }

  async sqlExport(id: string) {
    const { code, stdout, stderr } = await this.run(["sql", "export", "--session", id]);
    if (code !== 0) throw new Error(`tht sql export exit ${code}: ${stderr.trim()}`);
    return { path: stdout.trim() };
  }
}