import { isPracticeSessionType } from "./track_layouts_logic.js";
import { renderTrackLayoutBar, bindTrackLayoutBar } from "./track_layout_bar.js";
import { PROLOGUE_OPTIONS_SEC, formatPrologueOption } from "./prologue_logic.js";
import { estimateFinish } from "./timing_logic.js";
import { orderSessionsForRunning } from "./event_race_logic.js";
export function getRaceDayCheckAction(item, session) {
if (item.level === "ok") return null;
if (["backend", "decoder", "split_decoder", "pit_decoders", "audio"].includes(item.id)) {
return { view: "settings", settingsTab: item.id === "audio" ? "audio" : "connection", label: "nav.settings" };
}
if (item.id === "lap_window" && session?.mode === "race") {
return { field: "minLapSec", label: "race_day.lap_window_edit" };
}
if (item.id === "session") return { view: "timing", label: "nav.timing" };
if (["transponders", "duplicate_transponders"].includes(item.id) && session?.type !== "team_race") {
const view = session?.mode === "track" ? "cars" : "drivers";
return { view, label: "nav." + view };
}
if (["participants", "grid", "transponders", "duplicate_transponders", "duplicate_team_members", "lap_window"].includes(item.id)) {
const view = session?.mode === "track" ? "events" : "race_setup";
return { view, label: "nav." + view };
}
return null;
}
export function sortRaceDayChecks(checks) {
const priority = { error: 0, warning: 1, ok: 2 };
return [...checks].sort((a, b) => priority[a.level] - priority[b.level]);
}
function renderPreflightDetail(item, { t, formatLap, escapeHtml }) {
if (item.id === "lap_window") return `${formatLap(item.minLapMs || 0)} / ${formatLap(item.maxLapMs || 0)}`;
if (item.id === "participants") return item.openPractice ? t("race_day.open_practice_any") : t("race_day.count", { count: item.count || 0 });
if (item.id === "transponders") {
return item.openPractice ? t("race_day.open_practice_any") : item.missingCount
? t("race_day.missing_count", { count: item.missingCount })
: t("race_day.count", { count: item.count || 0 });
}
if (item.id === "duplicate_transponders" && item.duplicates?.length) return escapeHtml(item.duplicates.join(", "));
if (item.id === "duplicate_team_members" && item.duplicateTeamMemberNames?.length) return escapeHtml(item.duplicateTeamMemberNames.join(", "));
if (item.id === "transponder_check") return `${item.seen}/${item.total}`;
if (item.id === "decoder_clock") {
const amount = `${item.hours ? `${item.hours} h ` : ""}${item.minutes ? `${item.minutes} min` : ""}`.trim();
return t(item.ahead ? "race_day.decoder_clock_ahead" : "race_day.decoder_clock_behind", { amount });
}
if (item.id === "grid") return item.notRequired ? t("race_day.not_required") : `${item.count || 0}/${item.expectedCount || 0}`;
return t(`race_day.check_${item.level}`);
}
function renderQueueSession(session, positionKey, deps) {
const { t, escapeHtml, getEventName, getSessionTypeLabel, getStatusLabel } = deps;
if (!session) return `${t(positionKey)}${t("race_day.none")}`;
return `
${t(positionKey)}
${escapeHtml(session.name)}
${escapeHtml(getEventName(session.eventId))} · ${escapeHtml(getSessionTypeLabel(session.type))}
${escapeHtml(getStatusLabel(session.status))}
`;
}
// --- Prologue (count-down) and transponder check ---------------------------------------
// A race-format heat is started through a prologue (see prologue_logic.js): Start begins the
// count-down, and the check panel shows who has crossed the line since. The panel re-renders
// on its own (refreshRaceDayWarmup) on every passing, without rebuilding the page.
let lastWarmupDeps = null;
let showAllSessions = false;
const localDateKey = (date = new Date()) => `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
// The session picker lists today's races by default (plus whatever is live or selected),
// grouped per race in the order they were set up. Old races, practices and other series'
// rounds stay out of the way until "Show all" is ticked.
export function buildRaceDaySessionGroups({ sessions, events, selectedId = "", showAll = false, today = localDateKey(), now = Date.now() }) {
const eventById = new Map((events || []).map((event) => [event.id, event]));
const isLive = (session) => ["running", "paused"].includes(session.status);
// A race is "today's" by its date, or when something in it ran in the last 12 hours (a
// race day going past midnight, a date set wrong). Undated races are always listed.
const recentEventIds = new Set((sessions || []).filter((session) => Number(session.startedAt) > now - 12 * 3600 * 1000).map((session) => session.eventId));
const visible = (session) => {
if (showAll || isLive(session) || session.id === selectedId || recentEventIds.has(session.eventId)) return true;
const date = eventById.get(session.eventId)?.date;
return !date || date === today;
};
const groups = new Map();
let hidden = 0;
(sessions || []).forEach((session) => {
if (!visible(session)) { hidden += 1; return; }
if (!groups.has(session.eventId)) groups.set(session.eventId, { event: eventById.get(session.eventId) || null, sessions: [] });
groups.get(session.eventId).sessions.push(session);
});
// Each race's sessions in running order (practice, Q1 H1, Q1 H2 ..., finals).
groups.forEach((group) => { group.sessions = orderSessionsForRunning(group.sessions, group.event?.sessionOrder); });
const list = [...groups.values()].sort((a, b) =>
Number(b.sessions.some(isLive)) - Number(a.sessions.some(isLive))
|| String(b.event?.date || "").localeCompare(String(a.event?.date || "")));
return { groups: list, hidden };
}
function showsWarmupPanel(session) {
return Boolean(session && session.status === "ready" && session.mode !== "track" && session.type !== "team_race" && !isPracticeSessionType(session.type));
}
function formatMmSs(ms) {
const total = Math.ceil(ms / 1000);
return `${Math.floor(total / 60)}:${String(total % 60).padStart(2, "0")}`;
}
function renderPrologueControls({ t, escapeHtml, getDefaultPrologueSec }, session, check, canStart) {
const prologue = check?.prologue;
if (!prologue) {
const defaultSec = getDefaultPrologueSec(session);
return `
`;
}
const held = prologue.heldRemainingMs !== null;
return `
${formatMmSs(check.remainingMs)}
${t(held ? "prologue.held" : "prologue.running")}
`;
}
function renderWarmupPanelInner({ t, escapeHtml, getRaceDayWarmupCheck }, session) {
const check = getRaceDayWarmupCheck(session);
const warmup = check.prologue;
const unknownOptions = check.unknownTransponders.map((item) => ``).join("");
const status = (row) => (!warmup ? "–" : row.seen ? "✅" : "⏳");
return `
${warmup && check.unknownTransponders.length ? `
${t("warmup.unknown_seen")}: ${check.unknownTransponders.map((item) => `${escapeHtml(item.ownerName ? `${item.transponder} (${item.ownerName})` : item.transponder)}`).join(" ")}
` : ""}
`;
}
function bindWarmupPanel(panel, deps, session) {
const { setDriverTransponder } = deps;
panel.querySelectorAll("[data-warmup-driver]").forEach((row) => {
const driverId = row.dataset.warmupDriver;
row.querySelector("[data-warmup-assign]")?.addEventListener("change", (event) => {
if (event.target.value && setDriverTransponder(driverId, event.target.value)) refreshRaceDayWarmup(true);
});
row.querySelector("[data-warmup-save]")?.addEventListener("click", () => {
if (setDriverTransponder(driverId, row.querySelector("[data-warmup-transponder]")?.value)) refreshRaceDayWarmup(true);
});
});
}
// --- Live race for the race controller ------------------------------------------------
// The running order with laps, last and best lap, gaps and where each car will end, right on
// Race Day. Repainted once a second (refreshRaceDayLive) and on every passing (full render).
let lastLiveDeps = null;
const showsLivePanel = (session) => Boolean(session && !isPracticeSessionType(session.type)
&& (["running", "paused"].includes(session.status) || (["finished", "stopped"].includes(session.status) && session.startedAt)));
function renderLivePanelInner({ t, escapeHtml, formatLap, formatRaceClock, buildLeaderboard, getSessionTargetMs }, session) {
const rows = buildLeaderboard(session);
const seedRanked = ["practice", "qualification"].includes(session.type) && Number(session.seedBestLapCount || 0) > 0;
const targetMs = seedRanked ? null : getSessionTargetMs(session);
const fastestMs = Math.min(...rows.map((row) => Number(row.bestLapMs) || Infinity));
const done = ["finished", "stopped"].includes(session.status);
const lap = (ms) => (ms > 0 ? formatLap(ms) : "-");
const body = rows.map((row, index) => {
const estimate = !done && targetMs ? estimateFinish(row, targetMs) : null;
const bestIsFastest = row.bestLapMs > 0 && row.bestLapMs === fastestMs;
const lastIsBest = row.lastLapMs > 0 && row.lastLapMs === row.bestLapMs;
const flag = done || row.personalTimeUp ? " 🏁" : "";
const progress = Math.round(Math.min(1, row.predictedProgress || 0) * 100);
return `
| ${index + 1} |
${escapeHtml(row.displayName || row.driverName || row.transponder || "-")}${flag}${row.invalidPending ? ` ⚠` : ""}
${done ? "" : ``} |
${row.laps} |
${lap(row.lastLapMs)} |
${lap(row.bestLapMs)} |
${escapeHtml(index === 0 ? "-" : row.gapAhead || "-")} |
${escapeHtml(index === 0 ? "-" : row.leaderGap || "-")} |
${seedRanked ? escapeHtml(row.resultDisplay || "-") : done ? escapeHtml(`${row.laps} · ${formatRaceClock(row.totalElapsedMs)}`) : estimate ? escapeHtml(`${estimate.laps} · ${formatRaceClock(estimate.timeMs)}`) : "-"} |
`;
}).join("");
const lastColumn = seedRanked ? t("race_day.live_seed") : done ? t("race_day.live_result") : t("race_day.live_estimate");
return `
${rows.length ? `
| ${t("race_day.live_pos")} | ${t("race_day.live_driver")} | ${t("race_day.live_laps")} | ${t("race_day.live_last")} | ${t("race_day.live_best")} | ${t("race_day.live_gap")} | ${t("race_day.live_leader")} | ${lastColumn} |
${body}
` : `
${t("race_day.live_empty")}
`}
`;
}
// Called once a second by the clock tick in app.js; touches only the live panel.
export function refreshRaceDayLive() {
const panel = document.getElementById("raceDayLive");
if (!panel || !lastLiveDeps) return;
const session = lastLiveDeps.getSession();
if (!showsLivePanel(session)) return;
panel.innerHTML = renderLivePanelInner(lastLiveDeps, session);
}
// Called by the prologue timer in app.js (5x a second) - touches only the clock text.
export function refreshRaceDayPrologueClock(remainingMs) {
document.querySelectorAll("[data-prologue-clock]").forEach((node) => { node.textContent = formatMmSs(remainingMs); });
}
export function updateRaceDayStartDisplay(label, lights = 0) {
const button = document.getElementById("raceDayStart");
if (button && label) button.textContent = label;
const panel = document.getElementById("raceDayStartLights");
if (!panel) return;
panel.querySelector("strong")?.replaceChildren(document.createTextNode(label));
panel.querySelectorAll("[data-start-light]").forEach((node) => node.classList.toggle("is-on", Number(node.dataset.startLight) <= lights));
}
function paintWarmupPanel() {
const panel = document.getElementById("raceDayWarmup");
if (!panel || !lastWarmupDeps) return;
const session = lastWarmupDeps.getSession();
if (!showsWarmupPanel(session)) return;
panel.innerHTML = renderWarmupPanelInner(lastWarmupDeps, session);
bindWarmupPanel(panel, lastWarmupDeps, session);
}
// Re-renders the whole Race Day page (a few ms) so the panel and the preflight row stay in
// step. On a passing (force = false) it waits while the operator is typing in any field,
// so a half-entered transponder or lap window is never wiped.
export function refreshRaceDayWarmup(force = false) {
if (!lastWarmupDeps || !document.getElementById("raceDayWarmup")) return;
if (!force && ["INPUT", "SELECT", "TEXTAREA"].includes(document.activeElement?.tagName)) return;
lastWarmupDeps.renderView();
}
export function renderRaceDayView(deps) {
const {
state, dom, t, escapeHtml, formatLap, formatCountdown, formatElapsedClock,
getEventName, getSessionTypeLabel, getStatusLabel, getStartModeLabel,
getSessionTiming, getSessionGridEntries, buildRaceDayQueue, buildRaceDayPreflight,
backendAvailable, selectSession, startSession, finishSession, pauseSession, resumeSession,
saveLapWindow, navigateTo, getStartLightState, addTrackLayout, renderView,
getRaceDayWarmupCheck, setDriverTransponder, getDefaultPrologueSec,
startRacePrologue, holdRacePrologue, resumeRacePrologue, setRacePrologueRemaining, cancelRacePrologue, goRacePrologue,
isStartPending, renderSuspectLapsPanel = () => "", setCompetitorLapStatus = () => false, getLiveSession = () => null,
resetSessionData = () => false, startPracticeNow = async () => false, findOpenPracticeToContinue = () => null,
buildLeaderboard = () => [], getSessionTargetMs = () => null, formatRaceClock = (ms) => String(ms),
renderDaySchedule = () => "", bindDaySchedule = () => {}, renderDayCall = () => "", bindDayCall = () => {},
} = deps;
const queue = buildRaceDayQueue(state);
const session = queue.current;
const preflight = buildRaceDayPreflight(state, session, { backendAvailable });
const usesPrologue = showsWarmupPanel(session);
const warmupForChecks = usesPrologue ? getRaceDayWarmupCheck(session) : null;
const prologue = warmupForChecks?.prologue || null;
const checks = sortRaceDayChecks([
...preflight.checks,
...(prologue ? [{ id: "transponder_check", level: warmupForChecks.missing.length ? "warning" : "ok", seen: warmupForChecks.seenCount, total: warmupForChecks.total }] : []),
]);
const blockers = checks.filter((item) => item.level === "error").length;
const warnings = checks.filter((item) => item.level === "warning").length;
const lapWindowCheck = preflight.checks.find((item) => item.id === "lap_window") || null;
const timing = session ? getSessionTiming(session) : null;
const clock = !timing ? "-" : timing.followUpActive
? formatCountdown(timing.followUpRemainingMs)
: timing.untimed ? formatElapsedClock(timing.elapsedMs) : formatCountdown(timing.remainingMs);
const grid = session ? getSessionGridEntries(session) : [];
const isSelected = Boolean(session && state.activeSessionId === session.id);
const canStart = Boolean(session && preflight.ready && !["running", "paused"].includes(session.status) && !isStartPending?.(session));
// Another session is running while a different one is selected: say where laps go.
const liveSession = getLiveSession();
const liveElsewhere = liveSession && session && liveSession.id !== session.id && ["running", "paused"].includes(liveSession.status) ? liveSession : null;
// Quick actions for the common club evening, so nobody has to know where things live.
const practice = findOpenPracticeToContinue();
const practiceLabel = !practice ? t("race_day.quick_practice_new")
: practice.status === "running" ? t("race_day.quick_practice_show", { name: practice.name })
: t("race_day.quick_practice_continue", { name: practice.name });
const sessionChoices = buildRaceDaySessionGroups({ sessions: state.sessions, events: state.events, selectedId: session?.id, showAll: showAllSessions });
const isPracticeSession = Boolean(session && (isPracticeSessionType(session.type) || session.type === "practice"));
const isLiveSession = ["running", "paused"].includes(session?.status);
// Open/Free Practice runs all evening and is reset per day; a race's practice (seeding) is
// reset like a heat.
const isOpenPractice = Boolean(session && isPracticeSessionType(session.type));
// Layouts are a practice thing: never offered while a race session is in focus.
const layoutAllowed = !session || isPracticeSessionType(session.type);
dom.view.innerHTML = `
${layoutAllowed ? `` : ""}
${renderDayCall()}
${liveElsewhere ? `⏱ ${escapeHtml(t("timing.live_elsewhere", { name: liveElsewhere.name }))}
` : ""}
${t("race_day.current")}
${session ? escapeHtml(session.name) : t("race_day.no_session")}
${session ? `${escapeHtml(getEventName(session.eventId))} · ${escapeHtml(getSessionTypeLabel(session.type))} · ${escapeHtml(getStartModeLabel(session.startMode))}` : t("race_day.no_session_hint")}
${renderTrackLayoutBar({ state, t, escapeHtml, showNewButton: false })}
${prologue
? `${formatMmSs(warmupForChecks.remainingMs)}${t("prologue.to_start")}
`
: `${clock}${session ? escapeHtml(getStatusLabel(session.status)) : t("race_day.none")}
`}
${showsLivePanel(session) ? `` : ""}
${sessionChoices.hidden || showAllSessions ? `
` : ""}
${session && !isSelected ? `
` : ""}
${session && ["finished", "stopped"].includes(session.status) && queue.next ? `` : ""}
${usesPrologue
? renderPrologueControls({ t, escapeHtml, getDefaultPrologueSec }, session, warmupForChecks, canStart)
: isLiveSession ? "" : ``}
${prologue ? "" : `
${session?.status === "running" ? `` : ""}
${session?.status === "paused" ? `` : ""}
${isLiveSession ? `` : ""}
${isOpenPractice ? ``
: session && ["finished", "stopped", "paused"].includes(session.status) ? `` : ""}`}
${isPracticeSession ? "" : `
${[1, 2, 3, 4, 5].map((light) => ``).join("")}
${escapeHtml(getStartLightState())}
`}
${showsWarmupPanel(session) ? `
` : ""}
${session ? renderSuspectLapsPanel(session) : ""}
${grid.length ? grid.map((entry) => `
${entry.slot}${escapeHtml(entry.name)}${escapeHtml(entry.meta || "-")}`).join("") : `
${t("race_day.no_start_list")}
`}
${renderQueueSession(session, "race_day.current", deps)}
${renderQueueSession(queue.next, "race_day.next", deps)}
${renderQueueSession(queue.afterNext, "race_day.after_next", deps)}
${renderDaySchedule()}`;
dom.view.querySelectorAll("[data-race-day-fix-view]").forEach((button) => {
button.addEventListener("click", () => navigateTo(button.dataset.raceDayFixView, { settingsTab: button.dataset.raceDayFixTab || "" }));
});
dom.view.querySelectorAll("[data-race-day-fix-field]").forEach((button) => {
button.addEventListener("click", () => {
const field = document.getElementById("raceDayLapWindowForm")?.elements.namedItem(button.dataset.raceDayFixField);
field?.scrollIntoView({ block: "center" });
field?.focus({ preventScroll: true });
});
});
const choose = (sessionId) => sessionId && selectSession(sessionId);
document.getElementById("raceDayActivate")?.addEventListener("click", () => choose(session?.id));
document.querySelectorAll("[data-race-day-select]").forEach((node) => node.addEventListener("click", () => choose(node.dataset.raceDaySelect)));
document.getElementById("raceDayLapWindowForm")?.addEventListener("submit", (event) => {
event.preventDefault();
if (!session) return;
const form = new FormData(event.currentTarget);
const minLapSec = Number(form.get("minLapSec"));
const maxLapSec = Number(form.get("maxLapSec"));
const error = document.getElementById("raceDayLapWindowError");
if (!Number.isFinite(minLapSec) || !Number.isFinite(maxLapSec) || minLapSec <= 0 || maxLapSec <= minLapSec) {
if (error) {
error.textContent = t("race_day.lap_window_invalid");
error.hidden = false;
}
return;
}
saveLapWindow(session, minLapSec, maxLapSec);
});
bindTrackLayoutBar(dom.view, { state, t, addTrackLayout, renderView });
bindDaySchedule(dom.view);
bindDayCall(dom.view);
lastWarmupDeps = { t, escapeHtml, renderView, getRaceDayWarmupCheck, setDriverTransponder, getSession: () => buildRaceDayQueue(state).current };
paintWarmupPanel();
lastLiveDeps = { t, escapeHtml, formatLap, formatRaceClock, buildLeaderboard, getSessionTargetMs, getSession: () => buildRaceDayQueue(state).current };
refreshRaceDayLive();
document.getElementById("raceDayStart")?.addEventListener("click", async () => {
if (!session || !preflight.ready) return;
if (!isSelected) selectSession(session.id, { render: false });
if (usesPrologue) {
startRacePrologue(session, Number(document.getElementById("raceDayPrologueLength")?.value || 0));
return;
}
const button = document.getElementById("raceDayStart");
if (button) button.disabled = true;
const result = await startSession(session, {
onCountdown: (seconds) => updateRaceDayStartDisplay(String(seconds), 0),
onLight: (light) => updateRaceDayStartDisplay(`LIGHT_${light}`, light),
onArmed: () => updateRaceDayStartDisplay("WAIT_RANDOM", 5),
});
if (!result.ok && result.message) alert(result.message);
if (!result.ok && button) button.disabled = false;
});
dom.view.querySelector("[data-show-live]")?.addEventListener("click", (event) => selectSession(event.currentTarget.dataset.showLive));
document.getElementById("raceDayQuickPractice")?.addEventListener("click", (event) => {
event.currentTarget.disabled = true;
startPracticeNow();
});
document.getElementById("raceDayQuickRace")?.addEventListener("click", () => navigateTo("race_setup"));
document.getElementById("raceDaySessionSelect")?.addEventListener("change", (event) => { if (event.target.value) selectSession(event.target.value); });
document.getElementById("raceDayShowAllSessions")?.addEventListener("change", (event) => { showAllSessions = event.target.checked; renderView(); });
// Races: clear a heat's results (e.g. a restart after a false start) - not while it is running.
document.getElementById("raceDayResetSession")?.addEventListener("click", () => {
if (session && window.confirm(t("race_day.reset_session_confirm", { name: session.name }))) resetSessionData(session);
});
document.getElementById("raceDayNewPracticeDay")?.addEventListener("click", () => {
if (session && window.confirm(t("race_day.new_practice_day_confirm", { name: session.name }))) resetSessionData(session);
});
dom.view.querySelectorAll("[data-lap-action]").forEach((button) => button.addEventListener("click", () => {
if (session && setCompetitorLapStatus(session, button.dataset.lapRow, Number(button.dataset.lapTs), button.dataset.lapAction)) renderView();
}));
dom.view.querySelectorAll("[data-prologue]").forEach((button) => button.addEventListener("click", () => {
const action = button.dataset.prologue;
if (action === "hold") holdRacePrologue();
if (action === "resume") resumeRacePrologue();
if (action === "plus") setRacePrologueRemaining(getRaceDayWarmupCheck(session).remainingMs + 60000);
if (action === "to30") setRacePrologueRemaining(30000);
if (action === "to10") setRacePrologueRemaining(10000);
if (action === "cancel") cancelRacePrologue();
if (action === "go") {
// Warns (never blocks - a driver may not show up) when someone in the heat still
// hasn't crossed the line since the count-down began.
const check = getRaceDayWarmupCheck(session);
if (check.missing.length && !window.confirm(t("warmup.start_missing", { names: check.missing.map((row) => row.name).join(", ") }))) return;
goRacePrologue();
}
}));
document.getElementById("raceDayPause")?.addEventListener("click", () => pauseSession(session));
document.getElementById("raceDayResume")?.addEventListener("click", () => resumeSession(session));
document.getElementById("raceDayFinish")?.addEventListener("click", () => finishSession(session));
document.getElementById("raceDayTiming")?.addEventListener("click", () => navigateTo("timing"));
document.getElementById("raceDayOverlay")?.addEventListener("click", () => navigateTo("overlay"));
document.getElementById("raceDayJudging")?.addEventListener("click", () => navigateTo("judging"));
}