import path from "node:path";
import { songDir, isSegment } from "./browse";
import { stateFile } from "./paths";
import { readJson, withStateLock, writeJsonAtomic } from "./state";
import { NOTE_LIMIT, type NoteMap } from "./note-types";

// ---------------------------------------------------------------------------
// Notes on anything.
//
// The point of these is NOT to annotate a file for its own sake -- it is to be
// able to hand a whole song's picture to someone (or to a model) in one paste,
// without re-deriving it from scrollback. Every judgement made here has a
// reason, and the reason is the part that gets lost: a variant named
// `wide-triangle` records that a triangle build exists and nothing about why it
// was tried or what was wrong with it.
//
// So notes are attached to TARGETS, not to files, and a target can be anything
// the UI lets you select:
//
//   song                       the song as a whole
//   file:<rel>                 a cut or a variant
//   cut:<name>                 the cut SLOT -- notes survive a promote, and can
//                              be written about a cut that does not exist yet
//   plan:<name>                one file in plan/
//   thumb:<name>               one cover in thumb-manifest.json
//   source:<videoId>           an episode the clips come from
//   clip:<video>@<srcStart>    one note in the arrangement
//   moment:<rel>@<seconds>     a timestamped mark on a rendered cut
//
// GENEROUS ON PURPOSE. The cap is 8000 characters, not 200: a note that has to
// be terse is a note that loses the reasoning, and the reasoning is the whole
// value. Multi-line is normal.
// ---------------------------------------------------------------------------

// The shapes live in lib/note-types.ts, which has no server imports, so a
// client component can take NOTE_LIMIT as a value without dragging node:fs into
// the browser bundle. Re-exported here so the server side has one import.
export { NOTE_LIMIT } from "./note-types";
export type { NoteEntry, NoteMap } from "./note-types";

// `moment:` carries a float, `clip:` an @-separated id, so this is deliberately
// loose about the tail and strict about the head and the characters allowed.
const TARGET_RE =
  /^(song|file:[A-Za-z0-9._/-]+|cut:[A-Za-z0-9-]+|plan:[A-Za-z0-9._-]+|thumb:[A-Za-z0-9._-]+|source:[A-Za-z0-9_-]+|clip:[A-Za-z0-9_-]+@[0-9.]+|moment:[A-Za-z0-9._/-]+@[0-9.]+)$/;

export function isTarget(v: string): boolean {
  return TARGET_RE.test(v) && !v.includes("..");
}

export const notesFile = (id: string) => path.join(songDir(id), "notes.json");

export async function readNotes(id: string): Promise<NoteMap> {
  if (!isSegment(id)) return {};
  const j = await readJson<NoteMap>(notesFile(id), {});
  return j && typeof j === "object" ? j : {};
}

async function write(file: string, fn: (map: NoteMap) => void): Promise<NoteMap> {
  let out: NoteMap = {};
  await withStateLock(async () => {
    const map = await readJson<NoteMap>(file, {});
    const safe = map && typeof map === "object" ? map : {};
    fn(safe);
    await writeJsonAtomic(file, safe);
    out = safe;
  });
  return out;
}

/** Set or clear one note. An empty note REMOVES the row rather than storing "". */
export async function setNote(id: string, target: string, note: string): Promise<NoteMap> {
  return write(notesFile(id), (map) => {
    const text = note.slice(0, NOTE_LIMIT).replace(/\s+$/, "");
    if (!text) delete map[target];
    else map[target] = { note: text, at: new Date().toISOString() };
  });
}

/**
 * Follow a note to a file's new name.
 *
 * Promote renames a cut, and a note about `variants/wide-nokit.mp4` is a note
 * about those bytes -- the same argument verdicts.json makes. Notes on the
 * `cut:` slot deliberately do NOT move: they are about the slot.
 */
export async function carryNotes(id: string, moves: { from: string; to: string }[]): Promise<void> {
  if (!moves.length) return;
  await write(notesFile(id), (map) => {
    for (const m of moves) {
      const momentPrefix = `moment:${m.from}@`;
      for (const key of Object.keys(map)) {
        if (key === `file:${m.from}`) {
          map[`file:${m.to}`] = map[key];
          delete map[key];
        } else if (key.startsWith(momentPrefix)) {
          // A moment key is `moment:<rel>@<t>`, so the rename applies to the rel
          // part only -- otherwise every mark on a promoted variant is orphaned
          // at exactly the moment it becomes the shipped cut.
          map[`moment:${m.to}@${key.slice(momentPrefix.length)}`] = map[key];
          delete map[key];
        }
      }
    }
  });
}

/** Every timestamped mark on one rendition, in time order. */
export function momentsOf(map: NoteMap, rel: string): { t: number; note: string; at: string }[] {
  const prefix = `moment:${rel}@`;
  return Object.entries(map)
    .filter(([k]) => k.startsWith(prefix))
    .map(([k, v]) => ({ t: Number(k.slice(prefix.length)), note: v.note, at: v.at }))
    .filter((m) => Number.isFinite(m.t))
    .sort((a, b) => a.t - b.t);
}

// ---------------------------------------------------------------------------
// Trim sets are not song-scoped.
//
// A hook belongs to a catalogue shared across every song that uses it, so its
// notes cannot live in one song's notes.json. Small separate file, same
// contract, keyed `<set>:<hookId>`.
// ---------------------------------------------------------------------------

export const TRIM_NOTES = () => stateFile("trim-notes.json");

export async function readTrimNotes(): Promise<NoteMap> {
  const j = await readJson<NoteMap>(TRIM_NOTES(), {});
  return j && typeof j === "object" ? j : {};
}

export async function setTrimNote(set: string, hookId: string, note: string): Promise<NoteMap> {
  return write(TRIM_NOTES(), (map) => {
    const text = note.slice(0, NOTE_LIMIT).replace(/\s+$/, "");
    const key = `${set}:${hookId}`;
    if (!text) delete map[key];
    else map[key] = { note: text, at: new Date().toISOString() };
  });
}