Plan sheets and plan-and-profile sheets as PDF

export function scalesFor(units) {
  if (units === 'm') return [50, 100, 200, 250, 500, 1000, 2000, 2500, 5000, 10000].map((n) => ({ label: '1:' + n, mmPerUnit: 1000 / n }));
  return [5, 10, 20, 30, 40, 50, 60, 100, 200, 300, 400, 500, 1000].map((n) => ({ label: `1" = ${n}'`, mmPerUnit: 25.4 / n }));
}

/** The largest standard scale at which the extents fit inside the sheet's drawing area. */
export function fitScale(units, ext, paper, landscape = true) {
  const { w, h } = orient(paper, landscape);
  const aw = w - 2 * MARGIN, ah = h - 2 * MARGIN - TITLE_H;
  const W = Math.max(ext.maxX - ext.minX, 1e-9), H = Math.max(ext.maxY - ext.minY, 1e-9);
  const list = scalesFor(units);
  for (const s of list.slice().sort((a, b) => b.mmPerUnit - a.mmPerUnit)) if (W * s.mmPerUnit <= aw && H * s.mmPerUnit <= ah) return s;
  return list[list.length - 1];
}

/** 0.4 V8: the drawing window of planSheet (the frame above the title strip) in project coordinates. */
export function sheetWindow(extents, { paper = 'tabloid', landscape = true, scale }) {
  const P = orient(paperBy(paper), landscape);
  const frame = { x0: MARGIN, y0: MARGIN + TITLE_H, x1: P.w - MARGIN, y1: P.h - MARGIN };
  const s = scale.mmPerUnit, cx = (extents.minX + extents.maxX) / 2, cy = (extents.minY + extents.maxY) / 2;
  const hw = (frame.x1 - frame.x0) / 2 / s, hh = (frame.y1 - frame.y0) / 2 / s;
  return { minX: cx - hw, maxX: cx + hw, minY: cy - hh, maxY: cy + hh };
}

const s = scale.mmPerUnit;
const cx = (extents.minX + extents.maxX) / 2, cy = (extents.minY + extents.maxY) / 2;
const ox = (frame.x0 + frame.x1) / 2 - cx * s, oy = (frame.y0 + frame.y1) / 2 - cy * s;
const tx = (p) => ({ x: p.x * s + ox, y: p.y * s + oy });

const want = 50 / s, pow = Math.pow(10, Math.floor(Math.log10(want))), len = [1, 2, 5, 10].map((m) => m * pow).filter((v) => v <= want).pop() || pow;
const sb = { x: frame.x1 - 4 - len * s, y: MARGIN + TITLE_H - 6 };

/** Cubic Béziers for an arc from angle a to b, ≤ 90° each: [x1 y1 x2 y2 x3 y3]. */
export function arcBeziers(cx, cy, r, a, b) {
  const sweep = b - a, n = Math.max(1, Math.ceil(Math.abs(sweep) / (Math.PI / 2) - 1e-9)), d = sweep / n, k = 4 / 3 * Math.tan(d / 4);
  const out = [];
  for (let i = 0; i < n; i++) {
    const t0 = a + d * i, t1 = t0 + d;
    const c0 = Math.cos(t0), s0 = Math.sin(t0), c1 = Math.cos(t1), s1 = Math.sin(t1);
    out.push([cx + r * (c0 - k * s0), cy + r * (s0 + k * c0), cx + r * (c1 + k * s1), cy + r * (s1 - k * c1), cx + r * c1, cy + r * s1]);
  }
  return out;
}

function num(v) {
  if (!Number.isFinite(v)) return '0';
  const s = (Math.abs(v) < 5e-5 ? 0 : v).toFixed(4);
  return s.includes('.') ? s.replace(/0+$/, '').replace(/\.$/, '') : s;
}

out.push((72 / 25.4).toFixed(9) + ' 0 0 ' + (72 / 25.4).toFixed(9) + ' 0 0 cm', '1 J 1 j');

export function sheetPlan(al, { paper = 'tabloid', landscape = true, scale, from, to, units = 'ft' } = {}) {
  const L = layout(paper, landscape);
  const a0 = Math.max(al.start, Number.isFinite(from) ? from : al.start), a1 = Math.min(al.end, Number.isFinite(to) ? to : al.end);
  const fits = (L.plan.x1 - L.plan.x0) / scale.mmPerUnit;
  // whole 50 ft (20 m) on long stretches, whole 10 ft (5 m) on short ones, so little of the window is wasted
  const round = units === 'm' ? (fits > 200 ? 20 : fits > 25 ? 5 : 0) : (fits > 500 ? 50 : fits > 50 ? 10 : 0);
  const length = round ? Math.floor(fits / round) * round : fits;
  const stations = [];
  for (let a = a0; a < a1 - 1e-6 && stations.length < 500; a += length) stations.push([a, Math.min(a1, a + length)]);
  return { length, stations, window: L };
}

/** The design profile across [a, b]: its own breakpoints (PVIs, vertical curves) inside, plus both ends. */
function designIn(profile, a, b) {
  if (!profile?.ok) return [];
  const st = new Set([a, b]);
  for (const q of profile.sample(Math.max((b - a) / 300, 0.05))) if (q.sta > a && q.sta < b) st.add(q.sta);
  return [...st].sort((m, n) => m - n).map((sta) => ({ sta, z: profile.elevationAt(sta) })).filter((q) => q.z !== null);
}

const need = Math.max(1e-9, ...ranges.filter(Boolean).map(([lo, hi]) => hi - lo));
const want = VEXES.includes(vex) ? vex : 10;
const used = VEXES.filter((v) => v <= want).find((v) => need * s * v <= hAvail) ?? 1;
if (used !== want) notes.push(t('pp.vex.lowered', { want, used }));
if (need * s * used > hAvail) notes.push(t('pp.vex.clipped'));
const sv = s * used;

const th = rotation(al, a, b), c = Math.cos(-th), sn = Math.sin(-th), pa = al.pointAt(a);
const rot = (p) => ({ x: (p.x - pa.x) * c - (p.y - pa.y) * sn, y: (p.x - pa.x) * sn + (p.y - pa.y) * c });
// centre the stretch vertically in the plan window
let ylo = Infinity, yhi = -Infinity;
for (let i = 0; i <= 40; i++) { const q = rot(al.pointAt(a + ((b - a) * i) / 40)); ylo = Math.min(ylo, q.y); yhi = Math.max(yhi, q.y); }
const ymid = (ylo + yhi) / 2, cy = (PW.y0 + PW.y1) / 2;
const tx = (p) => { const q = rot(p); return { x: PW.x0 + q.x * s, y: cy + (q.y - ymid) * s }; };

const zmid = (r[0] + r[1]) / 2, zSpan = (VW.y1 - VW.y0) / sv;
const zStepRaw = 6 / sv, zStep = [0.1, 0.2, 0.5, 1, 2, 5, 10, 20, 50, 100].find((v) => v >= zStepRaw) || 100;
const z0 = Math.floor((zmid - zSpan / 2) / zStep) * zStep;
const X = (sta) => VW.x0 + (sta - a) * s, Y = (z) => VW.y0 + (z - z0) * sv;

const hLabel = scale.label, vLabel = units === 'm' ? '1:' + Math.round(1000 / sv) : '1" = ' + String(+(25.4 / sv).toFixed(1)) + "'";