import { medal, qualCell } from "./medal.js";
import { sortableTable, sortValuesAttribute } from "./list_sorting.js";
export function buildArchiveRows(state, { getEventName, getClassName, getTrackLayoutLabel, buildLeaderboard }) {
return (state.sessions || [])
.filter((session) => session.status === "finished")
.map((session) => {
const event = state.events.find((item) => item.id === session.eventId) || null;
const result = state.resultsBySession?.[session.id] || null;
const competitors = result ? Object.values(result.competitors || {}) : [];
// The same order as the session's result (laps, then time, penalties, seeding). The raw
// laps alone named whoever crossed the line first when laps were equal.
const winner = result ? buildLeaderboard(session)[0] || null : null;
return {
session,
event,
result,
competitors,
eventName: event ? getEventName(event.id) : session.name,
className: event ? getClassName(event.classId) : "",
date: event?.date || (session.endedAt ? new Date(session.endedAt).toISOString().slice(0, 10) : ""),
winnerName: winner?.displayName || winner?.driverName || "",
adjustmentCount: (result?.adjustments || []).length,
trackLayoutLabel: getTrackLayoutLabel(state.trackLayouts, session.trackLayoutId),
};
})
.sort((left, right) => Number(right.session.endedAt || 0) - Number(left.session.endedAt || 0));
}
// One row per event (a race, a sponsor event, a practice day); heats without an event stand alone.
// Newest first. The winner is the A final's, else the latest heat's.
export function groupArchiveRowsByEvent(rows) {
const groups = new Map();
rows.forEach((row) => {
const key = row.event ? row.event.id : `session:${row.session.id}`;
if (!groups.has(key)) groups.set(key, { key, event: row.event, eventName: row.eventName, className: row.className, date: row.date, rows: [], driverIds: new Set() });
const group = groups.get(key);
group.rows.push(row);
if (row.date > group.date) group.date = row.date;
row.competitors.forEach((competitor) => group.driverIds.add(String(competitor.driverId || competitor.transponder || "")));
});
return [...groups.values()].map((group) => {
const aFinal = group.rows.find((row) => row.session.type === "final" && /^A/i.test(row.session.name || ""));
return { ...group, driverCount: group.driverIds.size, winnerName: (aFinal || group.rows[0])?.winnerName || "", endedAt: Math.max(...group.rows.map((row) => Number(row.session.endedAt || 0))) };
}).sort((left, right) => right.endedAt - left.endedAt);
}
function matchesArchiveFilters(row, filters) {
const search = filters.search.trim().toLowerCase();
if (search && !`${row.eventName} ${row.session.name}`.toLowerCase().includes(search)) return false;
if (filters.classId && row.event?.classId !== filters.classId) return false;
if (filters.driverId && !row.competitors.some((competitor) => String(competitor.driverId || "") === filters.driverId)) return false;
if (filters.dateFrom && row.date && row.date < filters.dateFrom) return false;
if (filters.dateTo && row.date && row.date > filters.dateTo) return false;
return true;
}
function renderArchiveDetail(row, deps) {
const { t, escapeHtml, formatLap, formatRaceClock, renderTable, buildLeaderboard, getCompetitorPassings, getQualifyingPlaces = () => new Map() } = deps;
const { session, event, result } = row;
const leaderboard = buildLeaderboard(session);
// A final heat shows where each driver qualified ("TQ" for the top qualifier).
const qualPlaces = getQualifyingPlaces(session, event);
const withQual = leaderboard.some((rowItem) => qualPlaces.get(rowItem.driverId));
const adjustments = result?.adjustments || [];
return `
${t("archive.no_standings")} ${t("archive.no_penalties")} ${t("timing.no_lap_history")} ${t("archive.no_standings")}${escapeHtml(row.eventName)} - ${escapeHtml(session.name)}${row.trackLayoutLabel ? ` ${escapeHtml(row.trackLayoutLabel)}` : ""}
${t("archive.standings")}
${leaderboard.length
? renderTable(
[t("table.pos"), ...(withQual ? [t("table.qual")] : []), t("table.driver"), t("table.laps"), t("table.best_lap"), t("timing.total_time")],
leaderboard.map((rowItem, index) => `
`)
)
: `${medal(index + 1)}
${withQual ? qualCell(qualPlaces.get(rowItem.driverId), escapeHtml) : ""}
${escapeHtml(rowItem.displayName || rowItem.driverName || t("common.unknown_driver"))}
${rowItem.laps}
${formatLap(rowItem.bestLapMs)}
${escapeHtml(rowItem.resultDisplay || "-")}
${t("archive.penalties")}
${adjustments.length
? renderTable(
[t("table.time"), t("table.driver"), t("archive.action"), t("archive.detail")],
adjustments.slice().reverse().map((adjustment) => `
`)
)
: `${escapeHtml(new Date(adjustment.ts || 0).toLocaleTimeString())}
${escapeHtml(adjustment.displayName || "-")}
${escapeHtml(t(`archive.adjustment_${adjustment.category}`) || adjustment.category || "-")}
${escapeHtml(adjustment.detail || "-")}
${t("archive.lap_history")}
${leaderboard.map((rowItem) => {
const passings = getCompetitorPassings(session, rowItem);
return `
${escapeHtml(rowItem.displayName || rowItem.driverName || t("common.unknown_driver"))} - ${rowItem.laps} ${t("table.laps")}
${passings.length
? renderTable(
[t("table.lap"), t("table.time"), t("table.last_lap")],
passings.map((passing, index) => `
`)
)
: `${index + 1}
${formatRaceClock(Math.max(0, passing.timestamp - (session.startedAt || passing.timestamp)))}
${formatLap(passing.lapMs)}
${t("archive.hint")}
${t("archive.no_results")}
`}${escapeHtml([selectedGroup.date, selectedGroup.className].filter(Boolean).join(" • "))}