Offset, extend, break and lengthen

/** An entity offset by d toward the side of `side` (a point), or null. */
export function offsetEntity(e, d, side) {
  switch (e.type) {
    case 'line': {
      const L = Math.hypot(e.x2 - e.x1, e.y2 - e.y1); if (L < EPS) return null;
      let nx = -(e.y2 - e.y1) / L, ny = (e.x2 - e.x1) / L;
      if ((side.x - e.x1) * nx + (side.y - e.y1) * ny < 0) { nx = -nx; ny = -ny; }
      return { ...e, x1: e.x1 + nx * d, y1: e.y1 + ny * d, x2: e.x2 + nx * d, y2: e.y2 + ny * d };
    }
    case 'circle': case 'arc': {
      const out = dist({ x: e.cx, y: e.cy }, side) > e.r;
      const r = e.r + (out ? d : -d);
      return r > EPS ? { ...e, r } : null;
    }
    case 'poly': return offsetPoly(e, d, side);
    case 'xline': case 'ray': {
      let nx = -e.dy, ny = e.dx;
      if ((side.x - e.x) * nx + (side.y - e.y) * ny < 0) { nx = -nx; ny = -ny; }
      return { ...e, x: e.x + nx * d, y: e.y + ny * d };
    }
    default: return null;
  }
}

function offsetPoly(e, d, side) {
  // Signed offset: decide the side from the nearest segment, then offset every segment the same way.
  const ps = polyPrims(e);
  if (!ps.length) return null;
  let near = ps[0], nd = Infinity;
  for (const p of ps) { const x = distToPrim(p, side); if (x < nd) { nd = x; near = p; } }
  const leftOf = (p, q) => {
    if (p.k === 'L') return (p.x2 - p.x1) * (q.y - p.y1) - (p.y2 - p.y1) * (q.x - p.x1) > 0;
    const outside = dist({ x: p.cx, y: p.cy }, q) > p.r;
    return p.rev ? outside : !outside;      // CCW arc: left = inside
  };
  const sgn = leftOf(near, side) ? 1 : -1;  // +1 = offset to the left of travel
  const off = ps.map((p) => {
    if (p.k === 'L') {
      const L = Math.hypot(p.x2 - p.x1, p.y2 - p.y1) || 1, nx = -(p.y2 - p.y1) / L * d * sgn, ny = (p.x2 - p.x1) / L * d * sgn;
      return { ...p, x1: p.x1 + nx, y1: p.y1 + ny, x2: p.x2 + nx, y2: p.y2 + ny };
    }
    const toLeftInside = !p.rev;            // travelling CCW, the left side is the centre
    const r = p.r + (sgn > 0 === toLeftInside ? -d : d);
    return r > EPS ? { ...p, r } : null;
  });
  if (off.some((p) => !p)) return null;
  const start = (p) => (p.k === 'L' ? { x: p.x1, y: p.y1 } : primPoint(p, p.rev ? 1 : 0));
  const end = (p) => (p.k === 'L' ? { x: p.x2, y: p.y2 } : primPoint(p, p.rev ? 0 : 1));
  const n = off.length, pts = [];
  for (let i = 0; i < n; i++) {
    const p = off[i];
    let s = start(p);
    if (i > 0 || e.closed) {
      const prev = off[(i - 1 + n) % n];
      if (prev.k === 'L' && p.k === 'L') { const x = intersect(prev, p, true, true)[0]; if (x) s = x; }
    }
    pts.push({ x: s.x, y: s.y, b: e.pts[i].b || 0 });
  }
  if (!e.closed) { const last = end(off[n - 1]); pts.push({ x: last.x, y: last.y, b: 0 }); }
  return { ...e, pts };
}

