Coordinate system helpers

/** Catalog systems the project's coordinates fit (see the header). Sorted: state plane / UTM of current datums first, then
 *  the smallest area of use (the most specific system). */
export function systemsThatFit(pt, units, { limit = 60 } = {}) {
  if (!pt || !Number.isFinite(pt.x) || !Number.isFinite(pt.y)) return { list: [], total: 0 };
  const fam = familyOf(units);
  const all = search('', { limit: 1e6 }).filter((e) => !e.geographic && fam.includes(e.unit));
  const out = [];
  for (const e of all) {
    try {
      const t = transformer(e, null), [lon, lat] = t(pt.x, pt.y);
      if (!Number.isFinite(lon) || !Number.isFinite(lat) || !inArea(e.area, lon, lat)) continue;
      const back = transformer(null, e)(lon, lat);
      if (!(Math.hypot(back[0] - pt.x, back[1] - pt.y) < 1e-3)) continue;
      out.push({ entry: e, lon, lat });
    } catch { /* a definition proj4js cannot run here is just not a fit */ }
  }
  out.sort((a, b) => rankOf(a.entry) - rankOf(b.entry) || areaSize(a.entry.area) - areaSize(b.entry.area) || a.entry.code - b.entry.code);
  return { list: out.slice(0, limit), total: out.length };
}

function dmsOf(v, pos, neg) {
  let s = Math.round(Math.abs(v) * 360000) / 100; // hundredths of a second (about 0.3 m)
  const d = Math.floor(s / 3600); s -= d * 3600;
  const m = Math.floor(s / 60); s -= m * 60;
  return d + '°' + String(m).padStart(2, '0') + '′' + s.toFixed(2).padStart(5, '0') + '″ ' + (v >= 0 ? pos : neg);
}

/** Latitude and longitude for the status bar. */
export function latLonText(lon, lat, mode = 'dms') {
  if (!Number.isFinite(lon) || !Number.isFinite(lat)) return '';
  // i18n-ignore: hemisphere letters N S E W (symbols; parseLatLon reads them back)
  if (mode === 'dd') return Math.abs(lat).toFixed(6) + '° ' + (lat >= 0 ? 'N' : 'S') + '  ' + Math.abs(lon).toFixed(6) + '° ' + (lon >= 0 ? 'E' : 'W');
  return dmsOf(lat, 'N', 'S') + '  ' + dmsOf(lon, 'E', 'W');
}

function oneAngle(t) {
  let s = t.trim(), sign = 1, axis = null;
  const h = s.match(/^([NSEWnsew])\s*|\s*([NSEWnsew])$/);
  if (h) { const c = (h[1] || h[2]).toUpperCase(); axis = c === 'N' || c === 'S' ? 'lat' : 'lon'; if (c === 'S' || c === 'W') sign = -1; s = s.replace(/^[NSEWnsew]\s*|\s*[NSEWnsew]$/, ''); }
  if (s.startsWith('-')) { sign *= -1; s = s.slice(1); } else if (s.startsWith('+')) s = s.slice(1);
  const n = s.trim().split(/\s+/);
  if (!n.length || n.length > 3 || !n.every((x) => /^\d+(\.\d+)?$/.test(x))) return null;
  const [d, m = 0, sec = 0] = n.map(Number);
  if (n.length > 1 && (!Number.isInteger(d) || m >= 60 || sec >= 60)) return null;
  return { v: sign * (d + m / 60 + sec / 3600), axis };
}

/** The `local` step alone (crs.js frame().toGrid without a system): grid = to + scale · R(rotation) · (p − from). */
export function localToGrid(l, x, y) {
  const c = Math.cos(l.rotation * Math.PI / 180), s = Math.sin(l.rotation * Math.PI / 180), dx = x - l.from[0], dy = y - l.from[1];
  return [l.to[0] + l.scale * (c * dx - s * dy), l.to[1] + l.scale * (s * dx + c * dy)];
}

/** A third control point against a fit: where the fit puts its project coordinates vs its known grid coordinates. */
export function misclosure(local, pLocal, pGrid) {
  const g = localToGrid(local, pLocal[0], pLocal[1]);
  const dx = pGrid[0] - g[0], dy = pGrid[1] - g[1], dist = Math.hypot(dx, dy);
  const span = Math.hypot(pLocal[0] - local.from[0], pLocal[1] - local.from[1]);
  return { dx, dy, dist, ppm: span > 0 ? dist / span * 1e6 : null };
}

/** Converts every coordinate of a project (state + survey points) with map(x, y) → [x, y]. Call inside one undo step
 *  (Project.editPoints). Refuses a surface read from LandXML (its TIN is kept outside the undo snapshots). */
export function reprojectProject(state, points, map) {
  if (state.surface?.tin) return { points, moved: 0, refused: t('crs.reproject.tin') };
  let moved = 0;
  const xy = (q) => { const [x, y] = map(q.x, q.y); if (!Number.isFinite(x) || !Number.isFinite(y)) throw new Error(t('crs.reproject.coord')); q.x = x; q.y = y; moved++; };
  const pts = points.map((p) => { const [x, y] = map(p.x, p.y); if (!Number.isFinite(x) || !Number.isFinite(y)) throw new Error(t('crs.reproject.point', { n: p.n })); moved++; return { ...p, x, y }; });
  for (const b of state.surface?.breaklines || []) b.pts.forEach(xy);
  if (state.surface?.boundary) state.surface.boundary.forEach(xy);
  for (const a of state.alignments || []) a.pis.forEach(xy);
  for (const d of state.pads || []) d.pts.forEach(xy);
  for (const s of state.network?.structures || []) xy(s);
  return { points: pts, moved, refused: null };
}