server.js

import http from 'node:http';
import { readFileSync, writeFileSync, renameSync } from 'node:fs';
import { fileURLToPath } from 'node:url';
import path from 'node:path';
import { extractLayers } from './extract.js';
import {
  getLayerProfile, sourceLayerNames, toCanonicalLayers,
  normalizeCallouts, normalizeCampOutlines, CANONICAL,
} from './layers.js';
import { textsFromOutlinedGlyphs } from './ocr.js';

const __dirname = path.dirname(fileURLToPath(import.meta.url));

// The event year. All input/output data lives in a directory named for it;
// change this one constant to work on a different year.
const YEAR = 2026;
const DATA_DIR = path.join(__dirname, String(YEAR));

const PDF_PATH = path.join(DATA_DIR, 'input.pdf');
const PORT = Number(process.env.PORT) || 3000;

const CAMPS_PATH = path.join(DATA_DIR, 'camps.json');
const GEOCODED_PATH = path.join(DATA_DIR, 'camps-geocoded.json');
const GEOCODED_WITH_BORDERS_PATH = path.join(DATA_DIR, 'camps-geocoded-with-borders.json');
const OCR_CACHE_PATH = path.join(DATA_DIR, 'ocr-cache.json');

let campsJson = '[]';
let rosterNames = [];
try {
  const camps = JSON.parse(readFileSync(CAMPS_PATH, 'utf8'));
  // Send only the fields the client needs (name for matching; location_string /
  // dimensions / exact_location for the hover tooltip). Other fields like
  // contact_email / description stay server-side.
  const trimmed = [];
  for (const c of camps) {
    if (!c || typeof c.name !== 'string' || !c.name.length) continue;
    const loc = c.location || {};
    trimmed.push({
      name: c.name,
      location_string: typeof c.location_string === 'string' ? c.location_string : '',
      dimensions: typeof loc.dimensions === 'string' ? loc.dimensions : '',
      exact_location: typeof loc.exact_location === 'string' ? loc.exact_location : '',
    });
  }
  campsJson = JSON.stringify(trimmed);
  rosterNames = trimmed.map(c => c.name);
  console.log(`Loaded ${trimmed.length} canonical camp entries from camps.json`);
} catch (err) {
  console.warn(`Could not load camps.json (${err.message}); name matching disabled`);
}

// Pull the PDF apart, then translate whatever this year's artist did back into
// the shape the client expects: canonical layer names, camp outlines as single
// centrelines, callouts as two-point leaders, camp names as text. See layers.js.
const profile = getLayerProfile(YEAR);
console.log(`Extracting layers from ${PDF_PATH}...`);
const t0 = Date.now();
const raw = await extractLayers(PDF_PATH, sourceLayerNames(profile));
const { width, height } = raw;

let paths = toCanonicalLayers(raw.paths, profile);
let texts = toCanonicalLayers(raw.texts, profile);

paths = normalizeCallouts(paths, profile, width, height);
paths = normalizeCampOutlines(paths, profile, width, height);

if (profile.textStyle === 'outlined') {
  // The glyph paths stay in the payload: the client draws the artist's own
  // lettering and uses these text items only for matching camps to the roster.
  texts = texts.concat(await textsFromOutlinedGlyphs(paths, {
    width, height, rosterNames, cachePath: OCR_CACHE_PATH,
  }));
  // Those glyphs are 15,000-odd paths of full-precision floats. They are only
  // ever drawn, never measured, and a hundredth of a PDF unit is far below one
  // screen pixel at any usable zoom — so round them and halve the payload.
  paths = paths.map(p => p.layer !== CANONICAL.CAMP_NAMES ? p : {
    ...p,
    cmds: p.cmds.map(c => c.map(v => typeof v === 'number' ? Math.round(v * 100) / 100 : v)),
  });
}

const layerData = { width, height, paths, texts };
console.log(
  `Extracted ${paths.length} subpaths and ${texts.length} text items ` +
  `(page ${width}x${height} pts) in ${Date.now() - t0} ms`
);

const layerJson = JSON.stringify(layerData);
const appJs = readFileSync(path.join(__dirname, 'public', 'app.js'), 'utf8');

// Same normalization the client uses so coord-map keys line up.
const normalizeCampName = s => String(s)
  .toLowerCase()
  .replace(/&/g, 'and')
  .replace(/[^a-z0-9]/g, '');

