DWG and DXF linework into project units

const INSUNITS = {
  1: ['in', 0.0254], 2: ['ft', 0.3048], 3: ['mi', 1609.344], 4: ['mm', 0.001], 5: ['cm', 0.01], 6: ['m', 1], 7: ['km', 1000],
  8: ['microinch', 2.54e-8], 9: ['mil', 2.54e-5], 10: ['yd', 0.9144], 14: ['dm', 0.1], 21: ['ftUS', 1200 / 3937],
};

/** Drawing units → project units ('ft' = US survey feet, 'm'). */
export function unitScale(header, projectUnit = 'ft') {
  const u = cadUnits(header);
  const to = projectUnit === 'm' ? 'm' : 'ft';
  if (!u.metres) return { scale: 1, from: '', to, note: t('cad.units.unknown', { unit: t('cad.unit.' + to) }) };
  if (to === 'ft' && FEET.has(u.label)) return { scale: 1, from: u.label, to, note: u.label === 'ft' ? t('cad.units.feet') : null };
  if (to === 'm' && u.label === 'm') return { scale: 1, from: 'm', to, note: null };
  const projM = to === 'm' ? 1 : 1200 / 3937;
  // inches and other imperial lengths into a feet project: exact ratios to the international foot
  const scale = to === 'ft' && ['in', 'mi', 'yd', 'mil', 'microinch'].includes(u.label) ? u.metres / 0.3048 : u.metres / projM;
  return { scale, from: u.label, to, note: t('cad.units.scaled', { from: u.label, to: t('cad.unit.' + to), scale: +scale.toPrecision(10) }) };
}

/** OCS → WCS for an extrusion direction (DXF reference, "Arbitrary axis algorithm"); null for the plain +Z. */
export function ocs(ext) {
  if (!ext || !Number.isFinite(ext.x) || !Number.isFinite(ext.y) || !Number.isFinite(ext.z)) return null;
  const L = Math.hypot(ext.x, ext.y, ext.z);
  if (!L) return null;
  const az = [ext.x / L, ext.y / L, ext.z / L];
  if (Math.abs(az[0]) < 1e-12 && Math.abs(az[1]) < 1e-12 && az[2] > 0) return null;
  const cross = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
  let ax = Math.abs(az[0]) < 1 / 64 && Math.abs(az[1]) < 1 / 64 ? cross([0, 1, 0], az) : cross([0, 0, 1], az);
  const n = Math.hypot(...ax); ax = ax.map((v) => v / n);
  const ay = cross(az, ax);
  return [ax[0], ay[0], az[0], 0, ax[1], ay[1], az[1], 0, ax[2], ay[2], az[2], 0];
}

// ---------------------------------------------------------------- 3D affine transforms (row-major 3×4)
function mul(a, b) {   // a ∘ b
  const o = new Array(12);
  for (let r = 0; r < 3; r++) {
    for (let c = 0; c < 3; c++) o[r * 4 + c] = a[r * 4] * b[c] + a[r * 4 + 1] * b[4 + c] + a[r * 4 + 2] * b[8 + c];
    o[r * 4 + 3] = a[r * 4] * b[3] + a[r * 4 + 1] * b[7] + a[r * 4 + 2] * b[11] + a[r * 4 + 3];
  }
  return o;
}

