Sheet scale: presets, calibration and drawing units

/** Real feet per PDF user-space unit for a preset (a unit is 1/72 in × userUnit on paper). */
export function presetFtPerUnit(key, userUnit = 1) {
  const p = PRESETS.get(key);
  if (!p) throw new Error('Unknown scale ' + key);   // i18n-ignore: a programming error
  return (userUnit / 72) * p.ratio / 12;
}

/** Two picked points (user space) and the real distance between them → ftPerUnit. */
export function calibrate(a, b, realFt) {
  const d = Math.hypot(b.x - a.x, b.y - a.y);
  if (!(d > 0.5)) return { ok: false, error: t('cal.err.near') };
  if (!(realFt > 0) || !Number.isFinite(realFt)) return { ok: false, error: t('len.err.positive') };
  return { ok: true, ftPerUnit: realFt / d, units: d };
}

/** The preset a scale matches within tol (relative), or null. */
export function matchPreset(ftPerUnit, userUnit = 1, tol = 0.005) {
  let best = null;
  for (const p of PRESETS.values()) {
    const s = presetFtPerUnit(p.key, userUnit);
    const err = Math.abs(ftPerUnit - s) / s;
    if (err <= tol && (!best || err < best.err)) best = { ...p, err };
  }
  return best;
}

const FT = { 1: 1 / 12, 2: 1, 3: 5280, 4: 0.001 / 0.3048, 5: 0.01 / 0.3048, 6: 1 / 0.3048, 7: 1000 / 0.3048, 8: 1e-6 / 12, 9: 0.001 / 12, 10: 3,
  14: 0.1 / 0.3048, 15: 10 / 0.3048, 16: 100 / 0.3048, 21: 1200 / 3937, 22: 100 / 3937 / 12, 23: 3600 / 3937, 24: 5280 * 1200 / 3937 };

/** The drawing's length unit: `{ code, name, feetPerUnit }`; feetPerUnit is null for "unitless" and units that are not lengths we know. */
export function drawingUnits(model) {
  const code = Number(model?.header?.INSUNITS);
  const ft = Number.isInteger(code) ? FT[code] : undefined;
  return { code: Number.isInteger(code) ? code : 0, name: UNIT_NAMES[code] || '', feetPerUnit: ft && Number.isFinite(ft) && ft > 0 ? ft : null };
}

/** A viewport's model → paper transform: about the view centre, scaled to the viewport, twisted, moved to its centre (as dwg-view.js). */
export function vpMatrix(vp) {
  const k = vp.h / vp.viewHeight, c = Math.cos(vp.twist || 0), sn = Math.sin(vp.twist || 0);
  return [k * c, k * sn, -k * sn, k * c, vp.cx - k * (c * vp.vx - sn * vp.vy), vp.cy - k * (sn * vp.vx + c * vp.vy)];
}

if (sp.kind === 'paper') {
  const ptU = sp.paperUnit === 'mm' ? PT_MM : PT_IN;
  const r = sp.paper || (b && fin(b.minX) && b.maxX > b.minX ? b : { minX: 0, minY: 0, maxX: 36, maxY: 24 });
  const w = Math.max(1, (r.maxX - r.minX) * ptU), h = Math.max(1, (r.maxY - r.minY) * ptU);
  sheet.toPage = [ptU, 0, 0, ptU, -r.minX * ptU, -r.minY * ptU];
  sheet.width = w; sheet.height = h;
  sheet.ptU = ptU;
  sheet.viewports = (sp.viewports || []).filter((v) => [v.cx, v.cy, v.w, v.h, v.vx, v.vy, v.viewHeight].every(fin) && v.viewHeight > 0)
    .map((v) => ({ ...v, m: mul(sheet.toPage, vpMatrix(v)), rect: { x0: v.cx - v.w / 2, y0: v.cy - v.h / 2, x1: v.cx + v.w / 2, y1: v.cy + v.h / 2 } }));
} else {
  const ok = b && fin(b.minX) && fin(b.maxX) && b.maxX >= b.minX && b.maxY >= b.minY;
  if (!ok) b = { minX: 0, minY: 0, maxX: 100, maxY: 100 };
  const ext = Math.max(b.maxX - b.minX, b.maxY - b.minY, 1e-9);
  const k = SIZE / ext;
  sheet.k = k;
  sheet.toPage = [k, 0, 0, k, -b.minX * k + PAD, -b.minY * k + PAD];
  sheet.width = (b.maxX - b.minX) * k + PAD * 2; sheet.height = (b.maxY - b.minY) * k + PAD * 2;
}

