import { dist, vec } from './math.js';

const RAW_POINTS = {
  A: vec(78.468674, 129.90132),
  B: vec(137.85054, 130.12675),
  O: vec(108.00143, 129.68732),
  C0: vec(107.73979, 134.64543),
  D0: vec(91.864792, 153.45453),
  E0: vec(123.05698, 152.69731),
  F0: vec(77.341405, 173.08926),
  G0: vec(138.20833, 172.9466),
};

const RAW_LEG_LENGTH = dist(RAW_POINTS.C0, RAW_POINTS.G0);
const TARGET_LEG_LENGTH_CM = 45;
const SCALE_TO_CM = TARGET_LEG_LENGTH_CM / RAW_LEG_LENGTH;

export const POINTS = {
  A: vec(RAW_POINTS.A.x * SCALE_TO_CM, RAW_POINTS.A.y * SCALE_TO_CM),
  B: vec(RAW_POINTS.B.x * SCALE_TO_CM, RAW_POINTS.B.y * SCALE_TO_CM),
  O: vec(RAW_POINTS.O.x * SCALE_TO_CM, RAW_POINTS.O.y * SCALE_TO_CM),
  C0: vec(RAW_POINTS.C0.x * SCALE_TO_CM, RAW_POINTS.C0.y * SCALE_TO_CM),
  D0: vec(RAW_POINTS.D0.x * SCALE_TO_CM, RAW_POINTS.D0.y * SCALE_TO_CM),
  E0: vec(RAW_POINTS.E0.x * SCALE_TO_CM, RAW_POINTS.E0.y * SCALE_TO_CM),
  F0: vec(RAW_POINTS.F0.x * SCALE_TO_CM, RAW_POINTS.F0.y * SCALE_TO_CM),
  G0: vec(RAW_POINTS.G0.x * SCALE_TO_CM, RAW_POINTS.G0.y * SCALE_TO_CM),
};

const rOC = dist(POINTS.O, POINTS.C0);
const rAD = dist(POINTS.A, POINTS.D0);
const rCD = dist(POINTS.C0, POINTS.D0);
const rCF = dist(POINTS.C0, POINTS.F0);
const rBE = dist(POINTS.B, POINTS.E0);
const rCE = dist(POINTS.C0, POINTS.E0);
const rCG = dist(POINTS.C0, POINTS.G0);

export const LENGTHS = {
  rOC,
  rAD,
  rCD,
  rCF,
  rBE,
  rCE,
  rCG,
  kL: rCF / rCD,
  kR: rCG / rCE,
};

export const BASE_DIMENSIONS_CM = {
  crank: rOC,
  leg: rCG,
  tendon: rBE,
  body: dist(POINTS.A, POINTS.B),
};

export function mechanismBounds() {
  const pts = Object.values(POINTS);
  let minX = Infinity;
  let minY = Infinity;
  let maxX = -Infinity;
  let maxY = -Infinity;
  for (const p of pts) {
    minX = Math.min(minX, p.x);
    minY = Math.min(minY, p.y);
    maxX = Math.max(maxX, p.x);
    maxY = Math.max(maxY, p.y);
  }
  // Increase padding to account for full range of motion and potential parameter changes
  const padX = 50;
  const padY = 60;
  return {
    minX: minX - padX,
    minY: minY - padY,
    maxX: maxX + padX,
    maxY: maxY + padY,
  };
}