#!/usr/bin/env node

const fs = require("fs");
const path = require("path");
const os = require("os");
const { execFileSync } = require("child_process");
const { JsStreetNetwork } = require("osm2streets-js-node");
const { qgisPaths } = require("./lib/tool-paths");
const { buildCustomTurnLaneArrows } = require("./lib/turn-lane-arrows");
const { readTrafficSignalFeatures } = require("./lib/traffic-signals");
const {
  SCENE_LAYERS,
  AUXILIARY_EDIT_LAYERS,
  SCENE_FILE,
  SCENE_STYLE_FILE,
  layerFile,
  mergeScene,
  sceneStyle,
  qgisRgba,
} = require("./lib/scene-layers");

const repoRoot = path.resolve(__dirname, "..");
const args = parseArgs(process.argv.slice(2));
const configPath = path.resolve(args.config || path.join(repoRoot, "config", "default.json"));
const config = loadConfig(configPath, args);
const qgisApp = config.qgisApp;
const qgis = qgisPaths(qgisApp);
const qgisPython = qgis.python;
const ogr2ogr = qgis.ogr2ogr;
const normalizeLaneArrowsScript = path.join(repoRoot, "scripts", "normalize-lane-arrows.py");
const inputPath = path.resolve(config.input);
const outDir = path.resolve(config.outDir);
const gpkgPath = path.resolve(config.gpkg);
const projectPath = path.resolve(config.project);
const previewPath = path.resolve(config.preview);
const arrowScale = Number(config.arrowScale);
const arrowMergeTriangles = config.arrowMergeTriangles !== false;
const arrowOutlineSimplifyMeters = Number(config.arrowOutlineSimplifyMeters ?? 0.05);
const intersectionCornerSourceMaxDimensionMeters = Number(config.intersectionCornerSourceMaxDimensionMeters ?? 2.6);
const clipPad = Number(config.clipPad);
const canvasPad = Number(config.canvasPad);
const previewPad = Number(config.previewPad);
const layerPrefix = config.layerPrefix || "osm2streets";
const trafficSignalLayer = AUXILIARY_EDIT_LAYERS.find((layer) => layer.id === "traffic_signal_assemblies");
if (!trafficSignalLayer) throw new Error("Missing traffic_signal_assemblies auxiliary layer definition");
const trafficSignalAssembliesPath = path.resolve(
  config.trafficSignalAssemblies || path.join(outDir, trafficSignalLayer.file),
);

if (!Number.isFinite(arrowScale) || arrowScale <= 0) {
  throw new Error(`Invalid arrowScale: ${config.arrowScale}`);
}
if (!Number.isFinite(arrowOutlineSimplifyMeters) || arrowOutlineSimplifyMeters < 0) {
  throw new Error(`Invalid arrowOutlineSimplifyMeters: ${config.arrowOutlineSimplifyMeters}`);
}
if (!Number.isFinite(intersectionCornerSourceMaxDimensionMeters) || intersectionCornerSourceMaxDimensionMeters <= 0) {
  throw new Error(`Invalid intersectionCornerSourceMaxDimensionMeters: ${config.intersectionCornerSourceMaxDimensionMeters}`);
}
for (const [key, value] of [["clipPad", clipPad], ["canvasPad", canvasPad], ["previewPad", previewPad]]) {
  if (!Number.isFinite(value) || value < 0) {
    throw new Error(`Invalid ${key}: ${config[key]}`);
  }
}
if (!fs.existsSync(inputPath)) {
  throw new Error(`Input OSM XML not found: ${inputPath}`);
}
for (const exe of [ogr2ogr, qgisPython]) {
  if (!fs.existsSync(exe)) {
    throw new Error(`QGIS executable not found: ${exe}`);
  }
}
if (!fs.existsSync(normalizeLaneArrowsScript)) {
  throw new Error(`Lane-arrow normalizer not found: ${normalizeLaneArrowsScript}`);
}

fs.mkdirSync(outDir, { recursive: true });
fs.mkdirSync(path.dirname(gpkgPath), { recursive: true });
fs.mkdirSync(path.dirname(projectPath), { recursive: true });
fs.mkdirSync(path.dirname(previewPath), { recursive: true });

const xml = fs.readFileSync(inputPath, "utf8");
const bbox = getOsmBounds(xml);
const osm = parseOsm(xml);
const clip = makeClipPolygon(bbox, clipPad);

const network = new JsStreetNetwork(xml, JSON.stringify(clip), config.osm2streets);

writeGeoJson(outDir, "plain.geojson", network.toGeojsonPlain());
writeGeoJson(outDir, "lane_polygons.geojson", network.toLanePolygonsGeojson());
writeGeoJson(outDir, "lane_markings.geojson", network.toLaneMarkingsGeojson());
writeGeoJson(outDir, "intersection_markings.geojson", network.toIntersectionMarkingsGeojson());
fs.writeFileSync(path.join(outDir, "network.json"), network.toJson());

const split = splitLayers(
  outDir,
  arrowScale,
  intersectionCornerSourceMaxDimensionMeters,
  osm,
);
const customTurnLaneArrows = buildCustomTurnLaneArrows(osm, {
  ...config.turnLaneArrows,
  network: JSON.parse(network.toJson()),
  lanePolygons: JSON.parse(fs.readFileSync(path.join(outDir, "lane_polygons.geojson"), "utf8")).features,
  crosswalkStripes: split.crosswalks.features,
  stopLines: split.vehicleStopLines.features,
});
const suppressedStandardLaneArrows = suppressNearestStandardLaneArrows(
  split.laneArrows.features,
  customTurnLaneArrows.features,
);
split.laneArrows.features = split.laneArrows.features.filter((feature) => !suppressedStandardLaneArrows.has(feature));
split.laneArrows.features.push(...customTurnLaneArrows.features);
const turnLaneArrowDiagnostics = {
  enabled: config.turnLaneArrows?.enabled === true,
  generated: customTurnLaneArrows.features.length,
  suppressed_standard_lane_arrows: suppressedStandardLaneArrows.size,
  diagnostics: customTurnLaneArrows.diagnostics,
};
fs.writeFileSync(
  path.join(outDir, "turn_lane_arrow_diagnostics.json"),
  `${JSON.stringify(turnLaneArrowDiagnostics, null, 2)}\n`,
);
for (const layer of SCENE_LAYERS) {
  writeJson(path.join(outDir, layerFile(layer)), split[layer.splitKey]);
}
writeJson(trafficSignalAssembliesPath, readTrafficSignalFeatures(
  path.join(outDir, "vehicle_stop_lines.geojson"),
  path.join(outDir, "intersection_surface.geojson"),
  inputPath,
));
if (arrowMergeTriangles) {
  normalizeLaneArrows(path.join(outDir, "lane_arrows_webscale.geojson"), arrowOutlineSimplifyMeters);
  split.laneArrows = JSON.parse(fs.readFileSync(path.join(outDir, "lane_arrows_webscale.geojson"), "utf8"));
}
writeJson(path.join(outDir, SCENE_FILE), mergeScene((layer) => split[layer.splitKey]));
fs.writeFileSync(
  path.join(outDir, SCENE_STYLE_FILE),
  JSON.stringify(sceneStyle(), null, 2),
);

if (fs.existsSync(gpkgPath)) {
  fs.unlinkSync(gpkgPath);
}
const ogrEnv = qgis.env;
// First layer creates the GeoPackage; the rest append into it.
SCENE_LAYERS.forEach((layer, index) => {
  importLayer(gpkgPath, path.join(outDir, layerFile(layer)), layer.id, index > 0, ogrEnv);
});
importLayer(gpkgPath, trafficSignalAssembliesPath, trafficSignalLayer.id, true, ogrEnv);

const qgisScript = path.join(outDir, "_create_qgis_project.py");
const previewFeature = split.crosswalks.features[0] || split.laneArrows.features[0] || split.roadSurface.features[0];
const defaultPreviewExtent = extentString(expandBounds(
  featureBounds(previewFeature),
  previewPad,
));
fs.writeFileSync(qgisScript, makeQgisScript({
  qgisPrefix: qgis.prefix,
  gpkgPath,
  projectPath,
  previewPath,
  layerPrefix,
  canvasExtent: config.canvasExtent || extentString(expandBounds(bbox, canvasPad)),
  previewExtent: config.previewExtent || defaultPreviewExtent,
  trafficSignalSymbolPath: path.join(repoRoot, "assets", "qgis", "traffic-signal-direction.svg"),
}));

