Satu Fail, Setiap Baris

// Pure fairness engine. No DB, no request context — fully unit-testable.
//
// Strategy: greedy chronological assignment. For each date, for each slot, pick
// the eligible candidate with the lowest fairness score. Fairness combines:
//   - cumulative load (heavy shifts weighted), carried across months via history
//   - a soft cross-month "skip a heavy shift the month after you did one" penalty
//   - a seeded RNG tie-break so identical inputs always yield identical output
//
// HARD filters (R16): unavailability (per-date or leave-range) AND having worked
// the previous calendar day — a 48h no-sleep stretch is a safety issue, never a
// trade-off. If a slot's whole pool is filtered out, the slot is left empty and
// recorded as a conflict for the manager to resolve.
//
// R16 also adds a monthly duty cap (config.maxDutiesPerMonth — relaxed with a
// note when it would leave a day uncovered) and long-leave credit
// (config.leaveCreditMinDays — see leaveCredits()), so returning from maternity
// or a long course is not "repaid" with a catch-up pile-on.

import type {
  Assignment,
  HistoryEntry,
  HospitalConfig,
  MonthSchedule,
  Staff,
  Unavailability,
} from './types';

/** Deterministic PRNG (mulberry32) so tie-breaks are reproducible. */
function mulberry32(seed: number): () => number {
  let a = seed >>> 0;
  return () => {
    a |= 0;
    a = (a + 0x6d2b79f5) | 0;
    let t = Math.imul(a ^ (a >>> 15), 1 | a);
    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
  };
}

function pad(n: number): string {
  return n < 10 ? `0${n}` : String(n);
}

/** 'YYYY-MM-DD' for a given y/m(1-indexed)/d, computed without timezone drift. */
export function dateKey(year: number, month1: number, day: number): string {
  return `${year}-${pad(month1)}-${pad(day)}`;
}

/** Days in a 1-indexed month. */
export function daysInMonth(year: number, month1: number): number {
  return new Date(Date.UTC(year, month1, 0)).getUTCDate();
}

/** Day of week (0=Sun..6=Sat) for a 1-indexed month date. */
export function dayOfWeek(year: number, month1: number, day: number): number {
  return new Date(Date.UTC(year, month1 - 1, day)).getUTCDay();
}

/** The 'YYYY-MM' string of the month immediately before the given one. */
function prevMonthPrefix(year: number, month1: number): string {
  const m = month1 - 1;
  return m === 0 ? `${year - 1}-12` : `${year}-${pad(m)}`;
}

/** Is staff `id` unavailable on `date`? (date-block or leave-range covers it.) */
export function isUnavailable(
  unavail: Unavailability[],
  staffId: string,
  date: string,
): boolean {
  for (const u of unavail) {
    if (u.staffId !== staffId) continue;
    if (u.kind === 'date' && u.date === date) return true;
    if (u.kind === 'range' && date >= u.from && date <= u.to) return true;
  }
  return false;
}

/**
 * One concrete slot to fill on a given day. Per-team (2nd-call) slots expand into
 * several of these — one per covering team — each with its own `${key}:${team}` id.
 */
/**
 * How a concrete slot picks its assignee:
 * - fairness: lowest-load eligible candidate (officer, DSA 2nd-call old path).
 * - fixed: a constant assignee, no scoring (the 2nd-call specialist).
 * - sequence: giliran tetap harian — deterministic daily cycle from an anchor.
 * - weeklySequence: giliran tetap mingguan — deterministic Mon–Sun block cycle.
 */
type SlotMode = 'fairness' | 'fixed' | 'sequence' | 'weeklySequence';

interface EffectiveSlot {
  /** Per-team slots carry `${slotKey}:${team}`; others just `slotKey`. */
  key: string;
  groups: string[];
  mode: SlotMode;
  team?: string;
  /** sequence: the anchor date · weeklySequence: the anchor Monday. */
  anchorDate?: string;
  /** Cycle index occupied by the anchor date/week. */
  anchorIndex?: number;
}

