Spoken lengths, directions and extents

const R2D = 180 / Math.PI;
const num = (v) => (Number.isInteger(v) ? String(v) : String(Math.round(v * 100) / 100));
const deg = (rad) => num(Math.round(normAngle(rad) * R2D * 100) / 100);

/** The eight directions, as words: from a to b, in the drawing's own axes (right = +x, up = +y). Index 0..7 counter-clockwise from right. */
export function directionOf(a, b) {
  const ang = normAngle(Math.atan2(b.y - a.y, b.x - a.x));
  return Math.round(ang / (Math.PI / 4)) % 8;
}

/** How far and which way: "2400 to the right and 300 up" for a move; a plain distance and direction when both parts are real. */
export function sayMove(a, b, c) {
  const { fmt, t } = ctxOf(c);
  const dx = b.x - a.x, dy = b.y - a.y, d = Math.hypot(dx, dy);
  if (d < 1e-9) return t('access.move.none');
  return t('access.move', { d: fmt(d), dir: sayDirection(a, b, c), angle: deg(Math.atan2(dy, dx)), dx: fmt(Math.abs(dx)), dy: fmt(Math.abs(dy)), sx: t(dx >= 0 ? 'access.right' : 'access.left'), sy: t(dy >= 0 ? 'access.up' : 'access.down') });
}

/** The length along an object, when it has one. */
export function lengthOf(e) {
  switch (e.type) {
    case 'line': return Math.hypot(e.x2 - e.x1, e.y2 - e.y1);
    case 'circle': return 2 * Math.PI * e.r;
    case 'arc': { let s = normAngle(e.a1 - e.a0); if (s === 0) s = 2 * Math.PI; return s * e.r; }
    case 'poly': {
      let L = 0; const n = e.pts.length, m = e.closed ? n : n - 1;
      for (let i = 0; i < m; i++) { const p = e.pts[i], q = e.pts[(i + 1) % n]; L += Math.hypot(q.x - p.x, q.y - p.y); }   // bulges are counted straight
      return L;
    }
    default: return null;
  }
}

/** The whole drawing: how much, of what, how big, what is chosen. */
export function describeDrawing(cx, { selection = null } = {}) {
  const c = ctxOf(cx), { doc, fmt, t } = c;
  const list = doc.all().filter((e) => doc.visible(e));
  if (!list.length) return t('access.drawing.empty');
  const byType = new Map();
  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
  for (const e of list) {
    byType.set(e.type, (byType.get(e.type) || 0) + 1);
    const b = entityBounds(e, doc.blocks);
    if (b && [b.minX, b.minY, b.maxX, b.maxY].every(Number.isFinite)) { minX = Math.min(minX, b.minX); minY = Math.min(minY, b.minY); maxX = Math.max(maxX, b.maxX); maxY = Math.max(maxY, b.maxY); }
  }
  const kinds = [...byType].sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : 1)).slice(0, 6)
    .map(([type, n]) => t('access.count', { n, kind: kindName({ type }, c) })).join(', ');
  const layers = new Set(list.map((e) => e.layer)).size;
  const parts = [t('access.drawing', { n: list.length, kinds, layers })];
  if (Number.isFinite(minX)) parts.push(t('access.extents', { w: fmt(maxX - minX), h: fmt(maxY - minY), x0: fmt(minX), y0: fmt(minY), x1: fmt(maxX), y1: fmt(maxY) }));
  if (selection && selection.size) parts.push(t('access.selected', { n: selection.size }));
  return parts.join(' ');
}

/** What lies within `radius` of a point, nearest first: [{ id, e, d, dir }]. */
export function nearObjects(cx, p, { radius, max = 6 } = {}) {
  const { doc } = ctxOf(cx), out = [];
  for (const e of doc.all()) {
    if (!doc.visible(e)) continue;
    const d = distToEntity(e, p, doc.blocks);
    if (!(d <= radius)) continue;
    out.push({ id: e.id, e, d });
  }
  out.sort((a, b) => a.d - b.d || a.id - b.id);
  return out.slice(0, max);
}

/** "Near the cursor": the cursor's place, then each object close by with its distance and the side it is on. */
export function describeNear(cx, p, opts = {}) {
  const c = ctxOf(cx), { fmt, t } = c;
  const near = nearObjects(c, p, opts);
  const head = sayPoint(p, c);
  if (!near.length) return t('access.near.none', { at: head, r: fmt(opts.radius) });
  const items = near.map((o) => {
    const k = kindName(o.e, c);
    if (o.d < 1e-6) return t('access.near.on', { kind: k, id: o.id });
    const q = closestOn(o.e, p, c);
    return t('access.near.item', { kind: k, id: o.id, d: fmt(o.d), dir: q ? sayDirection(p, q, c) : '' });
  });
  return t('access.near', { at: head, items: items.join('; ') });
}

/** The measure of a move or a pair of points: said back after a command takes a point ("length 3000, 30 degrees"). */
export function sayBetween(a, b, cx) {
  const { fmt, t } = ctxOf(cx);
  const d = Math.hypot(b.x - a.x, b.y - a.y);
  return t('access.between', { d: fmt(d), angle: deg(Math.atan2(b.y - a.y, b.x - a.x)), dx: fmt(b.x - a.x), dy: fmt(b.y - a.y) });
}

/** The snap points and grips near a point, nearest first, for stepping from one to the next with a key. [{ kind, x, y, d, id }] */
export function snapTargets(cx, p, { radius, kinds, max = 40 } = {}) {
  const { doc } = ctxOf(cx), out = [], seen = new Set();
  const ks = kinds || new Set(['end', 'mid', 'cen', 'quad', 'node', 'ins']);
  for (const e of doc.all()) {
    if (!doc.visible(e)) continue;
    const b = entityBounds(e, doc.blocks);
    if (!b || p.x < b.minX - radius || p.x > b.maxX + radius || p.y < b.minY - radius || p.y > b.maxY + radius) continue;
    for (const s of snapPoints(e, p, radius, ks, doc.blocks, null)) {
      const key = s.kind + ':' + Math.round(s.x * 1000) + ':' + Math.round(s.y * 1000);
      if (seen.has(key)) continue;
      seen.add(key);
      out.push({ ...s, id: e.id, d: Math.hypot(s.x - p.x, s.y - p.y) });
    }
  }
  out.sort((a, b) => a.d - b.d || a.id - b.id || (a.kind < b.kind ? -1 : 1));
  return out.slice(0, max);
}