// Headless runtime: drive the download queue without the Ink TUI.
//
// The TUI is one front-end over DownloadQueue; a seedbox needs another that has
// no terminal at all. This mirrors App.tsx's boot sequence (load config, restore
// queue/history/seeds) so a headless run resumes exactly what an interactive one
// would, then exposes a single addInput() the watch folder and HTTP API share.

import { promises as fs } from "node:fs";
import { loadConfig } from "../config/config";
import { DownloadQueue } from "../download/queue";
import { loadQueue, loadSeeds } from "../download/persist";
import { loadHistory } from "../download/history";
import { reconcileQueue } from "../download/reconcile";
import {
  BOOT_SETTLE_MS,
  armBootMarker,
  disarmBootMarker,
  wasBootInterrupted,
} from "../download/bootguard";
import { parseInput } from "../sources/magnet";
import { magnetFromTorrentFile } from "../sources/torrentFile";

export interface Runtime {
  queue: DownloadQueue;
  downloadDir: string;
  // True when the previous run died mid-restore and this boot came up in safe
  // mode: everything paused, no engines started (see download/bootguard.ts).
  recovered?: boolean;
}

// Build a queue and restore persisted state, matching the TUI's boot order
// (history before seeds — seeds resolve against history). `downloadDir` falls
// back to the saved config's dir when the caller doesn't override it.
export async function startRuntime(overrideDir?: string): Promise<Runtime> {
  const cfg = await loadConfig();
  const queue = new DownloadQueue();
  queue.setTrackers(cfg.trackers);
  // Crash-boot breaker, mirroring the TUI: a marker left by the previous run
  // means it died mid-restore, so restore paused with the engine cold.
  const safe = wasBootInterrupted();
  armBootMarker();
  queue.restore(reconcileQueue(await loadQueue()), { safe });
  queue.restoreHistory(await loadHistory());
  queue.restoreSeeds(await loadSeeds(), { safe });
  setTimeout(disarmBootMarker, BOOT_SETTLE_MS).unref();
  if (safe) {
    console.error("[torlnk] recovered from a crashed start: restored downloads are paused");
  }
  const downloadDir = overrideDir && overrideDir.trim() ? overrideDir.trim() : cfg.downloadDir;
  return { queue, downloadDir, recovered: safe };
}

export type AddOutcome = "added" | "duplicate" | "invalid";

// Turn a magnet URI, bare info hash, or a path to a .torrent file into a queued
// download. Deduplicates by info hash (the queue's own id), so re-submitting the
// same torrent is a no-op rather than a restart. Never throws — bad input is
// reported as "invalid" so callers (a watcher, an HTTP handler) can fail soft.
export interface AddInputOptions {
  // Treat an input ending in .torrent as a local file path and read it. Only
  // the watch folder opts in; a network caller (the HTTP add API) must never
  // be able to point the daemon at the local filesystem.
  allowTorrentPath?: boolean;
}

export async function addInput(
  runtime: Runtime,
  input: string,
  options: AddInputOptions = {},
): Promise<AddOutcome> {
  const trimmed = input.trim();
  let parsed;
  if (/\.torrent$/i.test(trimmed)) {
    if (!options.allowTorrentPath) return "invalid";
    parsed = await magnetFromTorrentFile(trimmed);
  } else {
    parsed = parseInput(trimmed);
  }
  if (!parsed) return "invalid";
  if (runtime.queue.has(parsed.infoHash)) return "duplicate";
  await fs.mkdir(runtime.downloadDir, { recursive: true }).catch(() => {});
  runtime.queue.add(
    { id: parsed.infoHash, name: parsed.name, magnet: parsed.magnet },
    runtime.downloadDir,
  );
  return "added";
}