"use strict";

// Layer: math/geometry
// Shared primitive geometry helpers used by placement, collision, mechanical bodies,
// editor hit-testing, and world obstacle queries.
(function (global) {
  const num = global.TarinaiCoreHelpers?.finiteOr || ((v, fallback = 0) => {
    const n = Number(v);
    return Number.isFinite(n) ? n : fallback;
  });
  const clampValue = global.TarinaiCoreHelpers?.clampNumber || ((v, min, max) => Math.max(min, Math.min(max, v)));

  function orientedRectAabb(cx, cy, halfW, halfH, angle) {
    const c = Math.cos(num(angle));
    const s = Math.sin(num(angle));
    const ex = Math.abs(c) * num(halfW) + Math.abs(s) * num(halfH);
    const ey = Math.abs(s) * num(halfW) + Math.abs(c) * num(halfH);
    return { left: num(cx) - ex, right: num(cx) + ex, top: num(cy) - ey, bottom: num(cy) + ey, cos: c, sin: s };
  }

  function rectAabb(rect) {
    if (!rect) return null;
    if (!rect.oriented) return rect;
    const aabb = orientedRectAabb(rect.cx, rect.cy, rect.halfW, rect.halfH, rect.angle);
    return {
      left: num(rect.left, aabb.left), right: num(rect.right, aabb.right), top: num(rect.top, aabb.top), bottom: num(rect.bottom, aabb.bottom),
      cx: num(rect.cx), cy: num(rect.cy), halfW: num(rect.halfW), halfH: num(rect.halfH), angle: num(rect.angle),
      cos: Number.isFinite(rect.cos) ? rect.cos : aabb.cos,
      sin: Number.isFinite(rect.sin) ? rect.sin : aabb.sin,
      oriented: true, type: rect.type, item: rect.item,
    };
  }

  function rectLocalPoint(rect, x, y) {
    const dx = num(x) - num(rect?.cx);
    const dy = num(y) - num(rect?.cy);
    const c = Number.isFinite(rect?.cos) ? rect.cos : Math.cos(num(rect?.angle));
    const s = Number.isFinite(rect?.sin) ? rect.sin : Math.sin(num(rect?.angle));
    return { x: dx * c + dy * s, y: -dx * s + dy * c };
  }

  function rectWorldVector(rect, x, y) {
    const c = Number.isFinite(rect?.cos) ? rect.cos : Math.cos(num(rect?.angle));
    const s = Number.isFinite(rect?.sin) ? rect.sin : Math.sin(num(rect?.angle));
    return { x: num(x) * c - num(y) * s, y: num(x) * s + num(y) * c };
  }

  function rectWorldNormal(rect, nx, ny) {
    return rectWorldVector(rect, nx, ny);
  }

  function rectCorners(rect, padding = 0) {
    const r = rectAabb(rect);
    const pad = Math.max(0, num(padding));
    if (!r) return [];
    if (!r.oriented) {
      return [
        { x: num(r.left) - pad, y: num(r.top) - pad },
        { x: num(r.right) + pad, y: num(r.top) - pad },
        { x: num(r.right) + pad, y: num(r.bottom) + pad },
        { x: num(r.left) - pad, y: num(r.bottom) + pad },
      ];
    }
    const c = Number.isFinite(r.cos) ? r.cos : Math.cos(num(r.angle));
    const s = Number.isFinite(r.sin) ? r.sin : Math.sin(num(r.angle));
    const hw = num(r.halfW) + pad;
    const hh = num(r.halfH) + pad;
    const out = [];
    for (const [lx, ly] of [[-hw, -hh], [hw, -hh], [hw, hh], [-hw, hh]]) {
      out.push({ x: num(r.cx) + lx * c - ly * s, y: num(r.cy) + lx * s + ly * c });
    }
    return out;
  }

  function rectAxes(rect) {
    if (!rect?.oriented) return [{ x: 1, y: 0 }, { x: 0, y: 1 }];
    const c = Number.isFinite(rect.cos) ? rect.cos : Math.cos(num(rect.angle));
    const s = Number.isFinite(rect.sin) ? rect.sin : Math.sin(num(rect.angle));
    return [{ x: c, y: s }, { x: -s, y: c }];
  }

  function projectPoints(points, axis) {
    let min = Infinity;
    let max = -Infinity;
    for (const p of points || []) {
      const v = num(p.x) * axis.x + num(p.y) * axis.y;
      if (v < min) min = v;
      if (v > max) max = v;
    }
    return { min, max };
  }

  function aabbOverlap(a, b, padding = 0) {
    const pad = Math.max(0, num(padding));
    return Boolean(a && b && num(a.left) <= num(b.right) + pad && num(a.right) >= num(b.left) - pad
      && num(a.top) <= num(b.bottom) + pad && num(a.bottom) >= num(b.top) - pad);
  }

  function rectOverlapInfo(a, b, padding = 0) {
    if (!aabbOverlap(a, b, padding)) return null;
    const ptsA = rectCorners(a, padding);
    const ptsB = rectCorners(b, padding);
    if (!ptsA.length || !ptsB.length) return null;
    let bestOverlap = Infinity;
    let bestAxis = null;
    for (const axis of [...rectAxes(a), ...rectAxes(b)]) {
      const len = Math.hypot(axis.x, axis.y) || 1;
      const n = { x: axis.x / len, y: axis.y / len };
      const pa = projectPoints(ptsA, n);
      const pb = projectPoints(ptsB, n);
      const overlap = Math.min(pa.max, pb.max) - Math.max(pa.min, pb.min);
      if (overlap <= 0) return null;
      if (overlap < bestOverlap) { bestOverlap = overlap; bestAxis = n; }
    }
    if (!bestAxis) return null;
    const acx = num(a.cx, (num(a.left) + num(a.right)) * 0.5);
    const acy = num(a.cy, (num(a.top) + num(a.bottom)) * 0.5);
    const bcx = num(b.cx, (num(b.left) + num(b.right)) * 0.5);
    const bcy = num(b.cy, (num(b.top) + num(b.bottom)) * 0.5);
    if ((bcx - acx) * bestAxis.x + (bcy - acy) * bestAxis.y < 0) bestAxis = { x: -bestAxis.x, y: -bestAxis.y };
    return {
      overlap: bestOverlap,
      nx: bestAxis.x,
      ny: bestAxis.y,
      x: (Math.max(num(a.left), num(b.left)) + Math.min(num(a.right), num(b.right))) * 0.5,
      y: (Math.max(num(a.top), num(b.top)) + Math.min(num(a.bottom), num(b.bottom))) * 0.5,
    };
  }

  function rectsOverlap(a, b, margin = 0) {
    return Boolean(rectOverlapInfo(a, b, margin));
  }

  function pointInRect(x, y, rect, padding = 0) {
    if (!rect) return false;
    const pad = Math.max(0, num(padding));
    if (rect.oriented) {
      const p = rectLocalPoint(rect, x, y);
      return Math.abs(p.x) <= num(rect.halfW) + pad && Math.abs(p.y) <= num(rect.halfH) + pad;
    }
    return num(x) >= num(rect.left) - pad && num(x) <= num(rect.right) + pad
      && num(y) >= num(rect.top) - pad && num(y) <= num(rect.bottom) + pad;
  }

  function circleOverlapsRect(x, y, radius, rect, padding = 0) {
    if (!rect) return false;
    const rr = Math.max(0, num(radius)) + Math.max(0, num(padding));
    if (rect.oriented) {
      const local = rectLocalPoint(rect, x, y);
      const clx = clampValue(local.x, -num(rect.halfW), num(rect.halfW));
      const cly = clampValue(local.y, -num(rect.halfH), num(rect.halfH));
      return Math.hypot(local.x - clx, local.y - cly) < rr;
    }
    const cx = clampValue(num(x), num(rect.left), num(rect.right));
    const cy = clampValue(num(y), num(rect.top), num(rect.bottom));
    return Math.hypot(num(x) - cx, num(y) - cy) < rr;
  }

  function pointSegmentDistance(px, py, ax, ay, bx, by) {
    const dx = num(bx) - num(ax);
    const dy = num(by) - num(ay);
    const lenSq = dx * dx + dy * dy;
    if (lenSq <= 0.0001) return Math.hypot(num(px) - num(ax), num(py) - num(ay));
    const u = clampValue(((num(px) - num(ax)) * dx + (num(py) - num(ay)) * dy) / lenSq, 0, 1);
    return Math.hypot(num(px) - (num(ax) + dx * u), num(py) - (num(ay) + dy * u));
  }

  function segmentAabbHit(x1, y1, x2, y2, left, top, right, bottom) {
    if ((x1 >= left && x1 <= right && y1 >= top && y1 <= bottom) || (x2 >= left && x2 <= right && y2 >= top && y2 <= bottom)) return true;
    const minX = Math.min(left, right), maxX = Math.max(left, right);
    const minY = Math.min(top, bottom), maxY = Math.max(top, bottom);
    let t0 = 0, t1 = 1;
    const clip = (p, q) => {
      if (Math.abs(p) < 1e-9) return q >= 0;
      const t = q / p;
      if (p < 0) { if (t > t1) return false; if (t > t0) t0 = t; }
      else { if (t < t0) return false; if (t < t1) t1 = t; }
      return true;
    };
    const dx = num(x2) - num(x1);
    const dy = num(y2) - num(y1);
    return clip(-dx, num(x1) - minX) && clip(dx, maxX - num(x1)) && clip(-dy, num(y1) - minY) && clip(dy, maxY - num(y1));
  }

  function segmentIntersectsOrientedRect(x1, y1, x2, y2, r, padding = 0) {
    if (!r) return false;
    if (!r.oriented) return segmentAabbHit(x1, y1, x2, y2, r.left - padding, r.top - padding, r.right + padding, r.bottom + padding);
    const a = rectLocalPoint(r, x1, y1);
    const b = rectLocalPoint(r, x2, y2);
    return segmentAabbHit(a.x, a.y, b.x, b.y, -(r.halfW || 0) - padding, -(r.halfH || 0) - padding, (r.halfW || 0) + padding, (r.halfH || 0) + padding);
  }

  function oneWayFenceAllowsMotion(rect, prevX, prevY, motionX, motionY) {
    if (!rect?.oneWay) return false;
    const nx = num(rect.oneWayNx);
    const ny = num(rect.oneWayNy, -1);
    const prevSide = (num(prevX) - num(rect.cx)) * nx + (num(prevY) - num(rect.cy)) * ny;
    const motion = num(motionX) * nx + num(motionY) * ny;
    const sourceMargin = Math.max(1, num(rect.halfH) * 0.2);
    return motion > 0.01 || (prevSide < -sourceMargin && motion >= -0.01);
  }

  function oneWayFenceAllows(obj, rect, motionX = null, motionY = null) {
    if (!rect?.oneWay || !obj) return false;
    const hinted = Number.isFinite(Number(motionX)) || Number.isFinite(Number(motionY));
    const vx = hinted ? num(motionX) : num(obj.vx) + num(obj.impulseVx);
    const vy = hinted ? num(motionY) : num(obj.vy) + num(obj.impulseVy);
    const prevX = Number.isFinite(Number(obj.prevX)) ? Number(obj.prevX) : num(obj.x) - vx * 0.016;
    const prevY = Number.isFinite(Number(obj.prevY)) ? Number(obj.prevY) : num(obj.y) - vy * 0.016;
    return oneWayFenceAllowsMotion(rect, prevX, prevY, vx, vy);
  }

  global.TarinaiGeometry = Object.freeze({
    num,
    clampValue,
    orientedRectAabb,
    rectAabb,
    rectLocalPoint,
    rectWorldVector,
    rectWorldNormal,
    rectCorners,
    rectAxes,
    projectPoints,
    aabbOverlap,
    rectOverlapInfo,
    rectsOverlap,
    pointInRect,
    circleOverlapsRect,
    pointSegmentDistance,
    segmentAabbHit,
    segmentIntersectsOrientedRect,
    oneWayFenceAllowsMotion,
    oneWayFenceAllows,
  });
})(typeof window !== "undefined" ? window : globalThis);