schedule.ts

/*
 * The drip / unlock engine.
 *
 * This is the thing that makes the app an *ongoing class* rather than a video
 * dump, and it is deliberately pure: every function here takes the demo clock
 * as an argument and returns a value. Nothing reads `Date.now()`.
 *
 * Why the demo clock is not the real clock
 * ----------------------------------------
 * If locks were computed from the wall clock, the demo would look different
 * every week and be un-testable. Instead the cohort's week 1 is pinned to
 * Monday 20 July 2026 (`COHORT_WEEK_ONE`) and the store holds a `week` number
 * from 1 to 8. The dock's "Advance one week" / "Reset to week 1" buttons move
 * it, so the drip is visible inside a 60-second demo and identical on every
 * machine.
 *
 * The rule, in full:
 *   • Self-paced mode: nothing is ever locked.
 *   • Cohort mode: a module is locked while its `week` is past the demo
 *     clock's current week. Its lessons inherit that lock and render with the
 *     unlock date ("Unlocks Mon 3 Aug").
 *
 * A lesson marked `preview` would be open before enrolment; the seeded
 * curriculum marks previews on the course sales page rather than on the
 * lesson record, so `isPreviewLesson` reads the index and is exported for the
 * course page to use.
 */

import { COHORT_WEEK_ONE, COHORT_WEEKS, MODULES, TOTAL_LESSONS } from "../data/demo";
import type { CourseMode, FlatLesson, Module } from "../data/types";
import { locale, number as fmtNumber, t } from "../i18n/ambient";

/* ------------------------------------------------------ Intl plumbing --- */

/*
 * Every label below used to be assembled from hardcoded `DAYS` / `MONTHS`
 * arrays and `String.padStart`, which produced US English on a Cairo screen.
 * They now go through `Intl`, bound to whatever locale the provider is
 * rendering (the ambient bridge, since these are pure functions the tests call
 * with no React mounted).
 *
 * Note what did NOT change: the demo clock. `weekStart` / `demoNow` /
 * `liveDate` still pin the cohort to Monday 20 July 2026 and still never read
 * `Date.now()`. Only the rendering of those instants is locale-aware — the
 * instants themselves are the drip system's fixed points.
 *
 * The formatters are cached per locale + options: `countdown` and the lesson
 * player run once a second, and constructing an `Intl.DateTimeFormat` is by
 * far the most expensive thing in this file.
 */
const DTF_CACHE = new Map<string, Intl.DateTimeFormat>();
const NF_CACHE = new Map<string, Intl.NumberFormat>();

function dtf(opts: Intl.DateTimeFormatOptions): Intl.DateTimeFormat {
  const key = `${locale()}${JSON.stringify(opts)}`;
  let f = DTF_CACHE.get(key);
  if (!f) {
    f = new Intl.DateTimeFormat(locale(), opts);
    DTF_CACHE.set(key, f);
  }
  return f;
}

function nf(opts: Intl.NumberFormatOptions): Intl.NumberFormat {
  const key = `${locale()}${JSON.stringify(opts)}`;
  let f = NF_CACHE.get(key);
  if (!f) {
    f = new Intl.NumberFormat(locale(), opts);
    NF_CACHE.set(key, f);
  }
  return f;
}

/** A zero-padded clock digit pair — "07", and "٠٧" in Arabic. */
function pad2(n: number): string {
  return nf({ minimumIntegerDigits: 2, useGrouping: false }).format(n);
}

/** "2d" / "04h" — CLDR's own narrow unit, not a hardcoded English letter. */
function unit(n: number, u: string, pad = true): string {
  return nf({
    style: "unit",
    unit: u,
    unitDisplay: "narrow",
    useGrouping: false,
    ...(pad ? { minimumIntegerDigits: 2 } : {}),
  }).format(n);
}

/* ------------------------------------------------------------ the clock */

/** The Monday that starts cohort week `n` (1-based). */
export function weekStart(n: number): Date {
  const d = new Date(COHORT_WEEK_ONE.year, COHORT_WEEK_ONE.month, COHORT_WEEK_ONE.day);
  d.setDate(d.getDate() + 7 * (Math.max(1, n) - 1));
  return d;
}