/**
 * Expand a config's slots into the concrete slots to fill for one day-of-week.
 * `poolByDow`/`groups`/`sequence` → one slot; `teamGroups`/`fixed`/`weeklySequence`
 * → one slot per covering team. `selfPick` emits NOTHING (staff claim it later).
 */
function effectiveSlotsFor(config: HospitalConfig, dow: number): EffectiveSlot[] {
  const out: EffectiveSlot[] = [];
  for (const slot of config.slots) {
    const src = slot.source;
    if (src.kind === 'poolByDow') {
      out.push({ key: slot.key, groups: src.poolByDow[dow] ?? [], mode: 'fairness' });
    } else if (src.kind === 'groups') {
      out.push({ key: slot.key, groups: src.groups, mode: 'fairness' });
    } else if (src.kind === 'selfPick') {
      continue; // pilih sendiri — engine leaves it empty; no slot emitted.
    } else if (src.kind === 'sequence') {
      out.push({
        key: slot.key, groups: [src.group], mode: 'sequence',
        anchorDate: src.anchorDate, anchorIndex: src.anchorIndex,
      });
    } else if (src.kind === 'weeklySequence') {
      // 2nd-call: every covering team's slot is filled every day — the team that
      // actually handles a case is decided at CALL TIME by case type (adult →
      // OMFS, child → Paeds), not by which team's day this is. See HSR_CONFIG note.
      for (const team of Object.keys(src.teamGroups)) {
        const groups = src.teamGroups[team];
        if (!groups || groups.length === 0) continue;
        out.push({
          key: `${slot.key}:${team}`, groups, mode: 'weeklySequence', team,
          anchorDate: src.anchorMonday, anchorIndex: src.anchorIndex[team] ?? 0,
        });
      }
    } else {
      // teamGroups | fixed — same "every team, every day" rule as weeklySequence.
      for (const team of Object.keys(src.teamGroups)) {
        const groups = src.teamGroups[team];
        if (!groups || groups.length === 0) continue;
        out.push({
          key: `${slot.key}:${team}`, groups,
          mode: src.kind === 'fixed' ? 'fixed' : 'fairness', team,
        });
      }
    }
  }
  return out;
}

/** Staff in any of `groups`. */
function inGroups(staff: Staff[], groups: string[]): Staff[] {
  const set = new Set(groups);
  return staff.filter((s) => set.has(s.group));
}

interface LoadState {
  /** weighted load per (slot|staffId): heavy*heavyWeight + light. */
  load: Map<string, number>;
  /** staffIds who had a heavy shift in the immediately previous month. */
  heavyLastMonth: Set<string>;
  /** date(YYYY-MM-DD) → set of staffIds working any slot that day. */
  byDate: Map<string, Set<string>>;
  /**
   * staffId → number of heavy (weekend/24h) shifts assigned THIS month so far.
   * Drives the heavy-spread penalty so weekend burden is shared evenly; starts
   * at 0 each generation (cross-month fairness is handled by heavyLastMonth).
   */
  heavyCount: Map<string, number>;
  /** staffId → fairness-slot duties assigned THIS month (drives maxDutiesPerMonth). */
  dutiesThisMonth: Map<string, number>;
  /** staffId → public holidays worked THIS calendar year (drives holidaySpreadPenalty). */
  phThisYear: Map<string, number>;
}

function loadKey(slot: string, staffId: string): string {
  return `${slot}|${staffId}`;
}

/** Seed load + last-month-heavy state from prior published history. */
function initLoad(
  config: HospitalConfig,
  history: HistoryEntry[],
  year: number,
  month1: number,
): LoadState {
  const load = new Map<string, number>();
  const heavyLastMonth = new Set<string>();
  const byDate = new Map<string, Set<string>>();
  const phThisYear = new Map<string, number>();
  const prev = prevMonthPrefix(year, month1);
  const yearPrefix = `${year}-`;
  for (const h of history) {
    const w = h.heavy ? config.weights.heavyWeight : 1;
    const k = loadKey(h.slot, h.staffId);
    load.set(k, (load.get(k) ?? 0) + w);
    if (h.heavy && h.date.startsWith(prev)) heavyLastMonth.add(h.staffId);
    if (h.date.startsWith(yearPrefix) && h.date in config.holidays) {
      phThisYear.set(h.staffId, (phThisYear.get(h.staffId) ?? 0) + 1);
    }
    let set = byDate.get(h.date);
    if (!set) byDate.set(h.date, (set = new Set()));
    set.add(h.staffId);
  }
  return { load, heavyLastMonth, byDate, heavyCount: new Map(), dutiesThisMonth: new Map(), phThisYear };
}

