// On-disk library: one directory per video, each with a video.json.
//
//   <root>/library.json               { order: [videoId, ...] }
//   <root>/config.json                app settings (incl. Deepgram key), mode 0600
//   <root>/<videoId>/video.json
//   <root>/<videoId>/thumbnail.jpg
//   <root>/<videoId>/takes/<takeId>/{screen,camera}.webm, peaks.json, transcript.json
//   <root>/.trash/                    deleted videos are moved here

import fs from 'node:fs/promises';
import path from 'node:path';
import type { AppConfig, Video, VideoSummary } from '../shared/types.ts';
import { exportSignature } from '../shared/types.ts';
import { randomId, timelineDuration } from '../shared/timeline.ts';

export class HttpError extends Error {
  status: number;
  constructor(status: number, message: string) {
    super(message);
    this.status = status;
  }
}

let root = '';

export async function initStore(dir: string) {
  root = dir;
  await fs.mkdir(root, { recursive: true });
}

export const libraryDir = () => root;
export const videoDir = (id: string) => path.join(root, checkId(id));
export const takeDir = (id: string, takeId: string) => path.join(videoDir(id), 'takes', checkId(takeId));

const ID_RE = /^[a-z0-9][a-z0-9-]{0,79}$/;

export function checkId(id: string): string {
  if (typeof id !== 'string' || !ID_RE.test(id)) throw new HttpError(400, `Invalid id: ${id}`);
  return id;
}

export async function exists(p: string) {
  try {
    await fs.access(p);
    return true;
  } catch {
    return false;
  }
}

async function readJson<T>(file: string, fallback: T): Promise<T> {
  try {
    return JSON.parse(await fs.readFile(file, 'utf8')) as T;
  } catch (e) {
    if ((e as NodeJS.ErrnoException).code === 'ENOENT') return fallback;
    throw e;
  }
}

export async function writeJsonAtomic(file: string, data: unknown, mode = 0o644) {
  const tmp = `${file}.${randomId(6)}.tmp`;
  await fs.writeFile(tmp, JSON.stringify(data, null, 2), { mode });
  await fs.rename(tmp, file);
}

// Serialize read-modify-write cycles per key.
const locks = new Map<string, Promise<unknown>>();
function withLock<T>(key: string, fn: () => Promise<T>): Promise<T> {
  const prev = locks.get(key) ?? Promise.resolve();
  const next = prev.then(fn, fn);
  const settled = next.catch(() => {});
  locks.set(key, settled);
  settled.then(() => {
    if (locks.get(key) === settled) locks.delete(key);
  });
  return next;
}

// ---- config ----

const DEFAULT_CONFIG: AppConfig & { deepgramApiKey: string } = {
  deepgramApiKey: '',
  deepgramModel: 'nova-3',
  autoTranscribe: true,
  defaultCountdown: 3,
  defaultCameraHeight: 720,
  defaultOutputHeight: 720,
  matteHost: '',
  matteSetup: '',
};

export type FullConfig = typeof DEFAULT_CONFIG;

export async function getConfig(): Promise<FullConfig> {
  return { ...DEFAULT_CONFIG, ...(await readJson<Partial<FullConfig>>(path.join(root, 'config.json'), {})) };
}

export function updateConfig(patch: Partial<FullConfig>): Promise<FullConfig> {
  return withLock('__config__', async () => {
    const cfg = await getConfig();
    for (const k of Object.keys(DEFAULT_CONFIG) as (keyof FullConfig)[]) {
      if (patch[k] !== undefined) (cfg as unknown as Record<string, unknown>)[k] = patch[k];
    }
    await writeJsonAtomic(path.join(root, 'config.json'), cfg, 0o600);
    return cfg;
  });
}

// ---- videos ----

export async function getVideo(id: string): Promise<Video> {
  const v = await readJson<Video | null>(path.join(videoDir(id), 'video.json'), null);
  if (!v) throw new HttpError(404, `Video not found: ${id}`);
  return v;
}

export function updateVideo(id: string, fn: (v: Video) => void | Promise<void>): Promise<Video> {
  return withLock(id, async () => {
    const v = await getVideo(id);
    await fn(v);
    v.updatedAt = new Date().toISOString();
    await writeJsonAtomic(path.join(videoDir(id), 'video.json'), v);
    return v;
  });
}

