// The shortlist shapes and their validator, with NO server imports -- the same
// client-boundary rule lib/note-types.ts and lib/phrase-types.ts follow.
//
// A shortlist is what turns a search into an EDIT. The console retrieves by
// meaning; this is where the order gets decided, which is the part a renderer
// downstream actually consumes.

import { NOTE_LIMIT } from "./note-types";

export { NOTE_LIMIT };

/**
 * The one channel the two client components on /browse/find use to agree.
 *
 * The rows can star and the bar can unstar, and both must show the same list a
 * moment later. Every mutation returns the WHOLE list, so one event carrying it
 * keeps them exact -- where a router.refresh() would re-run the search, rebuild
 * the rows and throw away which row was focused, on every star.
 */
export const SHORTLIST_EVENT = "umtool:shortlist";

export const NAME_LIMIT = 120;
export const SLUG_LIMIT = 60;

/**
 * One starred moment.
 *
 * A SNAPSHOT, not a reference. Storing only the id would let a re-transcription
 * silently re-point a pick at a different word -- the word indices shift the
 * moment a chunk boundary moves, and nothing would say so. With the text and
 * the times written down, staleness can be DETECTED: the list still says what
 * it meant, and a mismatch against the corpus is visible rather than invisible.
 *
 * `q` is kept for the same reason. Six weeks later a list of 40 moments with no
 * record of what was asked for is a list that has to be re-derived by ear.
 */
export type Pick = {
  /** `<video>#<wordIndex>`, the hit's identity. Never a timestamp. */
  id: string;
  video: string;
  i: number;
  start: number;
  end: number;
  /** The words as written, at the time of starring. */
  text: string;
  /** The preview window, lead-in already applied. */
  from: number;
  to: number;
  /** The query that found it. */
  q: string;
  conf: number | null;
  suspect: boolean;
  note?: string;
  at: string;
};

export type Shortlist = {
  slug: string;
  name: string;
  created: string;
  updated: string;
  note?: string;
  /**
   * ORDER IS THE EDIT. An array, never a Set and never a Record -- the sequence
   * IS the thing being authored, and any container that does not preserve it
   * throws away the only decision this tool exists to record.
   */
  picks: Pick[];
};

export type ShortlistFile = { version: 1; lists: Record<string, Shortlist> };

export type ShortlistSummary = {
  slug: string;
  name: string;
  picks: number;
  updated: string;
  note?: string;
};

// ---------------------------------------------------------------------------
// Ops.
// ---------------------------------------------------------------------------

export type ShortlistBody =
  | { op: "create"; name: string; note?: string }
  | { op: "add"; list: string; pick: Pick }
  | { op: "remove"; list: string; id: string }
  | { op: "note"; list: string; id?: string; note: string }
  /**
   * A WHOLE PERMUTATION of the list's current ids, not an index move.
   *
   * Atomic and idempotent: the client sends the order it believes in and either
   * gets it or gets a 400, where a stream of "move item 3 up" messages against
   * a list two tabs are editing produces an order neither of them asked for.
   * A non-permutation -- a missing id, an unknown one, a duplicate -- is a
   * disagreement about what the list HOLDS, so it is rejected rather than
   * reconciled.
   */
  | { op: "reorder"; list: string; ids: string[] }
  | { op: "rename"; list: string; name: string }
  | { op: "delete"; list: string };

export const HIT_ID = /^[\w-]+#\d+$/;

const str = (v: unknown): v is string => typeof v === "string";
const fin = (v: unknown): v is number => typeof v === "number" && Number.isFinite(v);

export function isPick(v: unknown): v is Pick {
  if (!v || typeof v !== "object") return false;
  const p = v as Record<string, unknown>;
  return (
    str(p.id) &&
    HIT_ID.test(p.id) &&
    str(p.video) &&
    p.video.length > 0 &&
    fin(p.i) &&
    fin(p.start) &&
    fin(p.end) &&
    fin(p.from) &&
    fin(p.to) &&
    str(p.text) &&
    str(p.q) &&
    (p.conf === null || fin(p.conf)) &&
    typeof p.suspect === "boolean" &&
    (p.note === undefined || str(p.note))
  );
}

export function isShortlistBody(v: unknown): v is ShortlistBody {
  if (!v || typeof v !== "object") return false;
  const b = v as Record<string, unknown>;
  const list = str(b.list) && b.list.length > 0;
  switch (b.op) {
    case "create":
      return str(b.name) && b.name.trim().length > 0 && (b.note === undefined || str(b.note));
    case "add":
      return list && isPick(b.pick);
    case "remove":
      return list && str(b.id) && HIT_ID.test(b.id);
    case "note":
      return list && str(b.note) && (b.id === undefined || (str(b.id) && HIT_ID.test(b.id)));
    case "reorder":
      return list && Array.isArray(b.ids) && b.ids.every((x) => str(x) && HIT_ID.test(x));
    case "rename":
      return list && str(b.name) && b.name.trim().length > 0;
    case "delete":
      return list;
    default:
      return false;
  }
}

/** A name to a key. Stable, lowercase, and safe in a URL and a filename alike. */
export function slugify(name: string): string {
  return name
    .toLowerCase()
    .normalize("NFD")
    .replace(/[\u0300-\u036f]/g, "")
    .replace(/[^a-z0-9]+/g, "-")
    .replace(/^-+|-+$/g, "")
    .slice(0, SLUG_LIMIT)
    .replace(/-+$/, "");
}