/**
 * R16 — kredit cuti panjang. For every history month in which a staff member was
 * recorded unavailable for at least `config.leaveCreditMinDays` days, credit them
 * the average weighted markah their PRESENT group-mates earned that month, per
 * slot. Leave is not a debt: without this, someone returning from maternity (or a
 * long course) carries near-zero load and the greedy engine piles duties on them
 * until they "catch up" — e.g. 10 duties in their first month back.
 * Returns loadKey(slot, staffId) → credit, merged into the load state at generate.
 */
/** Weighted markah earned per history month: month('YYYY-MM') → loadKey → markah. */
function monthlyLoads(config: HospitalConfig, history: HistoryEntry[]): Map<string, Map<string, number>> {
  const monthLoads = new Map<string, Map<string, number>>();
  for (const h of history) {
    const month = h.date.slice(0, 7);
    let slotMap = monthLoads.get(month);
    if (!slotMap) monthLoads.set(month, (slotMap = new Map()));
    const k = loadKey(h.slot, h.staffId);
    slotMap.set(k, (slotMap.get(k) ?? 0) + (h.heavy ? config.weights.heavyWeight : 1));
  }
  return monthLoads;
}

export function leaveCredits(
  config: HospitalConfig,
  staff: Staff[],
  history: HistoryEntry[],
  unavail: Unavailability[],
): Map<string, number> {
  const credits = new Map<string, number>();
  const minDays = config.leaveCreditMinDays;
  if (minDays === undefined || history.length === 0) return credits;

  const monthLoads = monthlyLoads(config, history);
  const groupOf = new Map(staff.map((s) => [s.id, s.group]));
  for (const [month, slotMap] of monthLoads) {
    const [y, m1] = month.split('-').map(Number);
    const total = daysInMonth(y, m1);
    const onLeave = new Set<string>();
    for (const s of staff) {
      let blocked = 0;
      for (let d = 1; d <= total; d++) {
        if (isUnavailable(unavail, s.id, dateKey(y, m1, d))) blocked++;
      }
      if (blocked >= minDays) onLeave.add(s.id);
    }
    if (onLeave.size === 0) continue;

    const presentCount = new Map<string, number>();
    for (const s of staff) {
      if (!onLeave.has(s.id)) presentCount.set(s.group, (presentCount.get(s.group) ?? 0) + 1);
    }
    // Markah earned that month per (slot, group) by present members. Group
    // membership IS pool membership for fairness slots, so the group average is
    // exactly "what an average available colleague carried".
    const slotGroupSum = new Map<string, number>();
    for (const [k, earned] of slotMap) {
      const [slot, staffId] = k.split('|');
      const group = groupOf.get(staffId);
      if (!group || onLeave.has(staffId)) continue;
      const sg = `${slot}|${group}`;
      slotGroupSum.set(sg, (slotGroupSum.get(sg) ?? 0) + earned);
    }
    for (const s of staff) {
      if (!onLeave.has(s.id)) continue;
      const present = presentCount.get(s.group) ?? 0;
      if (present === 0) continue;
      for (const [sg, sum] of slotGroupSum) {
        const [slot, group] = sg.split('|');
        if (group !== s.group) continue;
        const k = loadKey(slot, s.id);
        credits.set(k, (credits.get(k) ?? 0) + sum / present);
      }
    }
  }
  return credits;
}

/**
 * R20-C — new-joiner fairness seed. For every history month that ended wholly
 * before a staff member's joinedAt, credit them the average weighted markah
 * their group-mates earned that month, per slot (same mechanism as
 * leaveCredits). Without it a newcomer carries zero load and the greedy engine
 * gives them the monthly cap every month until they "catch up" — joining late
 * is not a debt. Joining mid-month counts as present for that month (no credit).
 */
