import assert from "node:assert/strict";

import {
  linearUnitsToMetersFactor,
  linearUnitsToMillimetersFactor,
  linearValueToMeters,
  linearValueToMillimeters,
  normalizeLinearUnits,
  resolveStateLinearUnits,
} from "../../app/src/runtime/linear-units.js";
import { createLinuxCncInterpreterRuntime } from "../../app/src/runtime/linuxcnc-interpreter-runtime.js";
import { buildProgramExecutionTiming } from "../../app/src/runtime/execution-timing.js";
import { axesToSceneMeters } from "../../app/src/visualization/five-axis-scene.js";

function assertNear(actual, expected, label) {
  assert.equal(Math.abs(actual - expected) < 1e-9, true, `${label}: expected ${expected}, got ${actual}`);
}

assert.equal(normalizeLinearUnits("MM"), "mm");
assert.equal(normalizeLinearUnits("inch"), "inch");
assert.equal(normalizeLinearUnits("meters"), "m");
assertNear(linearUnitsToMetersFactor("mm"), 0.001, "mm to m factor");
assertNear(linearUnitsToMetersFactor("inch"), 0.0254, "inch to m factor");
assertNear(linearUnitsToMetersFactor("m"), 1, "m to m factor");
assertNear(linearUnitsToMillimetersFactor("inch"), 25.4, "inch to mm factor");
assertNear(linearValueToMeters(25.4, "mm"), 0.0254, "25.4 mm to meters");
assertNear(linearValueToMeters(1, "inch"), 0.0254, "1 inch to meters");
assertNear(linearValueToMillimeters(0.5, "m"), 500, "0.5 m to millimeters");

const mmState = { profile: { traj: { linearUnits: "mm" } } };
const inchState = { profile: { traj: { linearUnits: "inch" } } };
const meterState = { profile: { traj: { linearUnits: "m" } } };
const iniState = {
  linuxCncIniConfig: { traj: { linearUnits: "inch" } },
  profile: { traj: { linearUnits: "mm" } },
};

assert.equal(resolveStateLinearUnits(iniState), "inch");
assert.deepEqual(axesToSceneMeters({ x: 25.4, y: -10, z: 2000 }, mmState), {
  x: 0.0254,
  y: -0.01,
  z: 2,
});
assert.deepEqual(axesToSceneMeters({ x: 1, y: -0.5, z: 2 }, inchState), {
  x: 0.0254,
  y: -0.0127,
  z: 0.0508,
});
assert.deepEqual(axesToSceneMeters({ x: 0.1, y: -0.2, z: 0.3 }, meterState), {
  x: 0.1,
  y: -0.2,
  z: 0.3,
});

const inchTiming = buildProgramExecutionTiming({
  profile: {
    traj: {
      linearUnits: "inch",
      maxLinearVelocity: 2,
      defaultLinearVelocity: 1,
    },
  },
  defaultFeedRate: 1,
  motion: [
    { type: "STRAIGHT_FEED", line: 1, axes: { x: 0, y: 0, z: 0 } },
    { type: "STRAIGHT_FEED", line: 2, axes: { x: 1, y: 0, z: 0 } },
  ],
});

assert.equal(inchTiming.linearUnits, "inch");
assertNear(inchTiming.segments[1].linearDistanceMm, 25.4, "inch segment distance in mm");
assertNear(inchTiming.segments[1].velocityMmPerMin, 25.4, "inch feed velocity in mm/min");

const mixedUnitsTiming = buildProgramExecutionTiming({
  profile: {
    traj: {
      linearUnits: "mm",
      maxLinearVelocity: 100,
      defaultLinearVelocity: 10,
    },
  },
  motion: [
    { type: "STRAIGHT_FEED", line: 1, axes: { x: 0, y: 0, z: 0 }, linearUnits: "inch", feedRate: 10 },
    { type: "STRAIGHT_FEED", line: 2, axes: { x: 1, y: 0, z: 0 }, linearUnits: "inch", feedRate: 10 },
    { type: "STRAIGHT_FEED", line: 3, axes: { x: 25.4, y: 0, z: 0 }, linearUnits: "mm", feedRate: 100 },
  ],
});
assertNear(mixedUnitsTiming.segments[1].linearDistanceMm, 25.4, "mixed units inch segment distance");
assertNear(mixedUnitsTiming.segments[2].linearDistanceMm, 0, "mixed units unchanged position distance");

const inverseTimeTiming = buildProgramExecutionTiming({
  profile: {
    traj: {
      linearUnits: "mm",
      maxLinearVelocity: 100,
      defaultLinearVelocity: 10,
    },
  },
  motion: [
    { type: "STRAIGHT_FEED", line: 1, axes: { x: 0, y: 0, z: 0 }, linearUnits: "mm", feedMode: "inverse-time", feedRate: 120 },
    { type: "STRAIGHT_FEED", line: 2, axes: { x: 10, y: 0, z: 0 }, linearUnits: "mm", feedMode: "inverse-time", feedRate: 120 },
  ],
});
assertNear(inverseTimeTiming.segments[1].durationSeconds, 0.5, "G93 inverse-time F120 duration");
assertNear(inverseTimeTiming.segments[1].velocityMmPerMin, 1200, "G93 inverse-time velocity");

const interpreterRuntime = await createLinuxCncInterpreterRuntime();
const inchExecution = interpreterRuntime.runProgram("G20 G90\nG1 X1 F10\nM2");
const metricExecution = interpreterRuntime.runProgram("G21 G90\nG1 X25.4 F100\nM2");
const inverseExecution = interpreterRuntime.runProgram("G21 G90 G93\nG1 X1 F120\nM2");

assert.equal(inchExecution.motion[0].linearUnits, "inch");
assert.equal(metricExecution.motion[0].linearUnits, "mm");
assert.equal(inverseExecution.motion[0].feedMode, "inverse-time");
assertNear(
  axesToSceneMeters(inchExecution.motion[0].axes, mmState, inchExecution.motion[0].linearUnits).x,
  0.0254,
  "G20 interpreter motion uses inch scene conversion",
);
assertNear(
  axesToSceneMeters(metricExecution.motion[0].axes, mmState, metricExecution.motion[0].linearUnits).x,
  0.0254,
  "G21 interpreter motion uses millimeter scene conversion",
);

console.log("linear_unit_conversion_smoke=ok");