export function addDays(d: Date, n: number): Date {
  const x = new Date(d.getTime());
  x.setDate(x.getDate() + n);
  return x;
}

export function addMinutes(d: Date, n: number): Date {
  return new Date(d.getTime() + n * 60_000);
}

/**
 * The last minute of a day — 23:59.
 *
 * A deadline is an instant, not the string "23:59": pinning it to a `Date`
 * lets `fmtTime` print "11:59 PM" for a US reader and "23:59" for a German
 * one, from the same moment.
 */
export function endOfDay(d: Date): Date {
  const x = new Date(d.getTime());
  x.setHours(23, 59, 0, 0);
  return x;
}

/**
 * "Now" on the demo clock: Tuesday of the current week at 10:20.
 *
 * Mid-week on purpose — week 3's lessons are open, week 3's assignment is not
 * yet overdue, and Thursday's live session is still ahead.
 */
export function demoNow(week: number): Date {
  const d = weekStart(week);
  d.setDate(d.getDate() + 1);
  d.setHours(10, 20, 0, 0);
  return d;
}

/** The scheduled live session for the current week. */
export function liveDate(week: number, dayOffset = 3, hour = 18): Date {
  const d = addDays(weekStart(week), dayOffset);
  d.setHours(hour, 0, 0, 0);
  return d;
}

/** The week-3 assignment deadline — fixed, so it can go overdue as time moves. */
export function dueDate(): Date {
  return addDays(weekStart(3), 4);
}

/* ---------------------------------------------------------- formatting */

/** "Mon" — the abbreviated weekday on its own. */
export function fmtWeekday(d: Date): string {
  return dtf({ weekday: "short" }).format(d);
}

/** "Monday" — the full weekday, for prose. */
export function fmtWeekdayLong(d: Date): string {
  return dtf({ weekday: "long" }).format(d);
}

/** Any Sunday, so a bare `Date.getDay()` index can be turned into a name. */
const WEEKDAY_ANCHOR = new Date(1970, 0, 4);

/**
 * "Tue" from a `Date.getDay()` index (0 = Sunday).
 *
 * The streak heat map has columns, not dates — it never holds a real instant —
 * so it gets the name from the anchor above rather than from a hardcoded
 * `["Sun", "Mon", …]` list that only ever spoke English.
 */
export function weekdayName(dayIndex: number): string {
  return fmtWeekday(addDays(WEEKDAY_ANCHOR, ((dayIndex % 7) + 7) % 7));
}

/** "Aug 3" — day and month, no weekday. */
export function fmtDayMonth(d: Date): string {
  return dtf({ day: "numeric", month: "short" }).format(d);
}

/** "Mon, Aug 3" (en-US) — the locale decides field order and separators. */
export function fmtDate(d: Date): string {
  return dtf({ weekday: "short", day: "numeric", month: "short" }).format(d);
}

/** "Mon, Aug 3, 2026" (en-US). */
export function fmtDateLong(d: Date): string {
  return dtf({ weekday: "short", day: "numeric", month: "short", year: "numeric" }).format(d);
}

/**
 * "6:00 PM" (en-US), "18:00" (de-DE), "٦:٠٠ م" (ar-EG).
 *
 * The 12-vs-24-hour choice is the locale's, not ours — which is exactly why
 * the screens no longer interpolate `${session.hour}:00` by hand.
 */
export function fmtTime(d: Date): string {
  return dtf({ hour: "numeric", minute: "2-digit" }).format(d);
}

/**
 * "Week 3 of 8 · Mon, Aug 3" — the dock's readout.
 *
 * The whole sentence is one message rather than three glued fragments: German
 * wants "Woche 3 von 8" and Arabic "الأسبوع ٣ من ٨", and neither survives being
 * assembled from an English word order here.
 */
export function clockLabel(week: number): string {
  return t("chrome.clock.readout", {
    week: fmtNumber(week),
    total: fmtNumber(COHORT_WEEKS),
    date: fmtDate(weekStart(week)),
  });
}

/**
 * A live countdown, formatted "2d 04h 31m 12s".
 *
 * `elapsed` is seconds since the app mounted; it is the only place a real
 * ticking clock leaks in, and it only ever makes the countdown run down.
 *
 * The unit letters come from CLDR's narrow forms rather than being spelled
 * out here, so German reads "04 Std." and Chinese "04小时" instead of a
 * hard-coded "h".
 */