export function newJoinerCredits(
  config: HospitalConfig,
  staff: Staff[],
  history: HistoryEntry[],
): Map<string, number> {
  const credits = new Map<string, number>();
  if (history.length === 0 || !staff.some((s) => s.joinedAt)) return credits;

  const monthLoads = monthlyLoads(config, history);
  const groupOf = new Map(staff.map((s) => [s.id, s.group]));
  for (const [month, slotMap] of monthLoads) {
    // Pre-membership = joined in a LATER month than this history month.
    const preMember = new Set(
      staff.filter((s) => s.joinedAt && s.joinedAt.slice(0, 7) > month).map((s) => s.id),
    );
    if (preMember.size === 0) continue;

    const presentCount = new Map<string, number>();
    for (const s of staff) {
      if (!preMember.has(s.id)) presentCount.set(s.group, (presentCount.get(s.group) ?? 0) + 1);
    }
    const slotGroupSum = new Map<string, number>();
    for (const [k, earned] of slotMap) {
      const [slot, staffId] = k.split('|');
      const group = groupOf.get(staffId);
      if (!group || preMember.has(staffId)) continue;
      const sg = `${slot}|${group}`;
      slotGroupSum.set(sg, (slotGroupSum.get(sg) ?? 0) + earned);
    }
    for (const s of staff) {
      if (!preMember.has(s.id)) continue;
      const present = presentCount.get(s.group) ?? 0;
      if (present === 0) continue;
      for (const [sg, sum] of slotGroupSum) {
        const [slot, group] = sg.split('|');
        if (group !== s.group) continue;
        const k = loadKey(slot, s.id);
        credits.set(k, (credits.get(k) ?? 0) + sum / present);
      }
    }
  }
  return credits;
}

/** Shift the calendar date by `delta` days, returning a 'YYYY-MM-DD' key. */
function shiftDate(date: string, delta: number): string {
  const [y, m, d] = date.split('-').map(Number);
  const dt = new Date(Date.UTC(y, m - 1, d + delta));
  return `${dt.getUTCFullYear()}-${pad(dt.getUTCMonth() + 1)}-${pad(dt.getUTCDate())}`;
}

/** Whole calendar days from `from` to `to` (signed; to − from). Both 'YYYY-MM-DD'. */
function daysBetween(from: string, to: string): number {
  const [fy, fm, fd] = from.split('-').map(Number);
  const [ty, tm, td] = to.split('-').map(Number);
  return Math.round((Date.UTC(ty, tm - 1, td) - Date.UTC(fy, fm - 1, fd)) / 86_400_000);
}

/** The Monday (ISO week start) of the week containing `date`, as 'YYYY-MM-DD'. */
function mondayOf(date: string): string {
  const [y, m, d] = date.split('-').map(Number);
  const dow = new Date(Date.UTC(y, m - 1, d)).getUTCDay(); // 0=Sun..6=Sat
  return shiftDate(date, dow === 0 ? -6 : 1 - dow);        // Sun→prev Mon, else back to Mon
}

/** True modulo (always 0..m-1, even for negative n) — anchors may precede `date`. */
function trueMod(n: number, m: number): number {
  return ((n % m) + m) % m;
}

/** Order a group's pool by its cycle position (sortOrder), id as a stable tie-break. */
function byCycle(pool: Staff[]): Staff[] {
  return [...pool].sort(
    (a, b) => (a.sortOrder ?? 0) - (b.sortOrder ?? 0) || a.id.localeCompare(b.id),
  );
}

/**
 * Generate one month's schedule.
 * @param month1 1-indexed month (1=Jan..12=Dec).
 * @param seed   any integer; same inputs + seed ⇒ identical output.
 */