const s = e.scale || { x: 1, y: 1, z: 1 }, r = e.rotation || 0, ins = e.insert || { x: 0, y: 0, z: 0 }, base = b.base || { x: 0, y: 0, z: 0 };
const cols = e.type === 'MINSERT' ? Math.max(1, Math.min(1000, e.cols | 0 || 1)) : 1, rows = e.type === 'MINSERT' ? Math.max(1, Math.min(1000, e.rows | 0 || 1)) : 1;
const c = Math.cos(r), sn = Math.sin(r);
for (let ci = 0; ci < cols; ci++) for (let ri = 0; ri < rows; ri++) {
  // block → (−base) → scale → (+ column/row spacing) → rotate → (+insert) → OCS
  const step = translate(ci * (e.colSpacing || 0), ri * (e.rowSpacing || 0), 0);
  const rot = [c, -sn, 0, 0, sn, c, 0, 0, 0, 0, 1, 0];
  const scl = [s.x ?? 1, 0, 0, 0, 0, s.y ?? 1, 0, 0, 0, 0, s.z ?? 1, 0];
  const M = mul(mul(withOcs(m, e.extrusion), translate(ins.x, ins.y, ins.z || 0)), mul(rot, mul(step, mul(scl, translate(-base.x, -base.y, -(base.z || 0))))));
  walk(b.entities || [], M, layer, depth + 1);

// ---------------------------------------------------------------- curves → vertices
function arcPts(cx, cy, r, a0, a1, z = 0) {   // CCW from a0 to a1 (radians)
  let sweep = a1 - a0;
  while (sweep <= 0) sweep += 2 * Math.PI;
  const n = Math.max(2, Math.ceil(sweep / STEP));
  const out = [];
  for (let i = 0; i <= n; i++) { const a = a0 + (sweep * i) / n; out.push([cx + r * Math.cos(a), cy + r * Math.sin(a), z]); }
  return out;
}

/** Vertices with DXF bulges (the arc starting at a vertex) → points; `closed` adds the closing segment's arc. */
function bulgedPts(vs, closed, zOf) {
  const out = [];
  const n = vs.length;
  for (let i = 0; i < n; i++) {
    const a = vs[i], z = zOf(a);
    out.push([a.x, a.y, z]);
    if (i === n - 1 && !closed) break;
    const b = vs[(i + 1) % n], bu = a.bulge || 0;
    if (!bu || !Number.isFinite(bu)) continue;
    const dx = b.x - a.x, dy = b.y - a.y, c = Math.hypot(dx, dy);
    if (!c) continue;
    const theta = 4 * Math.atan(bu);              // signed sweep
    const r = c / (2 * Math.sin(theta / 2));
    const mx = (a.x + b.x) / 2, my = (a.y + b.y) / 2;
    const h = r * Math.cos(theta / 2);            // centre distance from the chord's middle (signed with r)
    const cx = mx - (dy / c) * h, cy = my + (dx / c) * h;
    const a0 = Math.atan2(a.y - cy, a.x - cx);
    const steps = Math.max(1, Math.ceil(Math.abs(theta) / STEP));
    const zb = zOf(b);
    for (let k = 1; k < steps; k++) {
      const ang = a0 + (theta * k) / steps, R = Math.abs(r);
      out.push([cx + R * Math.cos(ang), cy + R * Math.sin(ang), z + ((zb - z) * k) / steps]);
    }
  }
  return out;
}

/** A B-spline (optionally rational) by de Boor, sampled evenly in its parameter: ~32 vertices per control span. */
export function splinePts(sp) {
  const P = sp.control || [], p = sp.degree | 0, U = sp.knots || [];
  if (P.length > p && p >= 1 && U.length === P.length + p + 1) {
    const W = sp.weights && sp.weights.length === P.length ? sp.weights : null;
    const u0 = U[p], u1 = U[P.length];
    const n = Math.min(4000, Math.max(16, (P.length - p) * 32));
    const out = [];
    for (let i = 0; i <= n; i++) {
      const u = i === n ? u1 : u0 + ((u1 - u0) * i) / n;
      let k = p;
      while (k < P.length - 1 && u >= U[k + 1]) k++;
      const d = [];
      for (let j = 0; j <= p; j++) { const q = P[k - p + j], w = W ? W[k - p + j] : 1; d.push([q.x * w, q.y * w, (q.z || 0) * w, w]); }
      for (let r = 1; r <= p; r++) {
        for (let j = p; j >= r; j--) {
          const i0 = k - p + j, den = U[i0 + p - r + 1] - U[i0];
          const a = den ? (u - U[i0]) / den : 0;
          for (let c = 0; c < 4; c++) d[j][c] = (1 - a) * d[j - 1][c] + a * d[j][c];
        }
      }
      const q = d[p];
      out.push([q[0] / q[3], q[1] / q[3], q[2] / q[3]]);
    }
    return out;
  }
  const F = (sp.fit || []).map((q) => [q.x, q.y, q.z || 0]);
  if (F.length === 2) return F;
  if (F.length > 2) return throughFit(F);
  return P.length >= 2 ? P.map((q) => [q.x, q.y, q.z || 0]) : [];
}

/** A smooth curve through fit points (centripetal Catmull–Rom, 8 vertices a span) — for a spline stored only as fit
 *  points (DXF writers may leave out the control points). It passes every fit point, as the spline does. */
function throughFit(F) {
  const out = [F[0]];
  const P = [F[0].map((v, i) => 2 * v - F[1][i]), ...F, F.at(-1).map((v, i) => 2 * v - F.at(-2)[i])];
  const tj = (a, b) => Math.sqrt(Math.hypot(b[0] - a[0], b[1] - a[1], b[2] - a[2])) || 1e-9;
  for (let i = 1; i < P.length - 2; i++) {
    const [p0, p1, p2, p3] = [P[i - 1], P[i], P[i + 1], P[i + 2]];
    const t1 = tj(p0, p1), t2 = t1 + tj(p1, p2), t3 = t2 + tj(p2, p3);
    for (let k = 1; k <= 8; k++) {
      const u = t1 + ((t2 - t1) * k) / 8;
      const L = (a, b, ta, tb) => a.map((v, j) => ((tb - u) * v + (u - ta) * b[j]) / (tb - ta));
      const A1 = L(p0, p1, 0, t1), A2 = L(p1, p2, t1, t2), A3 = L(p2, p3, t2, t3);
      const B1 = L(A1, A2, 0, t2), B2 = L(A2, A3, t1, t3);
      out.push(L(B1, B2, t1, t2));
    }
  }
  return out;
}

case 'ELLIPSE': {
  const c = e.center, M = e.majorAxis, r = e.ratio;
  const N = ocs(e.extrusion) ? [e.extrusion.x, e.extrusion.y, e.extrusion.z] : [0, 0, 1];
  const L = Math.hypot(...N), n = N.map((v) => v / L);
  const mn = [n[1] * M.z - n[2] * M.y, n[2] * M.x - n[0] * M.z, n[0] * M.y - n[1] * M.x].map((v) => v * r);   // minor axis
  let s0 = e.startParam ?? 0, s1 = e.endParam ?? 2 * Math.PI;
  while (s1 <= s0) s1 += 2 * Math.PI;
  const full = Math.abs(s1 - s0 - 2 * Math.PI) < 1e-9;
  const k = Math.max(4, Math.ceil((s1 - s0) / STEP)), out = [];
  for (let i = 0; i <= k; i++) { const s = s0 + ((s1 - s0) * i) / k; out.push([c.x + M.x * Math.cos(s) + mn[0] * Math.sin(s), c.y + M.y * Math.cos(s) + mn[1] * Math.sin(s), (c.z || 0) + M.z * Math.cos(s) + mn[2] * Math.sin(s)]); }
  if (full) out.pop();
  return { parts: [out], closed: full, wcs: true };

const props = (layer, type, pts) => {
  const z0 = pts[0]?.[2];
  const same = pts.length && pts.every((p) => Math.abs(p[2] - z0) <= 1e-9 * Math.max(1, Math.abs(z0)));
  return { LAYER: layer, TYPE: type, ELEV: same && Number.isFinite(z0) && z0 !== 0 ? z0 : null, HANDLE: curHandle };
};
const shape = (pts) => {
  const flat = pts.every((p) => p[2] === 0 || Math.abs(p[2]) < 1e-12);
  return flat ? pts.map((p) => [p[0], p[1]]) : pts.map((p) => [p[0], p[1], p[2]]);
};

/** CivilCraft feature lines written into this drawing (top-level model space only), in project units. */
export function cadFeatureLines(model, { projectUnit = 'ft', scale = null } = {}) {
  const ms = (model?.blocks || []).find((b) => String(b.name).toUpperCase() === '*MODEL_SPACE');
  const k = Number.isFinite(scale) && scale > 0 ? scale : unitScale(model?.header || {}, projectUnit).scale;
  const out = [];
  for (const e of ms?.entities || []) {
    if (!isFeatureLine(e) || e.invisible) continue;
    const vs = (e.vertices || []).filter((v) => !(v.flags & 16)).map((v) => ({ x: v.x * k, y: v.y * k, z: (v.z || 0) * k }));
    const f = featureFromCad(vs, !!e.closed, e.xdata, projectUnit);
    if (f) out.push(f);
  }
  return out;
}

const ins = e.insert || { x: 0, y: 0, z: 0 };
// the insertion point is in the reference's object coordinate system (its extrusion), as every 2D entity
const O = ocs(e.extrusion) || [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0];   // row-major 3 × 4; null = +Z
const ix = ins.x || 0, iy = ins.y || 0, iz = ins.z || 0;
const w = [O[0] * ix + O[1] * iy + O[2] * iz, O[4] * ix + O[5] * iy + O[6] * iz, O[8] * ix + O[9] * iy + O[10] * iz];
const attrs = {};
for (const a of e.attribs || []) { const tag = str(a.tag, 255).toUpperCase(); if (tag && !(tag in attrs)) attrs[tag] = str(a.value ?? a.text, 500); }
const cols = e.type === 'MINSERT' ? Math.max(1, Math.min(1000, e.cols | 0 || 1)) : 1, rows = e.type === 'MINSERT' ? Math.max(1, Math.min(1000, e.rows | 0 || 1)) : 1;
const r = e.rotation || 0, c = Math.cos(r), s = Math.sin(r);
for (let ci = 0; ci < cols; ci++) for (let ri = 0; ri < rows; ri++) {
  const dx = ci * (e.colSpacing || 0), dy = ri * (e.rowSpacing || 0);
  const ox = c * dx - s * dy, oy = s * dx + c * dy;   // MINSERT steps run along the reference's own turned axes (OCS)
  const p = [w[0] + O[0] * ox + O[1] * oy, w[1] + O[4] * ox + O[5] * oy, w[2] + O[8] * ox + O[9] * oy].map((v) => v * k);

/** A number read from attribute text: "105.32", "105,32", "EL 105.32", "105.32'" — the first number in it. */
export function attrNumber(text) {
  const m = /[-+]?\d+(?:[.,]\d+)?(?:e[-+]?\d+)?/i.exec(String(text ?? ''));
  if (!m) return null;
  const v = Number(m[0].replace(',', '.'));
  return Number.isFinite(v) ? v : null;
}

let zz = null;
if (z === 'insert') zz = r.z;
else if (zTag) { zz = attrNumber(r.attrs[zTag]); if (zz === null) skipped.noZ++; }
let d = desc === 'layer' ? r.layer : dTag ? str(r.attrs[dTag]) : r.block;
if (!d) d = str(r.block);
points.push({ n, x: r.x, y: r.y, z: Number.isFinite(zz) && Math.abs(zz) < 1e6 ? zz : null, d: str(d), blk: { name: str(r.block, 255), layer: str(r.layer, 255), handle: str(r.handle, 40) } });