brackt/app/lib/draft-timer.ts

/**
 * Pure utility functions for the draft clock/timer system.
 * Extracted here to be independently testable and shared across
 * route handlers and UI components.
 *
 * Clock model (chess-clock / Fischer increment):
 *   - Draft start: every team receives `initialTime` as their bank.
 *   - While on the clock: the active team's bank counts down each second.
 *   - After a pick is made: the picker's bank += `incrementTime`.
 *   - Between turns: all other teams' banks are left untouched.
 */

/**
 * Formats a HH:MM time string as 12-hour time with AM/PM.
 * e.g. "23:00" → "11:00 PM", "07:30" → "7:30 AM"
 */
export function formatTime12h(t: string): string {
  const [h, m] = t.split(":").map(Number);
  const ap = (h || 0) >= 12 ? "PM" : "AM";
  return `${(h || 0) % 12 || 12}:${String(m || 0).padStart(2, "0")} ${ap}`;
}

/**
 * Formats a seconds value for display.
 *   undefined  → "--:--"
 *   < 3600 s   → "m:ss"
 *   >= 3600 s  → "h:mm:ss"
 */
export function formatClockTime(seconds: number | undefined): string {
  if (seconds === undefined) return "--:--";
  const clamped = Math.max(0, seconds); // guard against negative values from timer drift
  const h = Math.floor(clamped / 3600);
  const m = Math.floor((clamped % 3600) / 60);
  const s = clamped % 60;
  if (h > 0)
    return `${h}:${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}`;
  return `${m}:${String(s).padStart(2, "0")}`;
}

/**
 * Returns a team's new bank time after they complete a pick.
 * The increment is the post-pick reward (chess clock model).
 *
 * @param bankTime    Current remaining seconds in the team's bank
 * @param incrementTime  Bonus seconds awarded after each pick
 */
export function calculateTimeAfterPick(
  bankTime: number,
  incrementTime: number
): number {
  return bankTime + incrementTime;
}

/** Pure preset data for chess-clock mode — the single source of truth shared with DraftSpeedPicker. */
export const CHESS_CLOCK_PRESETS: { value: string; bankSec: number; incrSec: number }[] = [
  { value: "fast",      bankSec: 60,    incrSec: 10   },
  { value: "standard",  bankSec: 120,   incrSec: 15   },
  { value: "slow",      bankSec: 28800, incrSec: 3600 },
  { value: "very-slow", bankSec: 43200, incrSec: 3600 },
];

/**
 * Converts a draftSpeed form value + timerMode into DB time fields.
 *
 * Standard mode: speed is raw seconds (the per-pick time); both fields equal it.
 * Chess clock mode: speed is a named preset that maps to (initial bank, increment).
 */
export function parseDraftSpeed(
  draftSpeed: string | null,
  draftTimerMode: "chess_clock" | "standard"
): { draftInitialTime: number; draftIncrementTime: number } {
  if (draftTimerMode === "standard") {
    const seconds = parseInt(draftSpeed ?? "", 10);
    const time = isNaN(seconds) ? 90 : seconds;
    return { draftInitialTime: time, draftIncrementTime: time };
  }

  if (draftSpeed?.startsWith("custom:")) {
    const [, bankStr, incrStr] = draftSpeed.split(":");
    const bank = parseInt(bankStr ?? "", 10);
    const incr = parseInt(incrStr ?? "", 10);
    if (!isNaN(bank) && !isNaN(incr)) return { draftInitialTime: bank, draftIncrementTime: incr };
  }

  const preset = CHESS_CLOCK_PRESETS.find((p) => p.value === draftSpeed);
  if (preset) return { draftInitialTime: preset.bankSec, draftIncrementTime: preset.incrSec };

  // Unknown/null speed — fall back to "standard" preset
  return { draftInitialTime: 120, draftIncrementTime: 15 };
}

type DraftSpeedSource = {
  draftTimerMode?: "chess_clock" | "standard" | null;
  draftInitialTime?: number | null;
  draftIncrementTime?: number | null;
} | null | undefined;

/**
 * Derives the draftSpeed UI value (preset key or "custom:{bank}:{incr}") from
 * saved DB fields. Used to initialise and reset the DraftSpeedPicker.
 */
export function getInitialDraftSpeed(season: DraftSpeedSource): string {
  const mode = season?.draftTimerMode ?? "chess_clock";
  if (mode === "standard") return season?.draftIncrementTime?.toString() ?? "90";
  const preset = CHESS_CLOCK_PRESETS.find(
    (p) => p.bankSec === season?.draftInitialTime && p.incrSec === season?.draftIncrementTime
  );
  if (preset) return preset.value;
  if (season?.draftInitialTime !== null && season?.draftInitialTime !== undefined &&
      season?.draftIncrementTime !== null && season?.draftIncrementTime !== undefined) {
    return `custom:${season.draftInitialTime}:${season.draftIncrementTime}`;
  }
  return "standard";
}

/** Converts a millisecond duration to whole seconds, always rounding up. */
export function msToSeconds(ms: number): number {
  return Math.max(0, Math.ceil(ms / 1000));
}

/**
 * Anchors a server-provided remaining-seconds value to the local client clock.
 * Use this everywhere we convert timeRemaining → an expiresAt timestamp so the
 * logic stays consistent across event handlers and initial state.
 */
export function clientExpiresAt(timeRemaining: number): number {
  return Date.now() + timeRemaining * 1000;
}

/**
 * Returns the Tailwind colour class(es) for a timer value.
 *
 *   > 60 s   → green  (plenty of time)
 *   > 30 s   → amber  (getting tight)
 *   > 10 s   → coral  (urgent)
 *   ≤ 10 s   → coral + animate-pulse  (critical)
 *   undefined → muted (clock not running)
 */
export function getTimerColorClass(seconds: number | undefined): string {
  if (seconds === undefined) return "text-muted-foreground";
  if (seconds > 60) return "text-emerald-400";
  if (seconds > 30) return "text-amber-accent";
  if (seconds > 10) return "text-coral-accent";
  return "text-coral-accent animate-pulse";
}