const CORRECTIONS_PATH = path.join(DATA_DIR, 'corrections.json');
let correctionsData = { version: 1, corrections: [] };
try {
  const parsed = JSON.parse(readFileSync(CORRECTIONS_PATH, 'utf8'));
  if (parsed && Array.isArray(parsed.corrections)) {
    correctionsData = { version: parsed.version || 1, corrections: parsed.corrections };
    console.log(`Loaded ${correctionsData.corrections.length} corrections from corrections.json`);
  }
} catch (err) {
  if (err.code !== 'ENOENT') console.warn(`Could not load corrections.json (${err.message}); starting empty`);
}

const html = `<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>BRC Map Tools</title>
<style>
  html, body { margin: 0; padding: 0; height: 100%; overflow: hidden; background: #fff; }
  canvas { display: block; }
  #status-bar {
    position: absolute;
    bottom: 16px;
    left: 16px;
    background: rgba(255,255,255,0.92);
    border: 1px solid rgba(0,0,0,0.2);
    border-radius: 4px;
    padding: 8px 12px;
    font: 12px sans-serif;
    display: none;
    user-select: none;
  }
  #status-bar > * { vertical-align: middle; }
  #status-bar button {
    margin-left: 6px;
    font: inherit;
    padding: 2px 8px;
    cursor: pointer;
  }
  #status-bar button:disabled { cursor: default; opacity: 0.5; }
  #status-bar input {
    margin-left: 4px;
    margin-right: 4px;
    font: inherit;
    padding: 2px 6px;
  }
  #compass {
    position: absolute;
    top: 16px;
    right: 16px;
    width: 48px;
    height: 48px;
    background: rgba(255,255,255,0.92);
    border: 1px solid rgba(0,0,0,0.2);
    border-radius: 50%;
    cursor: pointer;
    user-select: none;
    box-shadow: 0 1px 3px rgba(0,0,0,0.15);
    display: flex;
    align-items: center;
    justify-content: center;
  }
  #compass svg {
    width: 100%;
    height: 100%;
    transition: transform 250ms ease-out;
  }
</style>
</head>
<body>
  <canvas id="map"></canvas>
  <div id="status-bar"></div>
  <div id="compass" title="Toggle map orientation (12:00 up / North up)">
    <svg viewBox="-24 -24 48 48" xmlns="http://www.w3.org/2000/svg">
      <circle cx="0" cy="0" r="20" fill="none" stroke="#999" stroke-width="1"/>
      <polygon points="0,-10 5,1 0,0 -5,1" fill="#d32f2f" stroke="#7a1a18" stroke-width="0.6" stroke-linejoin="round"/>
      <polygon points="0,10 5,-1 0,0 -5,-1" fill="#dddddd" stroke="#666" stroke-width="0.6" stroke-linejoin="round"/>
      <text x="0" y="-12" text-anchor="middle" font-family="sans-serif" font-size="10" font-weight="bold" fill="#000">N</text>
    </svg>
  </div>
  <script src="/app.js"></script>
</body>
</html>`;