/** Extend the end of e nearest `pick` to the closest boundary. Returns the new entity or null. */
export function extendEntity(e, boundaries, pick, blocks, { edgeExtend = false } = {}) {
  // EDGEMODE 1: a boundary line or arc counts as the whole line or circle it lies on
  const bps = boundaries.filter((b) => b !== e && (b.id === undefined || b.id !== e.id)).flatMap((b) => prims(b, blocks).map((q) => ({ q, ext: edgeExtend && (b.type === 'line' || b.type === 'arc') })));
  if (e.type === 'line') {
    const atStart = dist(pick, { x: e.x1, y: e.y1 }) < dist(pick, { x: e.x2, y: e.y2 });
    const from = atStart ? { x: e.x2, y: e.y2 } : { x: e.x1, y: e.y1 }, to = atStart ? { x: e.x1, y: e.y1 } : { x: e.x2, y: e.y2 };
    const L = dist(from, to); if (L < EPS) return null;
    const ray = { k: 'L', x1: from.x, y1: from.y, x2: to.x, y2: to.y };
    let best = null;
    for (const { q, ext } of bps) for (const x of intersect(ray, q, true, ext)) {
      const t = primParam(ray, x, false);
      if (t > 1 + 1e-9 && (!best || t < best.t)) best = { t, x };
    }
    if (!best) return null;
    return atStart ? { ...e, x1: best.x.x, y1: best.x.y } : { ...e, x2: best.x.x, y2: best.x.y };
  }
  if (e.type === 'arc') {
    const [a0, a1] = arcRange(e.a0, e.a1);
    const c = { x: e.cx, y: e.cy };
    const atStart = dist(pick, polar(c, a0, e.r)) < dist(pick, polar(c, a1, e.r));
    const full = { k: 'A', cx: e.cx, cy: e.cy, r: e.r, a0: 0, a1: TAU, full: true };
    let best = null;
    for (const { q, ext } of bps) for (const x of intersect(full, q, true, ext)) {
      const a = normAngle(Math.atan2(x.y - e.cy, x.x - e.cx));
      const gap = atStart ? normAngle(a0 - a) : normAngle(a - a1);
      if (gap > 1e-9 && gap < TAU - (a1 - a0) && (!best || gap < best.gap)) best = { gap, a };
    }
    if (!best) return null;
    return atStart ? { ...e, a0: best.a } : { ...e, a1: best.a };
  }
  if (e.type === 'poly' && !e.closed && e.pts.length >= 2) {
    const n = e.pts.length;
    const atStart = dist(pick, e.pts[0]) < dist(pick, e.pts[n - 1]);
    const [p, q] = atStart ? [e.pts[1], e.pts[0]] : [e.pts[n - 2], e.pts[n - 1]];
    if (Math.abs((atStart ? e.pts[0].b : e.pts[n - 2].b) || 0) > 1e-12) return null;   // arc ends: not yet
    const tmp = extendEntity({ type: 'line', x1: p.x, y1: p.y, x2: q.x, y2: q.y }, boundaries, q, blocks, { edgeExtend });
    if (!tmp) return null;
    const pts = e.pts.map((v) => ({ ...v }));
    if (atStart) { pts[0].x = tmp.x2; pts[0].y = tmp.y2; } else { pts[n - 1].x = tmp.x2; pts[n - 1].y = tmp.y2; }
    return { ...e, pts };
  }
  return null;
}

/**
 * BREAK: e without the part between p1 and p2 (both put onto it). p2 the same as p1 splits it there.
 * → [pieces] | { error: 'type' | 'circle' }. A circle loses the part counter-clockwise from p1 to p2; a closed
 * polyline the part from p1 to p2 in its own direction.
 */
export function breakEntity(e, p1, p2) {
  const same = dist(p1, p2) <= EPS * Math.max(1, Math.hypot(p1.x, p1.y));
  if (e.type === 'circle') {
    if (same) return { error: 'circle' };
    const a1 = Math.atan2(p1.y - e.cy, p1.x - e.cx), a2 = Math.atan2(p2.y - e.cy, p2.x - e.cx);
    return [{ ...e, type: 'arc', a0: normAngle(a2), a1: normAngle(a1) }];
  }
  if (!['line', 'arc', 'poly', 'xline', 'ray'].includes(e.type)) return { error: 'type' };
  let t1 = paramOn(e, p1), t2 = same ? t1 : paramOn(e, p2);
  if (e.type === 'poly' && e.closed) {
    const n = e.pts.length;
    const open = { ...e, closed: false, pts: [...e.pts, ...e.pts, { ...e.pts[0] }] };
    if (same) return [subEntity(open, t1, t1 + n)].filter(Boolean);
    if (t2 < t1) t2 += n;
    return [subEntity(open, t2, t1 + n)].filter(Boolean);
  }
  if (t2 < t1) [t1, t2] = [t2, t1];
  const maxT = e.type === 'poly' ? e.pts.length - 1 : 1;
  const tiny = UNBOUNDED.has(e.type) ? 1e-15 : 1e-9;
  const out = [];
  if (t1 > tiny || e.type === 'xline') out.push(subEntity(e, 0, t1));
  if (t2 < maxT - tiny) out.push(subEntity(e, t2, maxT));
  return out.filter(Boolean);
}

