// `archilyzer media attach <slug> <source> [--items <json>] [--match <re>]
// [--create-records] [--replace] [--dry-run]` — a channel's held videos given
// their media from a local archive, offline. The work and its rules are
// controller/attachMedia.ts; the editor runs the same function as the
// `attach-media` job (`POST /api/ops/attach-media`).
//
// Nothing on the network. It copies into the saved-video store and writes
// pointers (and, with --create-records, records) atomically; it does not see
// the editor's queues, so not beside a job on the same channel. The channel's
// media guard is asked here, as the job kind's `needsMedia` asks it there.

import { readFile } from "node:fs/promises";
import { getPaths } from "../lib/paths";
import { assertChannelMediaReachable } from "../lib/channelMedia";
import { isValidChannelSlug, readChannelConfig } from "../controller/channels";
import { attachMedia } from "../controller/attachMedia";
import type { AttachItem } from "../lib/attachMediaPlan";

function parseItems(text: string): AttachItem[] {
  const raw = JSON.parse(text) as unknown;
  if (!Array.isArray(raw) || raw.length === 0) throw new Error("--items: a non-empty JSON array of {id, path}");
  return raw.map((e, i) => {
    const r = e as Record<string, unknown>;
    if (typeof r?.id !== "string" || !r.id || /[/\\\0]/.test(r.id) || typeof r.path !== "string" || !r.path) {
      throw new Error(`--items[${i}]: an object {"id": "<video id>", "path": "<entry in the source>"}`);
    }
    return { id: r.id, path: r.path };
  });
}

export async function main(opts: {
  slug: string;
  source: string;
  items?: string;
  match?: string;
  createRecords: boolean;
  replace: boolean;
  dryRun: boolean;
  signal?: AbortSignal;
}): Promise<number> {
  if (!isValidChannelSlug(opts.slug)) {
    console.error(`media attach: "${opts.slug}" is not a channel slug`);
    return 2;
  }
  try {
    const paths = getPaths();
    const channelConfig = await readChannelConfig(paths, opts.slug);
    if (!channelConfig) {
      console.error(`media attach: no channel "${opts.slug}"`);
      return 2;
    }
    if (!opts.dryRun) await assertChannelMediaReachable(paths, opts.slug, channelConfig);
    // --items is a JSON array, inline or "@file".
    const items =
      opts.items === undefined
        ? undefined
        : parseItems(opts.items.startsWith("@") ? await readFile(opts.items.slice(1), "utf8") : opts.items);
    const result = await attachMedia({
      paths,
      slug: opts.slug,
      channelConfig,
      source: opts.source,
      ...(items ? { items } : {}),
      ...(opts.match !== undefined ? { match: opts.match } : {}),
      ...(opts.createRecords ? { createRecords: true } : {}),
      ...(opts.replace ? { replace: true } : {}),
      ...(opts.dryRun ? { dryRun: true } : {}),
      onLog: (line) => console.log(line.replace(/\n$/, "")),
      ...(opts.signal ? { signal: opts.signal } : {}),
    });
    return result.failed.length > 0 || (result.stopped && result.stopped !== "drained") ? 1 : 0;
  } catch (err) {
    console.error(`media attach: ${(err as Error).message}`);
    return 1;
  }
}