const server = http.createServer((req, res) => {
  const url = req.url || '/';
  if (url === '/' || url === '/index.html') {
    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
    res.end(html);
  } else if (url === '/app.js') {
    res.writeHead(200, { 'Content-Type': 'application/javascript; charset=utf-8' });
    res.end(appJs);
  } else if (url === '/layers.json') {
    res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
    res.end(layerJson);
  } else if (url === '/camps.json') {
    res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
    res.end(campsJson);
  } else if (url === '/corrections.json') {
    res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
    res.end(JSON.stringify(correctionsData));
  } else if (url === '/corrections' && req.method === 'POST') {
    let body = '';
    req.on('data', chunk => { body += chunk; if (body.length > 1e6) req.destroy(); });
    req.on('end', () => {
      let parsed;
      try { parsed = JSON.parse(body); }
      catch (err) {
        res.writeHead(400, { 'Content-Type': 'text/plain' }); res.end('Invalid JSON'); return;
      }
      if (!parsed || typeof parsed !== 'object' || typeof parsed.type !== 'string') {
        res.writeHead(400, { 'Content-Type': 'text/plain' }); res.end('Bad correction format'); return;
      }
      correctionsData.corrections.push(parsed);
      try {
        const tmp = CORRECTIONS_PATH + '.tmp';
        writeFileSync(tmp, JSON.stringify(correctionsData, null, 2));
        renameSync(tmp, CORRECTIONS_PATH);
      } catch (err) {
        console.warn('Failed to write corrections.json:', err.message);
        res.writeHead(500, { 'Content-Type': 'text/plain' }); res.end('Could not write file'); return;
      }
      console.log(`Correction added (${parsed.type}); total ${correctionsData.corrections.length}`);
      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ count: correctionsData.corrections.length }));
    });
  } else if (url === '/camps-geocoded' && req.method === 'POST') {
    // Client posts { coords, borders } once mapping is complete:
    //   coords  : { normalizedName: { latitude, longitude } }   — polygon centroid
    //   borders : { normalizedName: { type: 'Polygon', coordinates: [[[lng, lat], ...]] } }
    // We merge both against the on-disk camps.json. Two output files are
    // written: the slim one (centroid only) and a strict superset with
    // location.border attached as well.
    let body = '';
    req.on('data', chunk => { body += chunk; if (body.length > 5e6) req.destroy(); });
    req.on('end', () => {
      let parsed;
      try { parsed = JSON.parse(body); }
      catch (err) {
        res.writeHead(400, { 'Content-Type': 'text/plain' }); res.end('Invalid JSON'); return;
      }
      const coords = parsed && parsed.coords;
      if (!coords || typeof coords !== 'object') {
        res.writeHead(400, { 'Content-Type': 'text/plain' }); res.end('Missing coords'); return;
      }
      const borders = (parsed && parsed.borders && typeof parsed.borders === 'object')
        ? parsed.borders
        : {};
      let camps;
      try { camps = JSON.parse(readFileSync(CAMPS_PATH, 'utf8')); }
      catch (err) {
        res.writeHead(500, { 'Content-Type': 'text/plain' });
        res.end('Could not read camps.json: ' + err.message);
        return;
      }
      if (!Array.isArray(camps)) {
        res.writeHead(500, { 'Content-Type': 'text/plain' }); res.end('camps.json is not an array'); return;
      }
      let geocodedCount = 0;
      let borderCount = 0;
      const slimOut = [];
      const richOut = [];
      for (const c of camps) {
        if (!c || typeof c !== 'object' || typeof c.name !== 'string') {
          slimOut.push(c);
          richOut.push(c);
          continue;
        }
        const key = normalizeCampName(c.name);
        const ll = coords[key];
        const border = borders[key];
        const hasCentroid = ll && ll.type === 'Point' && Array.isArray(ll.coordinates)
          && ll.coordinates.length === 2
          && isFinite(ll.coordinates[0]) && isFinite(ll.coordinates[1]);
        const hasBorder = border && border.type === 'Polygon' && Array.isArray(border.coordinates);
        if (!hasCentroid && !hasBorder) {
          slimOut.push(c);
          richOut.push(c);
          continue;
        }
        if (hasCentroid) geocodedCount++;
        if (hasBorder) borderCount++;
        const slimLocation = Object.assign({}, c.location || {});
        const richLocation = Object.assign({}, c.location || {});
        if (hasCentroid) {
          const centroid = { type: 'Point', coordinates: [ll.coordinates[0], ll.coordinates[1]] };
          slimLocation.centroid = centroid;
          richLocation.centroid = centroid;
        }
        if (hasBorder) {
          richLocation.border = { type: 'Polygon', coordinates: border.coordinates };
        }
        slimOut.push(Object.assign({}, c, { location: slimLocation }));
        richOut.push(Object.assign({}, c, { location: richLocation }));
      }
      const writeAtomic = (filePath, data) => {
        const tmp = filePath + '.tmp';
        writeFileSync(tmp, JSON.stringify(data, null, 2));
        renameSync(tmp, filePath);
      };
      try {
        writeAtomic(GEOCODED_PATH, slimOut);
        writeAtomic(GEOCODED_WITH_BORDERS_PATH, richOut);
      } catch (err) {
        console.warn('Failed to write geocoded output:', err.message);
        res.writeHead(500, { 'Content-Type': 'text/plain' }); res.end('Could not write file'); return;
      }
      console.log(
        `Wrote camps-geocoded.json (${geocodedCount}/${slimOut.length} centroids) and ` +
        `camps-geocoded-with-borders.json (${borderCount} borders)`
      );
      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ total: slimOut.length, geocoded: geocodedCount, withBorders: borderCount }));
    });
  } else {
    res.writeHead(404, { 'Content-Type': 'text/plain' });
    res.end('Not found');
  }
});

server.listen(PORT, () => {
  console.log(`Listening on http://localhost:${PORT}`);
});