/**
 * LENGTHEN: e with the end nearest `pick` moved so the object gets longer or shorter by `delta` (drawing units), or,
 * for an arc, its included angle by `dAngle` (radians). → entity | { error: 'type' | 'short' | 'full' }.
 * A polyline changes its end segment (a straight one along its direction, an arc one round its center).
 */
export function lengthenEntity(e, pick, { delta = 0, dAngle = null } = {}) {
  if (e.type === 'line') {
    const L = Math.hypot(e.x2 - e.x1, e.y2 - e.y1), nl = L + delta;
    if (!(nl > EPS)) return { error: 'short' };
    const atStart = dist(pick, { x: e.x1, y: e.y1 }) < dist(pick, { x: e.x2, y: e.y2 });
    const ux = (e.x2 - e.x1) / L, uy = (e.y2 - e.y1) / L;
    return atStart ? { ...e, x1: e.x2 - ux * nl, y1: e.y2 - uy * nl } : { ...e, x2: e.x1 + ux * nl, y2: e.y1 + uy * nl };
  }
  if (e.type === 'arc') {
    const sw = normAngle(e.a1 - e.a0) || TAU, ns = sw + (dAngle ?? delta / e.r);
    if (!(ns > 1e-9)) return { error: 'short' };
    if (ns >= TAU - 1e-9) return { error: 'full' };
    const c = { x: e.cx, y: e.cy };
    const atStart = dist(pick, polar(c, e.a0, e.r)) < dist(pick, polar(c, e.a1, e.r));
    return atStart ? { ...e, a0: normAngle(e.a1 - ns) } : { ...e, a1: normAngle(e.a0 + ns) };
  }
  if (e.type === 'poly' && !e.closed && e.pts.length >= 2) {
    const n = e.pts.length, pts = e.pts.map((p) => ({ ...p }));
    const atStart = dist(pick, pts[0]) < dist(pick, pts[n - 1]);
    const i = atStart ? 0 : n - 2;   // the end segment
    const P = pts[i], Q = pts[i + 1], b = P.b || 0;
    if (Math.abs(b) < 1e-12) {
      const L = dist(P, Q), nl = L + delta;
      if (!(nl > EPS)) return { error: 'short' };
      const ux = (Q.x - P.x) / L, uy = (Q.y - P.y) / L;
      if (atStart) { pts[0].x = Q.x - ux * nl; pts[0].y = Q.y - uy * nl; } else { pts[n - 1].x = P.x + ux * nl; pts[n - 1].y = P.y + uy * nl; }
      return { ...e, pts };
    }
    const a = bulgeArc(P, Q, b), sw = a.a1 - a.a0, ns = sw + (dAngle ?? delta / a.r);
    if (!(ns > 1e-9)) return { error: 'short' };
    if (ns >= TAU - 1e-9) return { error: 'full' };
    // travel P → Q: counter-clockwise when b > 0; the far end of the segment moves, the near one stays
    const c = { x: a.cx, y: a.cy }, dir = b > 0 ? 1 : -1;
    if (atStart) {   // P moves: back from Q against the travel
      const aq = Math.atan2(Q.y - c.y, Q.x - c.x), np = polar(c, aq - dir * ns, a.r);
      pts[0].x = np.x; pts[0].y = np.y;
    } else {
      const ap = Math.atan2(P.y - c.y, P.x - c.x), nq = polar(c, ap + dir * ns, a.r);
      pts[n - 1].x = nq.x; pts[n - 1].y = nq.y;
    }
    pts[i].b = dir * Math.tan(ns / 4);
    return { ...e, pts };
  }
  return { error: 'type' };
}