export function countdown(week: number, elapsed: number): string {
  let ms = liveDate(week).getTime() - demoNow(week).getTime() - elapsed * 1000;
  if (ms < 0) ms = 0;
  const s = Math.floor(ms / 1000);
  const d = Math.floor(s / 86400);
  const h = Math.floor((s % 86400) / 3600);
  const m = Math.floor((s % 3600) / 60);
  const ss = s % 60;
  const head = d > 0 ? `${unit(d, "day", false)} ` : "";
  return `${head}${unit(h, "hour")} ${unit(m, "minute")} ${unit(ss, "second")}`;
}

/* -------------------------------------------------------------- the drip */

/** True when the app is running the dated-cohort story. */
export function isCohort(mode: CourseMode): boolean {
  return mode === "cohort";
}

/** A module is locked when its week is still ahead on the demo clock. */
export function isModuleLocked(m: Module, week: number, mode: CourseMode): boolean {
  return isCohort(mode) && m.week > week;
}

/** "Unlocks Mon 3 Aug" — the chip a locked row carries. */
export function unlockLabel(m: Module): string {
  return t("chrome.lesson.unlocks", { date: fmtDate(weekStart(m.week)) });
}

/** The two lessons the sales page opens before enrolment (the free preview). */
export function isPreviewLesson(lessonId: string): boolean {
  return lessonId === "L1" || lessonId === "L2";
}

/* ----------------------------------------------------------- curriculum */

/** Every lesson in order, each carrying its owning module. */
export function allLessons(): FlatLesson[] {
  const out: FlatLesson[] = [];
  for (const m of MODULES) {
    for (const l of m.lessons) out.push({ ...l, mod: m });
  }
  return out;
}

export function lessonById(id: string): FlatLesson | undefined {
  return allLessons().find((l) => l.id === id);
}

/** How many of the 22 lessons are ticked off. */
export function doneCount(done: Record<string, number>): number {
  return Object.keys(done).filter((k) => done[k]).length;
}

/** Course completion, 0–100. */
export function progressPct(done: Record<string, number>): number {
  return Math.round((doneCount(done) / TOTAL_LESSONS) * 100);
}

/**
 * Runtime of a lesson in seconds.
 *
 * Read straight off the seed's own number. It used to be recovered by parsing
 * `dur` as "mm:ss" — which worked only while `dur` was an English string, and
 * silently fell back to ten minutes for the readings written "9 min". Now that
 * `dur` is a localised getter there is nothing to parse, and a reading reports
 * its real length instead of the fallback.
 *
 * The fallback survives for a lesson that has no runtime at all: an assignment
 * is measured in points, and an unknown id has nothing to measure.
 */
export function lessonSeconds(id: string): number {
  return lessonById(id)?.secs ?? 600;
}

/* --------------------------------------------------------------- clocks */

/**
 * "04:32" — the player head and the exam timer.
 *
 * `:` is the universal digital-clock separator, but the DIGITS are the
 * locale's: an Arabic reader gets "٠٤:٣٢".
 */
export function mmss(seconds: number): string {
  const s = Math.max(0, Math.floor(seconds));
  return `${pad2(Math.floor(s / 60))}:${pad2(s % 60)}`;
}

/** "00:44:58" */
export function hhmmss(seconds: number): string {
  const s = Math.max(0, Math.floor(seconds));
  return [pad2(Math.floor(s / 3600)), pad2(Math.floor((s % 3600) / 60)), pad2(s % 60)].join(":");
}

/**
 * Where the player head sits, 0–1.
 *
 * Paused: whatever the user last scrubbed to. Playing: that anchor plus the
 * seconds elapsed since play was pressed, clamped at the end of the lesson.
 */
export function playheadPos(args: {
  playing: boolean;
  pos: number;
  lessonId: string;
  elapsed: number;
  playAnchor: number;
}): number {
  if (!args.playing) return args.pos;
  const dur = lessonSeconds(args.lessonId) || 600;
  return Math.min(1, args.pos + (args.elapsed - args.playAnchor) / dur);
}