/**
 * Integrationstest der Speed-Koordination (ToDo_6a).
 *
 * Kernaussage des Korrekt-Modus: Alle Controller müssen den Bewegungsschritt in
 * DERSELBEN Zeit beenden. Dieser Test prüft genau das — komplett unabhängig von der
 * internen Berechnung: er liest die tatsächlich gesendeten G-Code-Zeilen, rechnet aus
 * den absoluten Achswerten die Strecke jedes Senders aus und teilt durch die gesendete
 * Feedrate. Das Ergebnis (= Zeit) muss für jeden Sender gleich der robot-moveTime sein.
 *
 * Damit werden gleichzeitig abgesichert: moveTime-Propagation Robot→Sender, portValue
 * gegen den echten Sende-Pfad, und die Feedrate-Auswahl im Korrekt-Modus.
 */
const Robot = require('../robot/kinematics/Arm3SegmentLinearX');
const GCode = require('../robot/GCode');
const TelnetSender = require('../robot/TelnetSenderGRBL');

function parseLine(line) {
  const out = {};
  const re = /([a-z])(-?\d+(?:\.\d+)?)/g;
  let m;
  while ((m = re.exec(line)) !== null) out[m[1]] = parseFloat(m[2]);
  return out;
}

function makeSender(...args) {
  const s = new TelnetSender(...args); // "test.test" → isTestMode
  s.writes = [];
  s.tSocket = { write(t) { s.writes.push(t); } };
  return s;
}

// Produktiv-Verkabelung wie in startRobot.js
function buildRobot(speedMode) {
  const robot = new Robot(250, 264, 100);
  robot.speedMode = speedMode;
  robot.useSpeedCalc = (speedMode === 'correct');
  robot.moveRelative = false; // M1 absolut

  const base = makeSender('test.test', 2300, 'x', 'y', 'z');
  const elbow = makeSender('test.test', 5000, 'a', null, null);
  const hand = makeSender('test.test', 5000, 'c', 'e', 'b');
  robot.cmdReceivers.push(base, elbow, hand);

  return { robot, base, elbow, hand };
}

// drei absolute Motor-Stellungen; Schritt 0 = Warmup (erster Aufruf → Fallback)
function runMoves(robot) {
  GCode.receiveGCode(robot, 'M1 X5  Y0.10 Z0.20 A0.30 B0.40 C0.50'); // 0 warmup
  GCode.receiveGCode(robot, 'M1 X10 Y0.20 Z0.30 A0.40 B0.50 C0.60'); // 1 baseline
  GCode.receiveGCode(robot, 'M1 X22 Y0.45 Z0.50 A0.65 B0.85 C0.90'); // 2 gemessen
}

describe('Speed-Koordination (ToDo_6a)', () => {
  beforeAll(() => { jest.spyOn(console, 'log').mockImplementation(() => {}); });
  afterAll(() => { jest.restoreAllMocks(); });

  test('correct: alle Sender beenden den Schritt in gleicher Zeit (= moveTime)', () => {
    const { robot, base, elbow, hand } = buildRobot('correct');
    runMoves(robot);

    const moveTime = robot.motorPosition.moveTime;
    expect(moveTime).toBeGreaterThan(0);

    for (const s of [base, elbow, hand]) {
      const v1 = parseLine(s.writes[1]); // baseline
      const v2 = parseLine(s.writes[2]); // gemessen
      const axes = Object.keys(v2).filter(k => k !== 'f');

      let sumSq = 0;
      for (const ax of axes) sumSq += (v2[ax] - v1[ax]) ** 2;
      const dist = Math.sqrt(sumSq);

      const time = dist / v2.f; // unabhängig aus Output berechnet
      // jeder Controller braucht dieselbe Zeit (Rundung auf 2 Dezimalen → 2% Toleranz)
      expect(Math.abs(time - moveTime) / moveTime).toBeLessThan(0.02);
    }
  });

  test('correct: die Sender bekommen UNTERSCHIEDLICHE Feedrates', () => {
    const { robot, base, elbow, hand } = buildRobot('correct');
    runMoves(robot);

    const fBase = parseLine(base.writes[2]).f;
    const fElbow = parseLine(elbow.writes[2]).f;
    const fHand = parseLine(hand.writes[2]).f;

    // Genau das ist der Unterschied zu legacy: nicht alle gleich.
    expect(fBase).not.toBeCloseTo(fElbow, 2);
    expect(fBase).not.toBeCloseTo(fHand, 2);
  });

  test('legacy (Kontrast): alle Sender bekommen dieselbe kartesische Feedrate', () => {
    const { robot, base, elbow, hand } = buildRobot('legacy');
    runMoves(robot);

    // robot.feedrate ist 1000 (kein F in M1) → alle Sender f1000.00
    expect(parseLine(base.writes[2]).f).toBeCloseTo(1000, 2);
    expect(parseLine(elbow.writes[2]).f).toBeCloseTo(1000, 2);
    expect(parseLine(hand.writes[2]).f).toBeCloseTo(1000, 2);
  });
});