/**
 * The scale a sheet starts with, or null (and a reason in `sheet.note`). → { method: 'preset'|'drawing', ftPerUnit, preset?, label }
 * `ftPerUnit` is real feet per page unit. A scale the app can name (1/4" = 1'-0", 1:100…) becomes that preset.
 */
function sheetScale(sheet, units) {
  const ft = units.feetPerUnit;
  if (!ft) { sheet.note = units.code === 0 ? 'nounits' : 'badunits'; return null; }
  if (sheet.kind === 'model') {
    const f = ft / sheet.k;
    return { method: 'drawing', ftPerUnit: f, preset: null, label: t('cad.scale.units', { units: unitLabel(units) }) };
  }
  if (!sheet.viewports.length) { sheet.note = 'noviewport'; return null; }
  // the biggest viewport sets the sheet's scale; a sheet with viewports at other scales says so
  const biggest = [...sheet.viewports].sort((a, c) => c.w * c.h - a.w * a.h)[0];
  const s = biggest.h / biggest.viewHeight;                 // paper units per model unit
  if (!fin(s) || s <= 0) { sheet.note = 'noviewport'; return null; }
  const f = (1 / sheet.ptU) / s * ft;                       // feet per point
  sheet.mixed = sheet.viewports.some((v) => Math.abs(v.h / v.viewHeight / s - 1) > 0.01);
  return { method: 'drawing', ftPerUnit: f, preset: null, label: '', viewportScale: s };
}

/**
 * TD.2: a drawing's sheets start with the scale the drawing itself gives (INSUNITS, a layout's viewport scale), for the sheets that have
 * none yet — one undo step. A sheet with no usable units stays "No scale"; Calibrate and the scale menu override at any time.
 */
function applyDrawingScales(set) {
  const map = {};
  for (const sh of set.cad.sheets) {
    const key = sheetKey(set.hash, sh.index);
    if (!sh.scale || model.scaleOf(key)) continue;
    const sc = sh.scale;
    if (sh.kind === 'model') map[key] = U.scaleRecord({ method: 'drawing', ftPerUnit: sc.ftPerUnit, label: t('cad.scale.units', { units: cadMod.unitLabel(set.cad.units) }) });
    else {
      const pm = U.matchPreset(sc.ftPerUnit);
      map[key] = pm ? U.scaleRecord({ method: 'preset', preset: pm.key, ftPerUnit: U.presetFtPerUnit(pm.key), label: pm.label })
        : U.scaleRecord({ method: 'drawing', ftPerUnit: sc.ftPerUnit, label: t('cad.scale.viewport', { scale: U.describeScale(sc.ftPerUnit) }) });
    }
  }
  if (Object.keys(map).length) model.setScales(map, t('cad.scale.undo', { file: set.name }));
}

    const r = U.parseLength(input.value);
    if (!r.ok) return r.error;
    const c = U.calibrate(a, b, r.ft);
    if (!c.ok) return c.error;
    parsed = { ...c, ft: r.ft, text: input.value.trim() };
    return null;
  },
});
if (choice !== 'ok' || !parsed) { status(t('cal.canceled')); return; }
if (!(await confirmRescale())) return;
const m = U.matchPreset(parsed.ftPerUnit, cur.info.userUnit);
model.setScale(cur.key, U.scaleRecord({ method: 'calibrated', ftPerUnit: parsed.ftPerUnit, label: U.describeScale(parsed.ftPerUnit, cur.info.userUnit), cal: { a: [a.x, a.y], b: [b.x, b.y], ft: parsed.ft, text: parsed.text } }), 'Calibrate');