execFileSync(qgisPython, [qgisScript], {
  stdio: "inherit",
  env: {
    ...process.env,
    ...qgis.env,
    QT_QPA_PLATFORM: "offscreen",
    ...qgis.pythonEnv,
  },
});
fixCanvas(projectPath, config.canvasExtent || extentString(expandBounds(bbox, canvasPad)));

console.log(`Config: ${configPath}`);
console.log(`GeoPackage: ${gpkgPath}`);
console.log(`QGIS project: ${projectPath}`);
console.log(`Preview PNG: ${previewPath}`);

function parseArgs(argv) {
  const out = {};
  for (let i = 0; i < argv.length; i += 1) {
    const arg = argv[i];
    if (!arg.startsWith("--")) continue;
    const key = arg.slice(2).replace(/-([a-z])/g, (_, c) => c.toUpperCase());
    const next = argv[i + 1];
    if (!next || next.startsWith("--")) {
      out[key] = "true";
    } else {
      out[key] = next;
      i += 1;
    }
  }
  return out;
}

function loadConfig(file, cliArgs) {
  if (!fs.existsSync(file)) {
    throw new Error(`Config file not found: ${file}`);
  }
  const base = JSON.parse(fs.readFileSync(file, "utf8"));
  const overrides = {};
  const mapping = {
    qgisApp: "qgisApp",
    input: "input",
    outDir: "outDir",
    gpkg: "gpkg",
    project: "project",
    preview: "preview",
    arrowScale: "arrowScale",
    arrowMergeTriangles: "arrowMergeTriangles",
    arrowOutlineSimplifyMeters: "arrowOutlineSimplifyMeters",
    intersectionCornerSourceMaxDimensionMeters: "intersectionCornerSourceMaxDimensionMeters",
    clipPad: "clipPad",
    pad: "clipPad",
    canvasPad: "canvasPad",
    previewPad: "previewPad",
    canvasExtent: "canvasExtent",
    previewExtent: "previewExtent",
  };
  for (const [argKey, configKey] of Object.entries(mapping)) {
    if (cliArgs[argKey] !== undefined) {
      overrides[configKey] = cliArgs[argKey];
    }
  }
  if (process.env.QGIS_APP && overrides.qgisApp === undefined) {
    overrides.qgisApp = process.env.QGIS_APP;
  }
  const merged = deepMerge(base, overrides);
  const required = ["qgisApp", "input", "outDir", "gpkg", "project", "preview", "osm2streets"];
  for (const key of required) {
    if (merged[key] === undefined || merged[key] === null || merged[key] === "") {
      throw new Error(`Missing config key: ${key}`);
    }
  }
  return merged;
}

function deepMerge(base, overrides) {
  const out = { ...base };
  for (const [key, value] of Object.entries(overrides)) {
    if (
      value &&
      typeof value === "object" &&
      !Array.isArray(value) &&
      base[key] &&
      typeof base[key] === "object" &&
      !Array.isArray(base[key])
    ) {
      out[key] = deepMerge(base[key], value);
    } else {
      out[key] = value;
    }
  }
  return out;
}