export function generateMonth(
  config: HospitalConfig,
  staff: Staff[],
  history: HistoryEntry[],
  unavail: Unavailability[],
  year: number,
  month1: number,
  seed = 1,
): MonthSchedule {
  const rng = mulberry32(seed);
  const state = initLoad(config, history, year, month1);
  for (const [k, credit] of leaveCredits(config, staff, history, unavail)) {
    state.load.set(k, (state.load.get(k) ?? 0) + credit);
  }
  for (const [k, credit] of newJoinerCredits(config, staff, history)) {
    state.load.set(k, (state.load.get(k) ?? 0) + credit);
  }
  const assignments: Assignment[] = [];
  const conflicts: { date: string; slot: string; reason: string }[] = [];
  const total = daysInMonth(year, month1);

  for (let day = 1; day <= total; day++) {
    const date = dateKey(year, month1, day);
    const dow = dayOfWeek(year, month1, day);
    const isHoliday = date in config.holidays;
    const heavy = config.weekendDows.includes(dow) || isHoliday;
    const todaysAssigned = state.byDate.get(date) ?? new Set<string>();
    state.byDate.set(date, todaysAssigned);
    const prevDate = shiftDate(date, -1);
    const prevAssigned = state.byDate.get(prevDate) ?? new Set<string>();

    for (const es of effectiveSlotsFor(config, dow)) {
      // Giliran tetap (sequence / weeklySequence): the assignee is pure maths from
      // an anchor, ordered by sortOrder. NO unavailability skipping and NO fairness
      // — predictability is the whole point; a clash is resolved by a swap, not by
      // the engine silently picking someone else.
      if (es.mode === 'sequence' || es.mode === 'weeklySequence') {
        const cycle = byCycle(inGroups(staff, es.groups));
        if (cycle.length === 0) {
          const why = 'Tiada staf dalam pool untuk slot ini pada hari ini.';
          assignments.push({ date, slot: es.key, staffId: null, heavy, reason: why, team: es.team });
          conflicts.push({ date, slot: es.key, reason: why });
          continue;
        }
        const steps =
          es.mode === 'sequence'
            ? daysBetween(es.anchorDate!, date)
            : Math.round(daysBetween(es.anchorDate!, mondayOf(date)) / 7);
        const chosen = cycle[trueMod((es.anchorIndex ?? 0) + steps, cycle.length)];
        todaysAssigned.add(chosen.id);
        assignments.push({
          date, slot: es.key, staffId: chosen.id, heavy,
          reason: `${chosen.name}: giliran tetap${heavy ? ' (24j)' : ''}`,
          team: es.team,
        });
        continue;
      }

      const pool = inGroups(staff, es.groups);
      const eligible = pool.filter(
        (s) => !isUnavailable(unavail, s.id, date) && !todaysAssigned.has(s.id),
      );

      if (eligible.length === 0) {
        const why =
          pool.length === 0
            ? 'Tiada staf dalam pool untuk slot ini pada hari ini.'
            : 'Semua calon tidak tersedia (cuti / sudah bertugas hari ini).';
        assignments.push({ date, slot: es.key, staffId: null, heavy, reason: why, team: es.team });
        conflicts.push({ date, slot: es.key, reason: why });
        continue;
      }

      // Fixed specialist: constant assignee, no fairness scoring and no load
      // accumulation — pick deterministically by id so output is reproducible.
      if (es.mode === 'fixed') {
        const chosen = [...eligible].sort((a, b) => a.id.localeCompare(b.id))[0];
        todaysAssigned.add(chosen.id);
        assignments.push({
          date,
          slot: es.key,
          staffId: chosen.id,
          heavy,
          reason: `${chosen.name}: pakar tetap${heavy ? ' (24j)' : ''}`,
          team: es.team,
        });
        continue;
      }

      // R16 hard rule — tiada hari berturut. Working yesterday (any slot) is a
      // hard filter for fairness slots: 48h without sleep is a safety issue, not
      // a preference. An empty pool here becomes a manager-visible gap — the
      // engine never trades sleep for coverage.
      const rested = eligible.filter((s) => !prevAssigned.has(s.id));
      if (rested.length === 0) {
        const why = 'Semua calon bertugas semalam — peraturan tiada hari berturut.';
        assignments.push({ date, slot: es.key, staffId: null, heavy, reason: why, team: es.team });
        conflicts.push({ date, slot: es.key, reason: why });
        continue;
      }

      // R16 — had bulanan. Coverage beats the cap: when every rested candidate
      // is already at it, relax with a note instead of leaving the day empty.
      let candidates = rested;
      let capNote = '';
      if (config.maxDutiesPerMonth !== undefined) {
        const underCap = rested.filter(
          (s) => (state.dutiesThisMonth.get(s.id) ?? 0) < config.maxDutiesPerMonth!,
        );
        if (underCap.length > 0) candidates = underCap;
        else capNote = ', melebihi had bulanan (tiada calon lain)';
      }

      let best: Staff | null = null;
      let bestScore = Infinity;
      let bestNote = '';
      for (const cand of candidates) {
        const base = state.load.get(loadKey(es.key, cand.id)) ?? 0;
        let score = base;
        const notes: string[] = [`beban=${base.toFixed(0)}`];
        if (isHoliday && config.weights.holidaySpreadPenalty !== undefined) {
          // R17: the next PH goes to whoever has done the fewest PHs this
          // calendar year. Outranks the within-month heavy spread below.
          const phCount = state.phThisYear.get(cand.id) ?? 0;
          if (phCount > 0) {
            score += phCount * config.weights.holidaySpreadPenalty;
            notes.push('agih cuti umum setahun');
          }
        }
        if (heavy) {
          // Share weekends evenly: anyone who already has a heavy shift this month
          // is pushed far down the list, so the next weekend goes to someone with
          // none until everyone has had one. Dominates ordinary load differences.
          const hc = state.heavyCount.get(cand.id) ?? 0;
          if (hc > 0) {
            score += hc * config.weights.heavySpreadPenalty;
            notes.push('agih hujung-minggu rata');
          }
        }
        if (heavy && state.heavyLastMonth.has(cand.id)) {
          score += config.weights.skipWeekendPenalty;
          notes.push('elak ulang hujung-minggu');
        }
        score += rng() * 0.001; // deterministic tie-break, never overrides real signal
        if (score < bestScore) {
          best = cand;
          bestScore = score;
          bestNote = notes.join(', ');
        }
      }

      // best is non-null: candidates.length > 0 guaranteed a candidate above.
      const chosen = best as Staff;
      const k = loadKey(es.key, chosen.id);
      state.load.set(k, (state.load.get(k) ?? 0) + (heavy ? config.weights.heavyWeight : 1));
      if (heavy) state.heavyCount.set(chosen.id, (state.heavyCount.get(chosen.id) ?? 0) + 1);
      if (isHoliday) state.phThisYear.set(chosen.id, (state.phThisYear.get(chosen.id) ?? 0) + 1);
      state.dutiesThisMonth.set(chosen.id, (state.dutiesThisMonth.get(chosen.id) ?? 0) + 1);
      todaysAssigned.add(chosen.id);
      assignments.push({
        date,
        slot: es.key,
        staffId: chosen.id,
        heavy,
        reason: `${chosen.name}: ${bestNote}${capNote}${heavy ? ' (24j)' : ''}`,
        team: es.team,
      });

      // KPSR / KPTM officer day: the unit covers, but the actual doctor on call is
      // chosen by that unit. Emit an EMPTY `primer_doctor:<unit>` slot for the day so
      // the unit's doctor can self-fill it later. Not a conflict — an expected blank.
      if (chosen.group === 'primer') {
        const unit = chosen.name.toLowerCase(); // 'kpsr' | 'kptm' → matches kpsr_doctor/kptm_doctor
        assignments.push({
          date,
          slot: `primer_doctor:${unit}`,
          staffId: null,
          heavy,
          reason: `Doktor unit ${chosen.name} akan pilih sendiri.`,
          team: unit,
        });
      }
    }

  }

  return { hospitalId: config.hospitalId, year, month: month1, assignments, conflicts };
}

/** Per-(slot,staff) tally for the fairness dashboard / "Kiraan Tugas". */
export function tally(schedule: MonthSchedule): Record<string, { heavy: number; light: number }> {
  const out: Record<string, { heavy: number; light: number }> = {};
  for (const a of schedule.assignments) {
    if (!a.staffId) continue;
    const k = loadKey(a.slot, a.staffId);
    const t = (out[k] ??= { heavy: 0, light: 0 });
    if (a.heavy) t.heavy++;
    else t.light++;
  }
  return out;
}