How the data updates

/**
 * Sync the latest finished Formula 1 race result into app/f1-tyres/data/latest-sync.json.
 *
 * Source: Jolpica-F1 (the community-run, open-source Ergast replacement). No API key needed.
 * Run by .github/workflows/f1-tyre-sync.yml; safe to run locally with `node scripts/sync-f1-telemetry.js`.
 *
 * Behaviour:
 *   - The request has a timeout and a couple of retries.
 *   - If the API is unreachable, slow, or returns nothing usable, the existing JSON file is left untouched
 *     and the script exits 0 (a warning is printed; it is a transient condition, not a failure).
 *   - The file is only rewritten when the race data actually changed, so an unchanged week produces no diff.
 *   - The script exits 1 only for genuine local errors, such as being unable to read or write the file.
 */

const fs = require('node:fs');
const path = require('node:path');

const ENDPOINT = 'https://api.jolpi.ca/ergast/f1/current/last/results.json';
const SOURCE = 'https://api.jolpi.ca/ergast/f1/';
const OUT_PATH = path.join(__dirname, '..', 'app', 'f1-tyres', 'data', 'latest-sync.json');
const TIMEOUT_MS = 15000;
const ATTEMPTS = 3;
const RETRY_DELAY_MS = 3000;

const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

/** GitHub Actions turns `::warning::` lines into annotations; elsewhere it is just a readable line. */
function warn(message) {
  console.warn(`::warning::[F1-SYNC] ${message}`);
}

function fullName(driver) {
  return driver ? `${driver.givenName} ${driver.familyName}` : undefined;
}

async function fetchOnce() {
  const res = await fetch(ENDPOINT, {
    signal: AbortSignal.timeout(TIMEOUT_MS),
    headers: { Accept: 'application/json', 'User-Agent': 'tenziki-f1-tyre-sync' },
  });
  if (!res.ok) throw new Error(`HTTP ${res.status}`);
  return res.json();
}

async function fetchWithRetry() {
  let lastError;
  for (let attempt = 1; attempt <= ATTEMPTS; attempt += 1) {
    try {
      return await fetchOnce();
    } catch (err) {
      lastError = err;
      console.log(`[F1-SYNC] Attempt ${attempt}/${ATTEMPTS} failed: ${err.message}`);
      if (attempt < ATTEMPTS) await wait(RETRY_DELAY_MS);
    }
  }
  throw lastError;
}

/** Reduce the API response to the small structure the site displays. */
function toRaceSummary(json) {
  const race = json?.MRData?.RaceTable?.Races?.[0];
  if (!race || !Array.isArray(race.Results) || race.Results.length === 0) return null;

  const winner = race.Results.find((r) => r.position === '1') || race.Results[0];
  const fastest = race.Results.find((r) => r.FastestLap?.rank === '1');

  const summary = {
    season: race.season,
    round: race.round,
    name: race.raceName,
    circuit: race.Circuit?.circuitName,
    date: race.date,
    winner: {
      driver: fullName(winner.Driver),
      team: winner.Constructor?.name,
      laps: winner.laps,
      time: winner.Time?.time,
    },
  };

  if (fastest) {
    summary.fastestLap = {
      driver: fullName(fastest.Driver),
      team: fastest.Constructor?.name,
      time: fastest.FastestLap?.Time?.time,
      lap: fastest.FastestLap?.lap,
    };
    const speed = fastest.FastestLap?.AverageSpeed?.speed;
    if (speed) summary.fastestLap.speedKmh = speed;
  }

  return summary;
}

function readExisting() {
  try {
    return JSON.parse(fs.readFileSync(OUT_PATH, 'utf8'));
  } catch (err) {
    if (err.code === 'ENOENT') return null;
    // A corrupt file will simply be replaced by fresh data.
    console.log(`[F1-SYNC] Existing file could not be parsed (${err.message}); it will be replaced.`);
    return null;
  }
}

async function main() {
  console.log(`[F1-SYNC] Fetching ${ENDPOINT}`);

  let json;
  try {
    json = await fetchWithRetry();
  } catch (err) {
    warn(`Jolpica API unavailable (${err.message}). Keeping the existing data file unchanged.`);
    return;
  }

  const latest = toRaceSummary(json);
  if (!latest) {
    warn('The API responded but returned no race results. Keeping the existing data file unchanged.');
    return;
  }

  console.log(`[F1-SYNC] Latest race: ${latest.name} (${latest.season} round ${latest.round}), ${latest.date}`);
  console.log(`[F1-SYNC] Winner: ${latest.winner.driver} (${latest.winner.team})`);
  if (latest.fastestLap) {
    console.log(`[F1-SYNC] Fastest lap: ${latest.fastestLap.driver}, ${latest.fastestLap.time} on lap ${latest.fastestLap.lap}`);
  }

  const existing = readExisting();
  if (existing && JSON.stringify(existing.latestFinishedRace) === JSON.stringify(latest)) {
    console.log('[F1-SYNC] No change since the last sync. Nothing written.');
    return;
  }

  const payload = {
    lastSyncedAt: new Date().toISOString(),
    source: SOURCE,
    cost: '$0.00',
    latestFinishedRace: latest,
  };

  fs.writeFileSync(OUT_PATH, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
  console.log(`[F1-SYNC] Wrote ${path.relative(process.cwd(), OUT_PATH)}`);
}

main().catch((err) => {
  console.error(`[F1-SYNC] Sync failed: ${err.stack || err.message}`);
  process.exit(1);
});