function getOsmBounds(xmlText) {
  // OSM exports may contain distant relation members (for example subway
  // nodes) that are not part of the requested map extent. Prefer the explicit
  // bounds element when present and only fall back to node extents for files
  // that do not provide one.
  const boundsMatch = xmlText.match(/<bounds\b([^>]*)\/?\s*>/);
  if (boundsMatch) {
    const attrs = parseAttrs(boundsMatch[1]);
    const values = {
      minLon: Number(attrs.minlon),
      minLat: Number(attrs.minlat),
      maxLon: Number(attrs.maxlon),
      maxLat: Number(attrs.maxlat),
    };
    if (Object.values(values).every(Number.isFinite)) {
      return values;
    }
  }
  let minLon = Infinity;
  let minLat = Infinity;
  let maxLon = -Infinity;
  let maxLat = -Infinity;
  for (const match of xmlText.matchAll(/<node\b([^>]*)>/g)) {
    const attrs = match[1];
    const latMatch = attrs.match(/\blat=(["'])(.*?)\1/);
    const lonMatch = attrs.match(/\blon=(["'])(.*?)\1/);
    if (!latMatch || !lonMatch) continue;
    const lat = Number(latMatch[2]);
    const lon = Number(lonMatch[2]);
    if (!Number.isFinite(lat) || !Number.isFinite(lon)) continue;
    minLon = Math.min(minLon, lon);
    maxLon = Math.max(maxLon, lon);
    minLat = Math.min(minLat, lat);
    maxLat = Math.max(maxLat, lat);
  }
  if (!Number.isFinite(minLon)) {
    throw new Error("No OSM node coordinates found");
  }
  return { minLon, minLat, maxLon, maxLat };
}

function parseOsm(xmlText) {
  const nodes = new Map();
  const ways = new Map();
  for (const match of xmlText.matchAll(/<node\b([^>]*?)(?:\/>|>([\s\S]*?)<\/node>)/g)) {
    const attrs = parseAttrs(match[1]);
    const id = Number(attrs.id);
    const lat = Number(attrs.lat);
    const lon = Number(attrs.lon);
    if (!Number.isFinite(id) || !Number.isFinite(lat) || !Number.isFinite(lon)) continue;
    nodes.set(id, { id, lat, lon, tags: parseTags(match[2] || "") });
  }
  for (const match of xmlText.matchAll(/<way\b([^>]*)>([\s\S]*?)<\/way>/g)) {
    const attrs = parseAttrs(match[1]);
    const id = Number(attrs.id);
    if (!Number.isFinite(id)) continue;
    const body = match[2] || "";
    const refs = [...body.matchAll(/<nd\b([^>]*)\/>/g)]
      .map((refMatch) => Number(parseAttrs(refMatch[1]).ref))
      .filter(Number.isFinite);
    ways.set(id, { id, refs, tags: parseTags(body) });
  }
  return { nodes, ways };
}

function parseAttrs(text) {
  const attrs = {};
  for (const match of text.matchAll(/([\w:.-]+)=(["'])(.*?)\2/g)) {
    attrs[match[1]] = decodeXml(match[3]);
  }
  return attrs;
}

function parseTags(text) {
  const tags = {};
  for (const match of text.matchAll(/<tag\b([^>]*)\/>/g)) {
    const attrs = parseAttrs(match[1]);
    if (attrs.k !== undefined) tags[attrs.k] = attrs.v ?? "";
  }
  return tags;
}

function decodeXml(value) {
  return value
    .replaceAll("&quot;", "\"")
    .replaceAll("&apos;", "'")
    .replaceAll("&lt;", "<")
    .replaceAll("&gt;", ">")
    .replaceAll("&amp;", "&");
}

function makeClipPolygon(bbox, pad) {
  const b = expandBounds(bbox, pad);
  return {
    type: "FeatureCollection",
    features: [{
      type: "Feature",
      properties: {},
      geometry: {
        type: "Polygon",
        coordinates: [[
          [b.minLon, b.minLat],
          [b.maxLon, b.minLat],
          [b.maxLon, b.maxLat],
          [b.minLon, b.maxLat],
          [b.minLon, b.minLat],
        ]],
      },
    }],
  };
}

function expandBounds(bbox, pad) {
  return {
    minLon: bbox.minLon - pad,
    minLat: bbox.minLat - pad,
    maxLon: bbox.maxLon + pad,
    maxLat: bbox.maxLat + pad,
  };
}

function centeredExtent(bbox, width, height) {
  const cx = (bbox.minLon + bbox.maxLon) / 2;
  const cy = (bbox.minLat + bbox.maxLat) / 2;
  return {
    minLon: cx - width / 2,
    minLat: cy - height / 2,
    maxLon: cx + width / 2,
    maxLat: cy + height / 2,
  };
}

function extentString(bbox) {
  return `${bbox.minLon},${bbox.minLat},${bbox.maxLon},${bbox.maxLat}`;
}

function featureBounds(feature) {
  if (!feature?.geometry?.coordinates) {
    throw new Error("No feature available for preview extent");
  }
  const coords = [];
  collectCoords(feature.geometry.coordinates, coords);
  if (!coords.length) {
    throw new Error("Preview feature has no coordinates");
  }
  return {
    minLon: Math.min(...coords.map((p) => p[0])),
    minLat: Math.min(...coords.map((p) => p[1])),
    maxLon: Math.max(...coords.map((p) => p[0])),
    maxLat: Math.max(...coords.map((p) => p[1])),
  };
}

function writeGeoJson(dir, name, content) {
  const file = path.join(dir, name);
  fs.writeFileSync(file, content);
  const count = JSON.parse(content).features?.length ?? 0;
  console.log(`${file}\tfeatures=${count}`);
}

function writeJson(file, value) {
  fs.writeFileSync(file, JSON.stringify(value));
  console.log(`${file}\tfeatures=${value.features.length}`);
}

function emptyCollection() {
  return { type: "FeatureCollection", features: [] };
}

function splitLayers(dir, arrowScaleValue, maxCornerDimensionMeters, osm) {
  const plain = JSON.parse(fs.readFileSync(path.join(dir, "plain.geojson"), "utf8"));
  const lanePolygons = JSON.parse(fs.readFileSync(path.join(dir, "lane_polygons.geojson"), "utf8"));
  const markings = JSON.parse(fs.readFileSync(path.join(dir, "lane_markings.geojson"), "utf8"));
  const intersections = JSON.parse(fs.readFileSync(path.join(dir, "intersection_markings.geojson"), "utf8"));
  const network = JSON.parse(fs.readFileSync(path.join(dir, "network.json"), "utf8"));
  const crosswalkData = buildCrosswalks(osm, lanePolygons.features);
  const serviceWayIds = new Set([...osm.ways.values()]
    .filter((way) => way.tags.highway === "service")
    .map((way) => way.id));
  const out = {
    roadSurface: emptyCollection(),
    intersectionSurface: emptyCollection(),
    sidewalks: emptyCollection(),
    laneSeparators: emptyCollection(),
    centerLines: emptyCollection(),
    vehicleStopLines: crosswalkData.stopLines,
    laneArrows: emptyCollection(),
    sidewalkCorners: buildSidewalkCorners(intersections, plain, network, maxCornerDimensionMeters),
    crosswalks: crosswalkData.stripes,
  };
  const serviceDrivingPolygons = [];

  for (const feature of plain.features || []) {
    if (feature.properties?.type === "intersection") {
      out.intersectionSurface.features.push(feature);
    }
  }
  for (const feature of lanePolygons.features || []) {
    const type = feature.properties?.type;
    if (type === "Sidewalk" || type === "Footway") {
      out.sidewalks.features.push(feature);
    } else {
      out.roadSurface.features.push(feature);
      if (type === "Driving" && hasAnyWayId(feature.properties?.osm_way_ids, serviceWayIds)) {
        serviceDrivingPolygons.push({
          bbox: featureBounds(feature),
          rings: polygonRings(feature.geometry),
        });
      }
    }
  }

  for (const feature of markings.features || []) {
    const type = feature.properties?.type;
    const conflictsWithCrosswalk = isInAnyPolygon(feature, crosswalkData.zones, "intersects");
    if (type === "lane separator" && !conflictsWithCrosswalk) out.laneSeparators.features.push(feature);
    if (type === "center line" && !conflictsWithCrosswalk && !isInAnyPolygon(feature, serviceDrivingPolygons)) out.centerLines.features.push(feature);
    if (type === "lane arrow" && !conflictsWithCrosswalk && !isInAnyPolygon(feature, serviceDrivingPolygons)) {
      out.laneArrows.features.push(scaleFeature(feature, arrowScaleValue));
    }
  }

  return out;
}

function hasAnyWayId(value, ids) {
  const values = Array.isArray(value) ? value : [value];
  return values.some((id) => ids.has(Number(id)));
}

function filteredSidewalkCorners(intersections, maxDimensionMeters) {
  const out = emptyCollection();
  for (const feature of intersections.features || []) {
    if (feature.properties?.type !== "sidewalk corner") continue;
    const dimension = maxFeatureDimensionMeters(feature);
    if (dimension === null || dimension > maxDimensionMeters) continue;
    out.features.push(feature);
  }
  return out;
}

function buildSidewalkCorners(intersections, plain, network, maxDimensionMeters) {
  const out = filteredSidewalkCorners(intersections, maxDimensionMeters);
  const missing = synthesizeMissingSidewalkCorners(out, plain, network, maxDimensionMeters);
  out.features.push(...missing);
  const caps = synthesizeTJunctionSidewalkCaps(out, plain, network, maxDimensionMeters);
  out.features.push(...caps);
  return out;
}

function synthesizeMissingSidewalkCorners(existing, plain, network, maxDimensionMeters) {
  const roadFeatures = new Map((plain.features || [])
    .filter((feature) => feature.properties?.type === "road")
    .map((feature) => [Number(feature.properties.id), feature]));
  const intersectionFeatures = new Map((plain.features || [])
    .filter((feature) => feature.properties?.type === "intersection")
    .map((feature) => [Number(feature.properties.id), feature]));
  const roads = new Map((network.roads || []).map(([id, road]) => [Number(id), road]));
  const intersections = new Map((network.intersections || []).map(([id, intersection]) => [Number(id), intersection]));
  const existingByIntersection = assignCornersToIntersections(existing.features || [], intersectionFeatures);
  const synthesized = [];

  for (const [intersectionId, intersection] of intersections.entries()) {
    const intersectionFeature = intersectionFeatures.get(intersectionId);
    if (!intersectionFeature || intersection.roads.length < 2) continue;

    const edges = buildIntersectionEdges(intersection, roads, roadFeatures, intersectionFeature);
    if (!edges.length) continue;
    const qualifyingPairs = qualifyingCornerPairs(edges);
    if (!qualifyingPairs.length) continue;

    const current = existingByIntersection.get(intersectionId) || [];
    const currentCenters = current.map((entry) => entry.center);
    const missing = [];

    for (const [one, two] of qualifyingPairs) {
      const candidate = synthesizeCornerFeature(one, two, intersectionFeature, maxDimensionMeters);
      if (!candidate) continue;

      const candidateCenter = featureCenter(candidate);
      if (!candidateCenter || !pointInPolygon(candidateCenter, intersectionFeature.geometry.coordinates)) continue;
      const dimension = maxFeatureDimensionMeters(candidate);
      if (dimension === null || dimension > maxDimensionMeters) continue;
      if (polygonAreaMeters2(candidate) < 0.4) continue;
      if (currentCenters.some((point) => pointDistance(point, candidateCenter) <= 0.6)) continue;
      missing.push(candidate);
    }

    if (missing.length !== 1) continue;
    synthesized.push(missing[0]);
  }

  return synthesized;
}

function synthesizeTJunctionSidewalkCaps(existing, plain, network, maxDimensionMeters) {
  const roadFeatures = new Map((plain.features || [])
    .filter((feature) => feature.properties?.type === "road")
    .map((feature) => [Number(feature.properties.id), feature]));
  const intersectionFeatures = new Map((plain.features || [])
    .filter((feature) => feature.properties?.type === "intersection")
    .map((feature) => [Number(feature.properties.id), feature]));
  const roads = new Map((network.roads || []).map(([id, road]) => [Number(id), road]));
  const intersections = new Map((network.intersections || []).map(([id, intersection]) => [Number(id), intersection]));
  const existingByIntersection = assignCornersToIntersections(existing.features || [], intersectionFeatures);
  const synthesized = [];

  for (const [intersectionId, intersection] of intersections.entries()) {
    const intersectionFeature = intersectionFeatures.get(intersectionId);
    if (!intersectionFeature) continue;
    if (intersectionFeature.properties?.intersection_kind !== "Intersection") continue;
    if (new Set(intersection.roads || []).size !== 3) continue;

    const edges = buildIntersectionEdges(intersection, roads, roadFeatures, intersectionFeature);
    if (!edges.length) continue;
    const current = existingByIntersection.get(intersectionId) || [];
    const smallCurrent = current.filter((entry) => {
      const dimension = maxFeatureDimensionMeters(entry.feature);
      return Number.isFinite(dimension) && dimension <= maxDimensionMeters;
    });
    if (smallCurrent.length !== 2) continue;

    const candidates = [];
    for (const [one, two] of qualifyingCornerPairs(edges)) {
      const candidate = synthesizeCornerFeature(one, two, intersectionFeature, 100);
      if (!candidate) continue;
      const center = featureCenter(candidate);
      const dimension = maxFeatureDimensionMeters(candidate);
      const area = polygonAreaMeters2(candidate);
      if (!center || !Number.isFinite(dimension) || !Number.isFinite(area)) continue;
      candidates.push({ feature: candidate, center, dimension, area });
    }

    // For a true T-junction, the remaining large candidate is the sidewalk "cap"
    // opposite the side street, not another curb-return corner.
    const caps = candidates.filter(({ dimension, area, center }) => (
      dimension > maxDimensionMeters &&
      dimension <= 12 &&
      area >= 6 &&
      area <= 20 &&
      pointInPolygon(center, intersectionFeature.geometry.coordinates) &&
      !smallCurrent.some((entry) => pointDistance(entry.center, center) <= 1)
    ));
    if (caps.length !== 1) continue;
    caps[0].feature.properties.source = "fallback_t_cap";
    synthesized.push(caps[0].feature);
  }

  return synthesized;
}

function assignCornersToIntersections(features, intersectionFeatures) {
  const out = new Map();
  for (const feature of features) {
    const point = featureCenter(feature);
    if (!point) continue;
    for (const [intersectionId, intersectionFeature] of intersectionFeatures.entries()) {
      if (!pointInPolygon(point, intersectionFeature.geometry.coordinates)) continue;
      const bucket = out.get(intersectionId) || [];
      bucket.push({
        feature,
        center: point,
      });
      out.set(intersectionId, bucket);
      break;
    }
  }
  return out;
}

function buildIntersectionEdges(intersection, roads, roadFeatures, intersectionFeature) {
  const edges = [];
  for (const roadId of intersection.roads || []) {
    const road = roads.get(Number(roadId));
    const roadFeature = roadFeatures.get(Number(roadId));
    if (!road || !roadFeature) return [];
    const geometry = roadEndpointGeometry(road, roadFeature, intersectionFeature, intersection.id);
    if (!geometry) return [];
    const first = road.dst_i === intersection.id
      ? makeRoadEdge(road, geometry, "right")
      : makeRoadEdge(road, geometry, "left");
    const second = road.dst_i === intersection.id
      ? makeRoadEdge(road, geometry, "left")
      : makeRoadEdge(road, geometry, "right");
    if (!first || !second) return [];
    edges.push(first, second);
  }
  return edges;
}

function qualifyingCornerPairs(edges) {
  if (!edges.length) return [];
  const loop = [...edges, edges[0]];
  const pairs = [];
  for (let i = 0; i < loop.length - 1; i += 1) {
    const one = loop[i];
    const two = loop[i + 1];
    if (one.roadId === two.roadId) continue;
    if (!isWalkableOuterLane(one.laneType) || !isWalkableOuterLane(two.laneType)) continue;
    if (one.laneCount === 1 || two.laneCount === 1) continue;
    pairs.push([one, two]);
  }
  return pairs;
}

function isWalkableOuterLane(type) {
  return type === "Sidewalk" || type === "Shoulder";
}

function roadEndpointGeometry(road, roadFeature, intersectionFeature, intersectionId) {
  const ring = normalizedRing(roadFeature.geometry.coordinates?.[0]);
  if (ring.length !== 4) return null;

  const shortEdges = shortEdgePairs(ring);
  if (!shortEdges) return null;
  const intersectionCenter = ringCenter(intersectionFeature.geometry.coordinates[0]);
  const candidates = shortEdges.map(([a, b]) => {
    const near = [ring[a], ring[b]];
    return {
      pair: [a, b],
      center: midpoint(near[0], near[1]),
      distance: pointDistanceMeters(midpoint(near[0], near[1]), intersectionCenter, metersForLat(intersectionCenter[1])),
    };
  });
  candidates.sort((a, b) => a.distance - b.distance);
  const nearPair = candidates[0].pair;
  const farPair = candidates[1].pair;

  const nearPoints = nearPair.map((idx) => ring[idx]);
  const farPoints = farPair.map((idx) => ring[idx]);
  const nearCenter = midpoint(nearPoints[0], nearPoints[1]);
  const farCenter = midpoint(farPoints[0], farPoints[1]);
  const roadDirection = road.src_i === intersectionId
    ? normalizeLonLatVector([farCenter[0] - nearCenter[0], farCenter[1] - nearCenter[1]], nearCenter[1])
    : normalizeLonLatVector([nearCenter[0] - farCenter[0], nearCenter[1] - farCenter[1]], nearCenter[1]);
  if (!roadDirection) return null;

  const correspondences = nearPair.map((idx) => {
    const farIdx = farPair.find((candidate) => circularIndexDistance(idx, candidate, ring.length) === 1);
    return farIdx === undefined ? null : [ring[idx], ring[farIdx]];
  });
  if (correspondences.some((pair) => !pair)) return null;

  const classified = correspondences.map(([nearPoint, farPoint]) => ({
    near: nearPoint,
    far: farPoint,
    cross: signedSide(roadDirection, nearCenter, nearPoint, nearCenter[1]),
  })).sort((a, b) => a.cross - b.cross);

  return {
    nearCenter,
    nearLeft: classified[1].near,
    farLeft: classified[1].far,
    nearRight: classified[0].near,
    farRight: classified[0].far,
  };
}

function shortEdgePairs(ring) {
  const lengths = ring.map((point, index) => lineLengthMeters(point, ring[(index + 1) % ring.length]));
  const optionA = lengths[0] + lengths[2];
  const optionB = lengths[1] + lengths[3];
  if (!Number.isFinite(optionA) || !Number.isFinite(optionB)) return null;
  return optionA <= optionB
    ? [[0, 1], [2, 3]]
    : [[1, 2], [3, 0]];
}

function circularIndexDistance(a, b, size) {
  const distance = Math.abs(a - b);
  return Math.min(distance, size - distance);
}

function makeRoadEdge(road, geometry, side) {
  const lane = side === "left"
    ? road.lane_specs_ltr?.[0]
    : road.lane_specs_ltr?.[road.lane_specs_ltr.length - 1];
  if (!lane) return null;
  const outerNear = side === "left" ? geometry.nearLeft : geometry.nearRight;
  const outerFar = side === "left" ? geometry.farLeft : geometry.farRight;
  const oppositeNear = side === "left" ? geometry.nearRight : geometry.nearLeft;
  const oppositeFar = side === "left" ? geometry.farRight : geometry.farLeft;
  const widthMeters = Number(lane.width) / 10000;
  const innerNear = moveTowards(outerNear, oppositeNear, widthMeters);
  const innerFar = moveTowards(outerFar, oppositeFar, widthMeters);
  return {
    roadId: road.id,
    laneType: lane.lt,
    laneCount: road.lane_specs_ltr?.length || 0,
    outerNear,
    innerNear,
    innerFar,
  };
}

function synthesizeCornerFeature(one, two, intersectionFeature, maxDimensionMeters) {
  const ring = normalizedRing(intersectionFeature.geometry.coordinates?.[0]);
  const slice = shorterRingSliceBetween(ring, one.outerNear, two.outerNear);
  if (!slice || slice.length < 2) return null;

  const meetPoint = lineIntersection(one.innerFar, one.innerNear, two.innerFar, two.innerNear);
  const points = dedupeSequentialPoints([
    ...slice,
    two.innerNear,
    ...(meetPoint && pointInPolygon(meetPoint, intersectionFeature.geometry.coordinates) ? [meetPoint] : []),
    one.innerNear,
    slice[0],
  ]);
  if (points.length < 4) return null;

  const feature = {
    type: "Feature",
    properties: {
      type: "sidewalk corner",
      source: "fallback",
    },
    geometry: {
      type: "Polygon",
      coordinates: [points],
    },
  };
  const dimension = maxFeatureDimensionMeters(feature);
  if (dimension === null || dimension > maxDimensionMeters) return null;
  return feature;
}

function shorterRingSliceBetween(ring, start, end) {
  if (!ring.length) return null;
  const startIndex = nearestRingPointIndex(ring, start, 0.8);
  const endIndex = nearestRingPointIndex(ring, end, 0.8);
  if (startIndex === null || endIndex === null) return null;
  if (startIndex === endIndex) return [ring[startIndex]];
  const forward = walkRing(ring, startIndex, endIndex, 1);
  const backward = walkRing(ring, startIndex, endIndex, -1);
  return pathLengthMeters(forward) <= pathLengthMeters(backward) ? forward : backward;
}

function walkRing(ring, startIndex, endIndex, direction) {
  const out = [ring[startIndex]];
  let index = startIndex;
  while (index !== endIndex) {
    index = (index + direction + ring.length) % ring.length;
    out.push(ring[index]);
  }
  return out;
}

function pathLengthMeters(points) {
  let total = 0;
  for (let i = 1; i < points.length; i += 1) total += lineLengthMeters(points[i - 1], points[i]);
  return total;
}

function lineIntersection(a1, a2, b1, b2) {
  const originLat = (a1[1] + a2[1] + b1[1] + b2[1]) / 4;
  const meters = metersForLat(originLat);
  const ax1 = 0;
  const ay1 = 0;
  const ax2 = (a2[0] - a1[0]) * meters.lon;
  const ay2 = (a2[1] - a1[1]) * meters.lat;
  const bx1 = (b1[0] - a1[0]) * meters.lon;
  const by1 = (b1[1] - a1[1]) * meters.lat;
  const bx2 = (b2[0] - a1[0]) * meters.lon;
  const by2 = (b2[1] - a1[1]) * meters.lat;
  const denominator = (ax2 - ax1) * (by2 - by1) - (ay2 - ay1) * (bx2 - bx1);
  if (Math.abs(denominator) < 1e-9) return null;
  const ua = ((bx2 - bx1) * (ay1 - by1) - (by2 - by1) * (ax1 - bx1)) / denominator;
  return [
    a1[0] + ((ax1 + ua * (ax2 - ax1)) / meters.lon),
    a1[1] + ((ay1 + ua * (ay2 - ay1)) / meters.lat),
  ];
}

function normalizedRing(ring) {
  if (!Array.isArray(ring) || ring.length < 4) return [];
  const out = ring.map((point) => [point[0], point[1]]);
  if (pointDistance(out[0], out[out.length - 1]) <= 0.02) out.pop();
  return out;
}

function nearestRingPointIndex(ring, point, maxDistanceMeters) {
  let bestIndex = null;
  let bestDistance = Infinity;
  for (let i = 0; i < ring.length; i += 1) {
    const distance = pointDistance(ring[i], point);
    if (distance < bestDistance) {
      bestDistance = distance;
      bestIndex = i;
    }
  }
  return bestDistance <= maxDistanceMeters ? bestIndex : null;
}

function nearestRingPoint(ring, point, maxDistanceMeters) {
  const normalized = normalizedRing(ring);
  const index = nearestRingPointIndex(normalized, point, maxDistanceMeters);
  return index === null ? null : normalized[index];
}

function dedupeSequentialPoints(points, toleranceMeters = 0.02) {
  const out = [];
  for (const point of points) {
    if (!out.length || pointDistance(out[out.length - 1], point) > toleranceMeters) out.push(point);
  }
  if (out.length >= 2 && pointDistance(out[0], out[out.length - 1]) > toleranceMeters) out.push(out[0]);
  return out;
}

function dedupePointList(points, toleranceMeters) {
  const out = [];
  for (const point of points) {
    if (out.some((other) => pointDistance(point, other) <= toleranceMeters)) continue;
    out.push(point);
  }
  return out;
}

function midpoint(a, b) {
  return [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
}

function moveTowards(from, to, distanceMeters) {
  const meters = metersForLat((from[1] + to[1]) / 2);
  const unit = normalizeMetersVector([to[0] - from[0], to[1] - from[1]], meters);
  if (!unit) return from;
  return addMeters(from, unit, distanceMeters, meters);
}

function normalizeLonLatVector([dxLon, dyLat], lat) {
  return normalizeMetersVector([dxLon, dyLat], metersForLat(lat));
}

function signedSide(direction, origin, point, lat) {
  const meters = metersForLat(lat);
  const dx = (point[0] - origin[0]) * meters.lon;
  const dy = (point[1] - origin[1]) * meters.lat;
  return direction[0] * dy - direction[1] * dx;
}

function pointDistance(a, b) {
  return lineLengthMeters(a, b);
}

function lineLengthMeters(a, b) {
  const meters = metersForLat((a[1] + b[1]) / 2);
  return Math.hypot((a[0] - b[0]) * meters.lon, (a[1] - b[1]) * meters.lat);
}

function ringCenter(ring) {
  const points = normalizedRing(ring);
  const xs = points.map((point) => point[0]);
  const ys = points.map((point) => point[1]);
  return [(Math.min(...xs) + Math.max(...xs)) / 2, (Math.min(...ys) + Math.max(...ys)) / 2];
}

function polygonAreaMeters2(feature) {
  const ring = normalizedRing(feature.geometry?.coordinates?.[0]);
  if (ring.length < 3) return 0;
  const meters = metersForLat(ring.reduce((sum, point) => sum + point[1], 0) / ring.length);
  let area = 0;
  for (let i = 0; i < ring.length; i += 1) {
    const a = ring[i];
    const b = ring[(i + 1) % ring.length];
    area += (a[0] * meters.lon) * (b[1] * meters.lat) - (b[0] * meters.lon) * (a[1] * meters.lat);
  }
  return Math.abs(area) / 2;
}

function maxFeatureDimensionMeters(feature) {
  const points = [];
  collectCoords(feature.geometry?.coordinates, points);
  if (points.length === 0) return null;
  const lat = points.reduce((sum, point) => sum + point[1], 0) / points.length;
  const meters = metersForLat(lat);
  const xs = points.map((point) => point[0]);
  const ys = points.map((point) => point[1]);
  const width = (Math.max(...xs) - Math.min(...xs)) * meters.lon;
  const height = (Math.max(...ys) - Math.min(...ys)) * meters.lat;
  return Math.max(width, height);
}

function polygonRings(geometry) {
  if (!geometry?.coordinates) return [];
  if (geometry.type === "Polygon") return [geometry.coordinates];
  if (geometry.type === "MultiPolygon") return geometry.coordinates;
  return [];
}

function isInAnyPolygon(feature, polygons, mode = "point") {
  if (!polygons.length) return false;
  const featureBbox = featureBounds(feature);
  const points = mode === "intersects" ? featurePoints(feature) : [representativePoint(feature)].filter(Boolean);
  if (!points.length) return false;
  return polygons.some(({ bbox, rings }) => (
    bboxesOverlap(featureBbox, bbox, 0.00001) &&
    points.some((point) => (
      point[0] >= bbox.minLon - 0.00001 &&
      point[0] <= bbox.maxLon + 0.00001 &&
      point[1] >= bbox.minLat - 0.00001 &&
      point[1] <= bbox.maxLat + 0.00001 &&
      rings.some((polygon) => pointInPolygon(point, polygon))
    ))
  ));
}

function featurePoints(feature) {
  const coords = [];
  collectCoords(feature.geometry?.coordinates, coords);
  if (!coords.length) return [];
  return [
    coords[0],
    coords[Math.floor(coords.length / 2)],
    coords[coords.length - 1],
    ...bboxCorners(featureBounds(feature)),
  ];
}

function bboxCorners(bbox) {
  return [
    [bbox.minLon, bbox.minLat],
    [bbox.maxLon, bbox.minLat],
    [bbox.maxLon, bbox.maxLat],
    [bbox.minLon, bbox.maxLat],
  ];
}

function bboxesOverlap(a, b, pad = 0) {
  return a.minLon <= b.maxLon + pad &&
    a.maxLon >= b.minLon - pad &&
    a.minLat <= b.maxLat + pad &&
    a.maxLat >= b.minLat - pad;
}

function representativePoint(feature) {
  const coords = [];
  collectCoords(feature.geometry?.coordinates, coords);
  if (!coords.length) return null;
  return coords[Math.floor(coords.length / 2)];
}

function featureCenter(feature) {
  const coords = [];
  collectCoords(feature.geometry?.coordinates, coords);
  if (!coords.length) return null;
  const xs = coords.map((point) => point[0]);
  const ys = coords.map((point) => point[1]);
  return [(Math.min(...xs) + Math.max(...xs)) / 2, (Math.min(...ys) + Math.max(...ys)) / 2];
}

function suppressNearestStandardLaneArrows(standardFeatures, customFeatures) {
  const groups = new Map();
  for (const feature of customFeatures) {
    const id = feature.properties?.custom_arrow_id;
    if (!id) continue;
    const group = groups.get(id) || [];
    group.push(feature);
    groups.set(id, group);
  }
  const suppressed = new Set();
  for (const parts of groups.values()) {
    const center = featureGroupCenter(parts);
    if (!center) continue;
    let closest = null;
    for (const feature of standardFeatures) {
      if (suppressed.has(feature)) continue;
      const candidateCenter = featureCenter(feature);
      if (!candidateCenter) continue;
      const distance = lineLengthMeters(center, candidateCenter);
      if (distance > 5.5 || (closest && distance >= closest.distance)) continue;
      closest = { feature, distance };
    }
    if (closest) suppressed.add(closest.feature);
  }
  return suppressed;
}

function featureGroupCenter(features) {
  const points = [];
  for (const feature of features) collectCoords(feature.geometry?.coordinates, points);
  if (!points.length) return null;
  return [
    (Math.min(...points.map((point) => point[0])) + Math.max(...points.map((point) => point[0]))) / 2,
    (Math.min(...points.map((point) => point[1])) + Math.max(...points.map((point) => point[1]))) / 2,
  ];
}

function pointInPolygon(point, rings) {
  if (!rings?.length || !pointInRing(point, rings[0])) return false;
  return !rings.slice(1).some((ring) => pointInRing(point, ring));
}

function pointInRing([x, y], ring) {
  let inside = false;
  for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
    const xi = ring[i][0];
    const yi = ring[i][1];
    const xj = ring[j][0];
    const yj = ring[j][1];
    const intersect = ((yi > y) !== (yj > y)) &&
      x < ((xj - xi) * (y - yi)) / (yj - yi) + xi;
    if (intersect) inside = !inside;
  }
  return inside;
}

function buildCrosswalks(osm, lanePolygons = []) {
  const crossingNodes = markedCrossingNodes(osm);
  const clusterCenters = crossingClusters(crossingNodes);
  const stripes = emptyCollection();
  const stopLines = emptyCollection();
  const zones = [];
  const fixedCenters = [];
  for (const node of crossingNodes) {
    const way = findCrossingWay(osm, node.id);
    const vector = crossingVector(osm, way, node.id);
    if (!vector) continue;
    const crosswalk = crosswalkGeometry(node, way, vector, clusterCenters.get(node.id), lanePolygons);
    if (!crosswalk) continue;
    if (fixedCenters.some((center) => pointDistanceMeters(center, crosswalk.center, crosswalk.meters) < 1)) continue;
    fixedCenters.push(crosswalk.center);
    stripes.features.push(...crosswalk.stripes);
    if (crosswalk.stopLine) stopLines.features.push(crosswalk.stopLine);
    zones.push({
      bbox: featureBounds(crosswalk.zone),
      rings: polygonRings(crosswalk.zone.geometry),
    });
  }
  return { stripes, stopLines, zones };
}

function markedCrossingNodes(osm) {
  return [...osm.nodes.values()].filter((node) => {
    if (node.tags.highway !== "crossing") return false;
    const markings = node.tags["crossing:markings"];
    return !(markings && ["no", "none", "unmarked"].includes(markings));
  });
}

function crossingNodeClusters(nodes) {
  const clusters = [];
  for (const node of nodes) {
    let cluster = clusters.find((candidate) => {
      const center = clusterCenter(candidate);
      return distanceMeters(node, center) <= 45;
    });
    if (!cluster) {
      cluster = [];
      clusters.push(cluster);
    }
    cluster.push(node);
  }
  return clusters;
}

function crossingClusters(nodes) {
  const clusters = crossingNodeClusters(nodes);
  const centers = new Map();
  for (const cluster of clusters) {
    if (cluster.length < 2) continue;
    const center = clusterCenter(cluster);
    for (const node of cluster) centers.set(node.id, center);
  }
  return centers;
}

function clusterCenter(nodes) {
  return {
    lon: nodes.reduce((sum, node) => sum + node.lon, 0) / nodes.length,
    lat: nodes.reduce((sum, node) => sum + node.lat, 0) / nodes.length,
  };
}

function distanceMeters(a, b) {
  const meters = metersForLat((a.lat + b.lat) / 2);
  return Math.hypot((a.lon - b.lon) * meters.lon, (a.lat - b.lat) * meters.lat);
}

function findCrossingWay(osm, nodeId) {
  const candidates = [...osm.ways.values()]
    .filter((way) => way.tags.highway && way.refs.includes(nodeId));
  return candidates.find((way) => way.tags.highway !== "service") || candidates[0] || null;
}

function crossingVector(osm, way, nodeId) {
  if (!way) return null;
  const index = way.refs.indexOf(nodeId);
  const prev = osm.nodes.get(way.refs[index - 1]);
  const next = osm.nodes.get(way.refs[index + 1]);
  const current = osm.nodes.get(nodeId);
  if (prev && next) return [next.lon - prev.lon, next.lat - prev.lat];
  if (prev && current) return [current.lon - prev.lon, current.lat - prev.lat];
  if (next && current) return [next.lon - current.lon, next.lat - current.lat];
  return null;
}

function crosswalkGeometry(node, way, vector, intersectionCenter, lanePolygons) {
  const meters = metersForLat(node.lat);
  const stripeLength = crosswalkLengthMeters(way);
  const stripeWidth = 0.45;
  const gap = 0.45;
  const count = 6;
  const total = count * stripeWidth + (count - 1) * gap;
  const rawRoadUnit = normalizeMetersVector(vector, meters);
  if (!rawRoadUnit) return null;
  const provisionalCenter = fixedCrosswalkCenter(node, rawRoadUnit, intersectionCenter, meters);
  const laneFrame = crosswalkLaneFrame(way, lanePolygons, provisionalCenter, rawRoadUnit, meters);
  const roadUnit = laneFrame?.roadUnit || rawRoadUnit;
  const acrossUnit = [-roadUnit[1], roadUnit[0]];
  const center = laneFrame?.center || provisionalCenter;
  const zoneCoords = rectangleMeters(center, roadUnit, acrossUnit, stripeLength + 0.8, total + 0.8, meters);
  const zone = {
    type: "Feature",
    properties: {
      type: "crosswalk zone",
      crossing_node_id: node.id,
    },
    geometry: { type: "Polygon", coordinates: [zoneCoords] },
  };
  const stripes = [];
  for (let i = 0; i < count; i += 1) {
    const offset = -total / 2 + stripeWidth / 2 + i * (stripeWidth + gap);
    const stripeCenter = addMeters(center, acrossUnit, offset, meters);
    const coords = rectangleMeters(stripeCenter, roadUnit, acrossUnit, stripeLength, stripeWidth, meters);
    stripes.push({
      type: "Feature",
      properties: {
        type: "crosswalk stripe",
        crossing_node_id: node.id,
        highway: way?.tags.highway || null,
      },
      geometry: { type: "Polygon", coordinates: [coords] },
    });
  }
  return {
    stripes,
    center,
    meters,
    zone,
    stopLine: syntheticStopLine(center, node.id, way, roadUnit, acrossUnit, stripeLength, total, intersectionCenter, meters),
  };
}

function crosswalkLaneFrame(way, lanePolygons, provisionalCenter, rawRoadUnit, meters) {
  if (!way || !Array.isArray(lanePolygons)) return null;
  const candidates = lanePolygons
    .filter((feature) => feature.properties?.type === "Driving" && hasAnyWayId(feature.properties?.osm_way_ids, new Set([way.id])))
    .map((feature) => nearestLaneAnchor(feature, provisionalCenter, meters))
    .filter(Boolean)
    .sort((a, b) => a.distance - b.distance);
  if (!candidates.length) return null;
  // A way may be represented by adjacent normalized road pieces. Keep the
  // nearby cross-section, including every directional lane, not a distant
  // piece that happens to retain the same OSM way ID.
  const maxDistance = candidates[0].distance + 8;
  const anchors = candidates.filter((anchor) => anchor.distance <= maxDistance);
  if (!anchors.length) return null;
  const center = anchors.reduce((sum, anchor) => [sum[0] + anchor.point[0], sum[1] + anchor.point[1]], [0, 0])
    .map((value) => value / anchors.length);
  const axis = anchors.reduce((sum, anchor) => {
    const sign = anchor.tangent[0] * rawRoadUnit[0] + anchor.tangent[1] * rawRoadUnit[1] >= 0 ? 1 : -1;
    return [sum[0] + anchor.tangent[0] * sign, sum[1] + anchor.tangent[1] * sign];
  }, [0, 0]);
  const roadUnit = normalizeMetersVector(axis, { lon: 1, lat: 1 });
  return roadUnit ? { center, roadUnit } : null;
}

function nearestLaneAnchor(feature, point, meters) {
  const centerline = drivingLaneCenterline(feature);
  if (!centerline) return null;
  let best = null;
  for (let index = 0; index < centerline.length - 1; index += 1) {
    const start = centerline[index];
    const end = centerline[index + 1];
    const closest = closestPointOnSegment(point, start, end, meters);
    const distance = pointDistanceMeters(closest, point, meters);
    const tangent = normalizeMetersVector([end[0] - start[0], end[1] - start[1]], meters);
    if (tangent && (!best || distance < best.distance)) best = { point: closest, distance, tangent };
  }
  return best;
}

function drivingLaneCenterline(feature) {
  const ring = feature.geometry?.type === "Polygon" ? feature.geometry.coordinates?.[0] : null;
  if (!ring || ring.length < 5) return null;
  const vertices = ring.slice(0, -1);
  const half = vertices.length / 2;
  if (!Number.isInteger(half) || half < 2) return null;
  return vertices.slice(0, half).map((point, index) => [
    (point[0] + vertices[vertices.length - 1 - index][0]) / 2,
    (point[1] + vertices[vertices.length - 1 - index][1]) / 2,
  ]);
}

function closestPointOnSegment(point, start, end, meters) {
  const dx = (end[0] - start[0]) * meters.lon;
  const dy = (end[1] - start[1]) * meters.lat;
  const px = (point[0] - start[0]) * meters.lon;
  const py = (point[1] - start[1]) * meters.lat;
  const lengthSquared = dx * dx + dy * dy;
  const ratio = lengthSquared ? Math.max(0, Math.min(1, (px * dx + py * dy) / lengthSquared)) : 0;
  return [start[0] + ratio * (end[0] - start[0]), start[1] + ratio * (end[1] - start[1])];
}

function fixedCrosswalkCenter(node, roadUnit, intersectionCenter, meters) {
  if (!intersectionCenter) return [node.lon, node.lat];
  const center = [intersectionCenter.lon, intersectionCenter.lat];
  const candidates = [
    addMeters(center, roadUnit, 7, meters),
    addMeters(center, roadUnit, -7, meters),
  ];
  const source = [node.lon, node.lat];
  return pointDistanceMeters(candidates[0], source, meters) <= pointDistanceMeters(candidates[1], source, meters)
    ? candidates[0]
    : candidates[1];
}

function syntheticStopLine(crosswalkCenter, crossingNodeId, way, roadUnit, acrossUnit, stripeLength, crosswalkWidth, intersectionCenter, meters) {
  if (!intersectionCenter) return null;
  const offset = stripeLength / 2 + 1.2;
  const candidateA = addMeters(crosswalkCenter, roadUnit, offset, meters);
  const candidateB = addMeters(crosswalkCenter, roadUnit, -offset, meters);
  const stopSide = pointDistanceMeters(candidateA, intersectionCenter, meters) >= pointDistanceMeters(candidateB, intersectionCenter, meters)
    ? 1
    : -1;
  const stopCenterOnRoad = stopSide === 1 ? candidateA : candidateB;
  const placement = stopLineLanePlacement(way, stripeLength, stopSide);
  const stopCenter = addMeters(stopCenterOnRoad, acrossUnit, placement.acrossOffset, meters);
  const coords = rectangleMeters(stopCenter, acrossUnit, roadUnit, placement.length, 0.45, meters);
  return {
    type: "Feature",
    properties: {
      type: "vehicle stop line",
      source: "crosswalk",
      crossing_node_id: crossingNodeId,
      highway: way?.tags.highway || null,
      stop_side: stopSide === 1 ? "with_way_outside" : "against_way_outside",
    },
    geometry: { type: "Polygon", coordinates: [coords] },
  };
}

function pointDistanceMeters(pointA, point, meters) {
  const [lon, lat] = Array.isArray(pointA) ? pointA : [pointA.lon, pointA.lat];
  const px = Array.isArray(point) ? point[0] : point.lon;
  const py = Array.isArray(point) ? point[1] : point.lat;
  return Math.hypot((lon - px) * meters.lon, (lat - py) * meters.lat);
}

function stopLineLanePlacement(way, roadWidth, stopSide) {
  if (isOneway(way)) {
    return { length: Math.max(2.8, roadWidth - 1.4), acrossOffset: 0 };
  }
  const halfWidth = roadWidth / 2;
  const innerGap = 0.15;
  const outerGap = 0.8;
  const laneWidth = Math.max(2.4, halfWidth - innerGap - outerGap);
  // China uses right-hand traffic. If the stop line is on the +roadUnit side,
  // the approaching traffic direction is -roadUnit, whose right side is +acrossUnit.
  const laneSide = stopSide === 1 ? 1 : -1;
  return {
    length: laneWidth,
    acrossOffset: laneSide * (innerGap + laneWidth / 2),
  };
}

function isOneway(way) {
  const value = String(way?.tags.oneway || "").toLowerCase();
  return ["yes", "true", "1"].includes(value);
}

function crosswalkLengthMeters(way) {
  const lanes = Number(way?.tags.lanes);
  if (Number.isFinite(lanes) && lanes > 0) return Math.max(5, lanes * 3.2 + 1.2);
  if (way?.tags.highway === "secondary") return 8.5;
  if (way?.tags.highway === "service") return 4.5;
  return 7.5;
}

function metersForLat(lat) {
  return {
    lon: 111320 * Math.cos((lat * Math.PI) / 180),
    lat: 110540,
  };
}

function normalizeMetersVector([dxLon, dyLat], meters) {
  const x = dxLon * meters.lon;
  const y = dyLat * meters.lat;
  const length = Math.hypot(x, y);
  if (!Number.isFinite(length) || length === 0) return null;
  return [x / length, y / length];
}

function addMeters([lon, lat], [ux, uy], distance, meters) {
  return [lon + (ux * distance) / meters.lon, lat + (uy * distance) / meters.lat];
}

function rectangleMeters(center, axisUnit, acrossUnit, axisWidth, acrossLength, meters) {
  const halfAxis = axisWidth / 2;
  const halfAcross = acrossLength / 2;
  const corners = [
    [-halfAxis, -halfAcross],
    [halfAxis, -halfAcross],
    [halfAxis, halfAcross],
    [-halfAxis, halfAcross],
    [-halfAxis, -halfAcross],
  ];
  return corners.map(([axis, across]) => {
    const x = axisUnit[0] * axis + acrossUnit[0] * across;
    const y = axisUnit[1] * axis + acrossUnit[1] * across;
    return [center[0] + x / meters.lon, center[1] + y / meters.lat];
  });
}

function scaleFeature(feature, scale) {
  const coords = [];
  collectCoords(feature.geometry.coordinates, coords);
  if (!coords.length) return feature;
  const xs = coords.map((p) => p[0]);
  const ys = coords.map((p) => p[1]);
  const cx = (Math.min(...xs) + Math.max(...xs)) / 2;
  const cy = (Math.min(...ys) + Math.max(...ys)) / 2;
  return {
    type: "Feature",
    properties: { ...feature.properties, render_scale: scale },
    geometry: {
      ...feature.geometry,
      coordinates: scaleCoords(feature.geometry.coordinates, cx, cy, scale),
    },
  };
}

function collectCoords(obj, acc) {
  if (Array.isArray(obj) && obj.length >= 2 && typeof obj[0] === "number" && typeof obj[1] === "number") {
    acc.push([obj[0], obj[1]]);
  } else if (Array.isArray(obj)) {
    for (const item of obj) collectCoords(item, acc);
  }
}

function scaleCoords(obj, cx, cy, scale) {
  if (Array.isArray(obj) && obj.length >= 2 && typeof obj[0] === "number" && typeof obj[1] === "number") {
    return [cx + (obj[0] - cx) * scale, cy + (obj[1] - cy) * scale, ...obj.slice(2)];
  }
  if (Array.isArray(obj)) {
    return obj.map((item) => scaleCoords(item, cx, cy, scale));
  }
  return obj;
}

function normalizeLaneArrows(geojsonPath, outlineSimplifyMeters) {
  execFileSync(qgisPython, [
    normalizeLaneArrowsScript,
    "--input", geojsonPath,
    "--outline-simplify-meters", String(outlineSimplifyMeters),
  ], {
    stdio: "inherit",
    env: {
      ...process.env,
      ...qgis.env,
      QT_QPA_PLATFORM: "offscreen",
      ...qgis.pythonEnv,
    },
  });
}

function importLayer(gpkg, source, layerName, update, env) {
  const args = ["-f", "GPKG"];
  if (update) args.push("-update", "-overwrite");
  args.push(gpkg, source, "-nln", layerName);
  execFileSync(ogr2ogr, args, { stdio: "inherit", env: { ...process.env, ...env } });
}

function qgisLayerSpecs() {
  return SCENE_LAYERS.map((layer) => ({
    id: layer.id,
    title: layer.title,
    fill: qgisRgba(layer.fill),
    outline: qgisRgba(layer.outline, layer.outlineAlpha ?? 255),
    outlineWidth: String(layer.outlineWidth),
  }));
}

function makeQgisScript(options) {
  return `
from pathlib import Path

from qgis.PyQt.QtCore import QSize
from qgis.PyQt.QtGui import QColor, QImage, QPainter
from qgis.core import (
    QgsApplication,
    QgsCoordinateReferenceSystem,
    QgsEditorWidgetSetup,
    QgsFieldConstraints,
    QgsFillSymbol,
    QgsMarkerSymbol,
    QgsMapRendererCustomPainterJob,
    QgsMapSettings,
    QgsProject,
    QgsPalLayerSettings,
    QgsProperty,
    QgsRectangle,
    QgsSingleSymbolRenderer,
    QgsSymbolLayer,
    QgsSvgMarkerSymbolLayer,
    QgsVectorLayerSimpleLabeling,
    QgsVectorLayer,
)

QGIS_PREFIX = ${JSON.stringify(options.qgisPrefix)}
TRAFFIC_SIGNAL_SYMBOL = ${JSON.stringify(options.trafficSignalSymbolPath)}
GPKG = ${JSON.stringify(options.gpkgPath)}
PROJECT_PATH = ${JSON.stringify(options.projectPath)}
PREVIEW_PATH = ${JSON.stringify(options.previewPath)}
PREVIEW_EXTENT = [${options.previewExtent.split(",").map(Number).join(", ")}]
LAYER_PREFIX = ${JSON.stringify(options.layerPrefix || "osm2streets")}
LAYER_SPECS = ${JSON.stringify(qgisLayerSpecs(), null, 4)}

try:
    IMAGE_FORMAT = QImage.Format.Format_ARGB32_Premultiplied
except AttributeError:
    IMAGE_FORMAT = QImage.Format_ARGB32_Premultiplied

try:
    NOT_NULL_CONSTRAINT = QgsFieldConstraints.Constraint.ConstraintNotNull
except AttributeError:
    NOT_NULL_CONSTRAINT = QgsFieldConstraints.ConstraintNotNull

def fill_symbol(color, outline="0,0,0,0", outline_width="0"):
    return QgsFillSymbol.createSimple({
        "color": color,
        "outline_color": outline,
        "outline_width": outline_width,
        "outline_width_unit": "MM",
        "joinstyle": "round",
    })

def make_layer(layer_name, title, color, outline="0,0,0,0", outline_width="0"):
    layer = QgsVectorLayer(f"{GPKG}|layername={layer_name}", title, "ogr")
    if not layer.isValid():
        raise RuntimeError(f"Invalid layer: {title}")
    layer.setRenderer(QgsSingleSymbolRenderer(fill_symbol(color, outline, outline_width)))
    return layer

def make_signal_layer():
    layer = QgsVectorLayer(f"{GPKG}|layername=traffic_signal_assemblies", f"{LAYER_PREFIX} traffic signal assemblies", "ogr")
    if not layer.isValid():
        raise RuntimeError("Invalid traffic signal assemblies layer")
    symbol = QgsMarkerSymbol()
    svg_layer = QgsSvgMarkerSymbolLayer(TRAFFIC_SIGNAL_SYMBOL, 9)
    svg_layer.setDataDefinedProperty(
        QgsSymbolLayer.Property.Angle,
        QgsProperty.fromField("heading_deg"),
    )
    symbol.changeSymbolLayer(0, svg_layer)
    layer.setRenderer(QgsSingleSymbolRenderer(symbol))
    labels = QgsPalLayerSettings()
    labels.fieldName = "if(trim(display_id) = '', signal_uid, display_id)"
    labels.isExpression = True
    layer.setLabeling(QgsVectorLayerSimpleLabeling(labels))
    layer.setLabelsEnabled(True)
    for field_name in ("signal_uid", "control_id", "approach_id", "source_way_id", "stop_lon", "stop_lat"):
        index = layer.fields().indexOf(field_name)
        if index >= 0:
            layer.setFieldConstraint(index, NOT_NULL_CONSTRAINT)
            form = layer.editFormConfig()
            form.setReadOnly(index, True)
            layer.setEditFormConfig(form)
    enabled_index = layer.fields().indexOf("enabled")
    if enabled_index >= 0:
        layer.setEditorWidgetSetup(enabled_index, QgsEditorWidgetSetup("CheckBox", {"CheckedState": "1", "UncheckedState": "0"}))
    phase_index = layer.fields().indexOf("phase_group")
    if phase_index >= 0:
        layer.setEditorWidgetSetup(phase_index, QgsEditorWidgetSetup("ValueMap", {"map": [{"Phase 0": 0}, {"Phase 1": 1}]}))
    return layer

QgsApplication.setPrefixPath(QGIS_PREFIX, True)
app = QgsApplication([], False)
app.initQgis()

project = QgsProject.instance()
project.clear()
project.setFileName(PROJECT_PATH)
project.setCrs(QgsCoordinateReferenceSystem("EPSG:4326"))
project.setPresetHomePath(str(Path(PROJECT_PATH).parent))

layers = {
    spec["id"]: make_layer(
        spec["id"],
        f"{LAYER_PREFIX} {spec['title']}",
        spec["fill"],
        spec["outline"],
        spec["outlineWidth"],
    )
    for spec in LAYER_SPECS
}
signal_layer = make_signal_layer()
layers["traffic_signal_assemblies"] = signal_layer
draw_order = [spec["id"] for spec in LAYER_SPECS]
for key in draw_order:
    project.addMapLayer(layers[key], False)
project.addMapLayer(signal_layer, False)
root = project.layerTreeRoot()
for key in draw_order:
    root.insertLayer(0, layers[key])
root.insertLayer(0, signal_layer)
if not project.write(PROJECT_PATH):
    raise RuntimeError(f"Failed to write {PROJECT_PATH}")

settings = QgsMapSettings()
settings.setLayers([layers[key] for key in reversed(draw_order)])
settings.setDestinationCrs(QgsCoordinateReferenceSystem("EPSG:4326"))
settings.setExtent(QgsRectangle(*PREVIEW_EXTENT))
settings.setOutputSize(QSize(1600, 1100))
settings.setBackgroundColor(QColor(245, 245, 240))
image = QImage(settings.outputSize(), IMAGE_FORMAT)
image.fill(settings.backgroundColor().rgba())
painter = QPainter(image)
job = QgsMapRendererCustomPainterJob(settings, painter)
job.start()
job.waitForFinished()
painter.end()
image.save(PREVIEW_PATH)

print(PROJECT_PATH)
print(PREVIEW_PATH)
app.exitQgis()
`;
}

function fixCanvas(projectFile, extentCsv) {
  const fixScript = path.join(os.tmpdir(), `osm2streets_fix_canvas_${process.pid}.py`);
  const script = `
from pathlib import Path
import shutil
import zipfile
import xml.etree.ElementTree as ET

project_path = Path(${JSON.stringify(projectFile)})
extent_values = [${extentCsv.split(",").map(Number).join(", ")}]
work_dir = Path(${JSON.stringify(path.join(os.tmpdir(), `osm2streets_qgz_fix_${process.pid}`))})
if work_dir.exists():
    shutil.rmtree(work_dir)
work_dir.mkdir(parents=True)
with zipfile.ZipFile(project_path, "r") as zin:
    zin.extractall(work_dir)
qgs_files = list(work_dir.glob("*.qgs"))
if not qgs_files:
    raise RuntimeError("No .qgs file found inside project")
qgs_path = qgs_files[0]
tree = ET.parse(qgs_path)
root = tree.getroot()
old_canvas = root.find("mapcanvas")
if old_canvas is not None:
    root.remove(old_canvas)
project_crs = root.find("projectCrs/spatialrefsys")
canvas = ET.Element("mapcanvas", {"name": "theMapCanvas", "annotationsVisible": "1"})
ET.SubElement(canvas, "units").text = "degrees"
extent = ET.SubElement(canvas, "extent")
for key, value in zip(["xmin", "ymin", "xmax", "ymax"], extent_values):
    ET.SubElement(extent, key).text = str(value)
ET.SubElement(canvas, "rotation").text = "0"
dest = ET.SubElement(canvas, "destinationsrs")
if project_crs is not None:
    dest.append(ET.fromstring(ET.tostring(project_crs, encoding="unicode")))
ET.SubElement(canvas, "rendermaptile").text = "0"
ET.SubElement(canvas, "expressionContextScope")
layer_tree = root.find("layer-tree-group")
insert_at = list(root).index(layer_tree) + 1 if layer_tree is not None else 1
root.insert(insert_at, canvas)
ET.indent(tree, space="  ")
tree.write(qgs_path, encoding="UTF-8", xml_declaration=True)
tmp = project_path.with_suffix(".qgz.tmp")
with zipfile.ZipFile(tmp, "w", compression=zipfile.ZIP_DEFLATED) as zout:
    for f in sorted(work_dir.iterdir()):
        zout.write(f, f.name)
tmp.replace(project_path)
shutil.rmtree(work_dir)
`;
  fs.writeFileSync(fixScript, script);
  execFileSync("python3", [fixScript], { stdio: "inherit" });
  fs.unlinkSync(fixScript);
}