function newVideoId(title: string) {
  const d = new Date();
  const pad = (n: number) => String(n).padStart(2, '0');
  const stamp = `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}`;
  const slug = slugify(title).slice(0, 40);
  return [stamp, slug, randomId(4)].filter(Boolean).join('-');
}

export function slugify(s: string) {
  return s
    .toLowerCase()
    .normalize('NFKD')
    .replace(/[^a-z0-9]+/g, '-')
    .replace(/^-+|-+$/g, '');
}

export async function createVideo(input: { title?: string; description?: string; notes?: string }): Promise<Video> {
  const cfg = await getConfig();
  const now = new Date().toISOString();
  const title = (input.title ?? '').trim() || 'Untitled video';
  const v: Video = {
    id: newVideoId(title),
    title,
    description: input.description ?? '',
    notes: input.notes ?? '',
    createdAt: now,
    updatedAt: now,
    takes: [],
    timeline: [],
    layout: { mode: 'pip', corner: 'br', size: 0.22, shape: 'rounded' },
    output: { height: cfg.defaultOutputHeight, normalizeAudio: true },
    thumbnail: null,
    export: null,
  };
  await fs.mkdir(path.join(videoDir(v.id), 'takes'), { recursive: true });
  await writeJsonAtomic(path.join(videoDir(v.id), 'video.json'), v);
  await withLock('__library__', async () => {
    const lib = await readLibrary();
    lib.order.push(v.id);
    await writeJsonAtomic(path.join(root, 'library.json'), lib);
  });
  return v;
}

async function readLibrary() {
  return readJson<{ order: string[] }>(path.join(root, 'library.json'), { order: [] });
}

export function summarize(v: Video): VideoSummary {
  const ready = v.takes.filter((t) => t.status === 'ready');
  const used = new Set(v.timeline.map((s) => s.takeId));
  const usedTakes = ready.filter((t) => used.has(t.id));
  return {
    id: v.id,
    title: v.title,
    description: v.description,
    createdAt: v.createdAt,
    updatedAt: v.updatedAt,
    duration: timelineDuration(v.timeline),
    takeCount: ready.length,
    hasScreen: usedTakes.some((t) => t.tracks.screen),
    hasCamera: usedTakes.some((t) => t.tracks.camera),
    thumbnailUrl: v.thumbnail ? `/media/${v.id}/${v.thumbnail.file}?v=${encodeURIComponent(v.thumbnail.updatedAt)}` : null,
    exportState: !v.export ? 'none' : v.export.signature === exportSignature(v) ? 'current' : 'stale',
  };
}

export async function listVideos(): Promise<VideoSummary[]> {
  const entries = await fs.readdir(root, { withFileTypes: true });
  const videos = new Map<string, Video>();
  for (const e of entries) {
    if (!e.isDirectory() || !ID_RE.test(e.name)) continue;
    try {
      videos.set(e.name, await getVideo(e.name));
    } catch {
      // not a video directory
    }
  }
  const lib = await readLibrary();
  const ordered = lib.order.filter((id) => videos.has(id));
  const rest = [...videos.keys()].filter((id) => !ordered.includes(id)).sort((a, b) => videos.get(a)!.createdAt.localeCompare(videos.get(b)!.createdAt));
  return [...ordered, ...rest].map((id) => summarize(videos.get(id)!));
}

export function setOrder(order: string[]) {
  order.forEach(checkId);
  return withLock('__library__', async () => {
    await writeJsonAtomic(path.join(root, 'library.json'), { order });
  });
}

export async function trashVideo(id: string) {
  const src = videoDir(id);
  if (!(await exists(path.join(src, 'video.json')))) throw new HttpError(404, `Video not found: ${id}`);
  const trash = path.join(root, '.trash');
  await fs.mkdir(trash, { recursive: true });
  await withLock(id, () => fs.rename(src, path.join(trash, `${id}--deleted-${Date.now()}`)));
  await withLock('__library__', async () => {
    const lib = await readLibrary();
    lib.order = lib.order.filter((x) => x !== id);
    await writeJsonAtomic(path.join(root, 'library.json'), lib);
  });
}