// calculateActions.js
// Berechnung + nachvollziehbare Result-Struktur + Live-Logs in analysis-log

function getAnalysisLogEl() {
  if (typeof document === "undefined") return null;
  return document.getElementById("analysis-log");
}

function appendToAnalysis(line) {
  const el = getAnalysisLogEl();
  if (!el) return;

  const now = new Date().toISOString();
  el.value += `[${now}] ${line}\n`;
  el.scrollTop = el.scrollHeight;
}

function createAnalysisResult(meta = {}) {
  return {
    meta: {
      timestamp: new Date().toISOString(),
      ...meta
    },
    inputs: {
      source: null,
      headers: [],
      rowCount: 0
    },
    observations: [],
    calculations: [],
    features: {},
    commands: [],
    logs: [],
    errors: [],
    summary: {
      observationCount: 0,
      calculationCount: 0,
      featureCount: 0,
      commandCount: 0
    },
    status: "ok"
  };
}

function rowSnapshot(row) {
  return {
    id: row?.id,
    seen_by: row?.seen_by,
    x_mm: row?.x_mm,
    y_mm: row?.y_mm,
    z_mm: row?.z_mm,
    roll_deg: row?.roll_deg,
    pitch_deg: row?.pitch_deg
  };
}

function addLog(result, message, level = "info") {
  const entry = {
    timestamp: new Date().toISOString(),
    level,
    message
  };
  result.logs.push(entry);
  appendToAnalysis(message);
}

function addError(result, message, error = null) {
  result.status = "error";
  result.errors.push({
    timestamp: new Date().toISOString(),
    message,
    details: error ? String(error) : null
  });
  addLog(result, `Fehler: ${message}`, "error");
}

function addObservation(result, key, row, confidence = 1.0, notes = []) {
  result.observations.push({
    key,
    source: {
      rowId: row?.id,
      seenBy: row?.seen_by
    },
    values: rowSnapshot(row),
    confidence,
    notes
  });
}

function addCalculation(result, calc) {
  result.calculations.push({
    timestamp: new Date().toISOString(),
    ...calc
  });
}

function addFeature(result, key, feature) {
  result.features[key] = feature;
}

function addCommand(result, id, command, basedOn = [], confidence = 1.0, format = "gcode") {
  result.commands.push({
    id,
    command,
    basedOn,
    confidence,
    format
  });
}

function weightedAverage(candidates) {
  const weightSum = candidates.reduce((sum, c) => sum + c.weight, 0);
  if (!weightSum) return null;

  const valueRad = candidates.reduce((sum, c) => sum + (c.valueRad * c.weight), 0) / weightSum;
  const spreadRad = candidates.length > 1
    ? Math.sqrt(
        candidates.reduce(
          (sum, c) => sum + c.weight * Math.pow(c.valueRad - valueRad, 2),
          0
        ) / weightSum
      )
    : 0;

  const confidence = Math.max(
    0.2,
    Math.min(
      0.98,
      0.55 +
        Math.min(candidates.length * 0.1, 0.25) -
        Math.min(spreadRad / 1.0, 0.2)
    )
  );

  return { valueRad, weightSum, spreadRad, confidence };
}

async function fetchCSV() {
  const res = await fetch("/api/latest-snapshot");
  if (!res.ok) throw new Error("Fehler beim Laden des Snapshots");

  let data;
  if (res.headers.get("content-type")?.includes("application/json")) {
    data = await res.json();
  } else {
    const csvData = await res.text();
    data = {
      filename: "latest.csv",
      mtime: new Date().toISOString(),
      content: csvData
    };
  }

  const lines = data.content.trim().split(/\r?\n/).filter(Boolean);
  if (lines.length < 2) {
    throw new Error("Keine oder unvollständige Daten");
  }

  const headers = lines[0].split(",").map(h => h.trim());

  const rows = lines.slice(1).map(line => {
    const cells = line.split(",");
    const obj = {};
    headers.forEach((h, i) => {
      const raw = (cells[i] ?? "").trim();
      const numeric = Number(raw);
      obj[h] = raw !== "" && Number.isFinite(numeric) ? numeric : raw;
    });
    return obj;
  });

  return { data, headers, rows };
}

function calculateAngleFromPosition(result, row, axisY, axisZ, deltaYangle0, deltaZangle0 = 0, label = "angle") {
  const y = parseFloat(row.y_mm);
  const z = parseFloat(row.z_mm);

  const dy = -(y - axisY);
  const dz = z - axisZ;

  let angle0Rad = 0;
  if (deltaZangle0 !== 0 && deltaYangle0 !== 0) {
    angle0Rad = Math.atan(deltaZangle0 / deltaYangle0);
  }

  const angleRad = Math.atan2(dz, dy) - angle0Rad;
  const angleDeg = angleRad * 180 / Math.PI;

  const message = `(${label} = ${angleDeg.toFixed(2)}° = ${angleRad.toFixed(4)} rad) aus Position von ID = ${row.id}`;
  addLog(result, message);

  addCalculation(result, {
    type: "angleFromPosition",
    label,
    source: {
      rowId: row.id,
      seenBy: row.seen_by
    },
    input: {
      axisY,
      axisZ,
      deltaYangle0,
      deltaZangle0,
      y_mm: y,
      z_mm: z,
      dy,
      dz,
      angle0Rad
    },
    output: {
      angleRad,
      angleDeg
    }
  });

  return angleRad;
}

function calculateAngleFromRollColumn(result, row, roll0 = 0, pitch0 = 0, yaw0 = 0, strMotor = "motor") {
  const rollDeg = -parseFloat(row.roll_deg) + roll0;
  const rollRad = rollDeg * Math.PI / 180;

  const message = `(${strMotor} = ${rollDeg.toFixed(2)}° = ${rollRad.toFixed(4)} rad) aus roll_deg von ID = ${row.id}`;
  addLog(result, message);

  addCalculation(result, {
    type: "angleFromRollColumn",
    label: strMotor,
    source: {
      rowId: row.id,
      seenBy: row.seen_by
    },
    input: {
      roll0,
      pitch0,
      yaw0,
      roll_deg: row.roll_deg
    },
    output: {
      angleRad: rollRad,
      angleDeg: rollDeg
    }
  });

  return rollRad;
}

function calculateAngleFromRelativePosition(result, row1, row2, strMotor = "motor") {
  const y1 = parseFloat(row1.y_mm);
  const z1 = parseFloat(row1.z_mm);
  const y2 = parseFloat(row2.y_mm);
  const z2 = parseFloat(row2.z_mm);

  const dy = y1 - y2;
  const dz = z1 - z2;

  const angleRad = -Math.atan2(dz, dy);
  const angleDeg = angleRad * 180 / Math.PI;

  const message = `(${strMotor} = ${angleDeg.toFixed(2)}° = ${angleRad.toFixed(4)} rad) aus relativer Position von ID = ${row1.id} und ID = ${row2.id}`;
  addLog(result, message);

  addCalculation(result, {
    type: "angleFromRelativePosition",
    label: strMotor,
    source: {
      rowIds: [row1.id, row2.id],
      seenBy: [row1.seen_by, row2.seen_by]
    },
    input: {
      y1_mm: y1,
      z1_mm: z1,
      y2_mm: y2,
      z2_mm: z2,
      dy,
      dz
    },
    output: {
      angleRad,
      angleDeg
    }
  });

  return angleRad;
}

function buildFeatureFromCandidates(result, key, title, method, candidates) {
  const summary = weightedAverage(candidates);
  if (!summary) return null;

  const feature = {
    title,
    method,
    valueRad: summary.valueRad,
    valueDeg: summary.valueRad * 180 / Math.PI,
    confidence: summary.confidence,
    spreadRad: summary.spreadRad,
    weightSum: summary.weightSum,
    evidence: candidates.map(c => c.source),
    parts: candidates
  };

  addFeature(result, key, feature);
  addCalculation(result, {
    type: "featureSummary",
    key,
    title,
    method,
    input: candidates,
    output: {
      valueRad: feature.valueRad,
      valueDeg: feature.valueDeg,
      confidence: feature.confidence,
      spreadRad: feature.spreadRad,
      weightSum: feature.weightSum
    }
  });

  return feature;
}

function calculate_angleY(row243, row229, row198, row197, shoulderAxisY, shoulderAxisZ, result) {
    const angleYCandidates = [];

    if (row243) {
      const a1 = calculateAngleFromPosition(result, row243, shoulderAxisY, shoulderAxisZ, 285, 0, "yMotor");
      const a2 = calculateAngleFromRollColumn(result, row243, 90, 0, 0, "yMotor");

      angleYCandidates.push({
        source: "row243.position",
        valueRad: a1,
        weight: 1
      });
      /*
      angleYCandidates.push({
        source: "row243.roll_deg",
        valueRad: a2,
        weight: 1
      });
      */
    }

    if (row229) {
      const a = calculateAngleFromPosition(result, row229, shoulderAxisY, shoulderAxisZ, 250, 35, "yMotor");
      angleYCandidates.push({
        source: "row229.position",
        valueRad: a,
        weight: 1
      });
    }

    if (row198) {
      const a = calculateAngleFromPosition(result, row198, shoulderAxisY, shoulderAxisZ, 165, 35, "yMotor");
      angleYCandidates.push({
        source: "row198.position",
        valueRad: a,
        weight: 1
      });
    }

    if (row198 && row229) {
      const a = calculateAngleFromRelativePosition(result, row198, row229, "yMotor");
      angleYCandidates.push({
        source: "row198-row229.relative",
        valueRad: a,
        weight: 3
      });
    }

    if (row197) {
      const angleDeg = 90 - parseFloat(row197.pitch_deg);
      const angleRad = angleDeg * Math.PI / 180;

      addLog(result, `(yMotor = ${angleDeg.toFixed(2)}° = ${angleRad.toFixed(4)} rad ) aus Pitch von ${row197.id}`);

      addCalculation(result, {
        type: "angleFromPitch",
        label: "yMotor",
        source: {
          rowId: row197.id,
          seenBy: row197.seen_by
        },
        input: {
          pitch_deg: row197.pitch_deg
        },
        output: {
          angleRad,
          angleDeg
        }
      });

      angleYCandidates.push({
        source: "row197.pitch_deg",
        valueRad: angleRad,
        weight: 1
      });
    }


    if (angleYCandidates.length > 0) {
      buildFeatureFromCandidates(
        result,
        "shoulder.angleY",
        "Schulter Y",
        "weighted-average",
        angleYCandidates
      );
    }

}

async function calculate() {
  const result = createAnalysisResult({
    sourceScript: "calculateActions.js"
  });

  try {
    addLog(result, "Starte Berechnung...");

    const { data, headers, rows } = await fetchCSV();

    result.inputs = {
      source: {
        filename: data.filename,
        mtime: data.mtime
      },
      headers,
      rowCount: rows.length
    };

    addLog(result, `CSV-Daten geladen: ${rows.length} Zeilen, ${headers.length} Spalten.`);

    const getRow = (id, seenBy = null) => {
      const row = rows.find(r => r.id == id && (seenBy === null || r.seen_by == seenBy));
      if (row) {
        addObservation(
          result,
          `row-${id}${seenBy !== null ? `-seenBy-${seenBy}` : ""}`,
          row,
          seenBy === 3 ? 0.95 : 0.75,
          [
            `id=${id}`,
            seenBy !== null ? `seen_by=${seenBy}` : "seen_by=any"
          ]
        );
      } else {
        addLog(result, `Zeile nicht gefunden: id=${id}${seenBy !== null ? `, seen_by=${seenBy}` : ""}`, "warn");
      }
      return row;
    };

    const shoulderAxisY = 115;
    const shoulderAxisZ = 61;


    const row200 = getRow(200, 3); // Base
    const row204 = getRow(204, 3); // Base
    const row201 = getRow(201, 3); // Base

    
    const row198 = getRow(198, 3); // Bizeps oben-hinten
    const row242 = getRow(242, 3); // Bizeps unten
    const row243 = getRow(243, 3); // Bizeps vorne
    const row229 = getRow(229, 3); // Bizeps oben
    const row197 = getRow(197);    // Bizeps Seiten-Abdeckung

    const row222 = getRow(222, 3); // Ellbow
    const row226 = getRow(226, 3); // Ellbow

    const row223 = getRow(223, 3); // Forearm
    const row228 = getRow(228, 3); // Forearm
    const row218 = getRow(218, 3); // Forearm 90°
    const row219 = getRow(219, 3); // Forearm 90°

    const row212 = getRow(212, 3); // Hand

    

    // Bizeps > Y-Achse der Schulter: angleYCandidates
    calculate_angleY(row243, row229, row198, row197, shoulderAxisY, shoulderAxisZ, result);

    // Forearm rotation: a axis:

    listForearmID  = [row223, row228, row218, row219];
    listForearmAngle = [60, 145, -90, -90];
    addLog(result, "Berechnung der Unterarm-Rotation (a axis) aus x Positionen von Forearm und Ellbogen...");
    for(let r = 0; r < listForearmID.length; r++){
      if (listForearmID[r] && (row222 || row226)) {
        dx = listForearmID[r].x_mm - (row222 ? row222.x_mm : row226.x_mm); 
        if(dx > 35 || dx < -35){
          addLog(result, `dx=${dx.toFixed(2)} mm ist zu groß für eine realistische Unterarm-Rotation. Überspringe...`, "warn");
          continue;
        }
        addLog(result, `dx between ${listForearmID[r].id} and Ellbow: ${dx.toFixed(2)} mm results in angle: ${Math.asin(dx / 35)*180/Math.PI}°`);
        
        var angleRad = Math.asin(dx / 35) + listForearmAngle[r] * Math.PI / 180
        if(row222){angleRad = -angleRad }
        const angleDeg = angleRad * 180 / Math.PI;
        addLog(result, `(a axis from ${listForearmID[r].id}  with dx ${dx.toFixed(2)} mm: ${angleDeg.toFixed(2)}° = ${angleRad.toFixed(4)} rad ) aus x von ${listForearmID[r].id} und Ellbogen`);
      

        addCalculation(result, {
            type: "forearmrotationAFromX",
            input: {
              dx,
              r
            }
        });
      }
    }

    // Unterarm / z
    const angleZCandidates = [];

    if (row218 && row219) {
      const lowerArmAngle = calculateAngleFromRelativePosition(result, row218, row219, "zMotor");
      angleZCandidates.push({
        source: "row218-row219.relative",
        valueRad: lowerArmAngle,
        weight: 200     // Hohes gewicht, da ich sicher bin, dass es korrekt ist
      });
    }

    if (row226) {
      const a = calculateAngleFromRollColumn(result, row226, 0, 0, 0, "zMotor");
      angleZCandidates.push({
        source: "row226.roll_deg",
        valueRad: a,
        weight: 1
      });
    }

    if (angleZCandidates.length > 0) {
      buildFeatureFromCandidates(
        result,
        "forearm.angleZ",
        "Unterarm Z",
        "combined",
        angleZCandidates
      );
    }

    // Commands
    const angleY = result.features["shoulder.angleY"];
    const angleZ = result.features["forearm.angleZ"];

    if (angleY && angleZ) {
      const cmdConfidence = Math.min(angleY.confidence, angleZ.confidence);

      addCommand(
        result,
        "set-coord-angles-deg",
        `G92 y${angleY.valueDeg.toFixed(1)} z${angleZ.valueDeg.toFixed(1)} (Set Coord. Angles in deg)`,
        ["shoulder.angleY", "forearm.angleZ"],
        cmdConfidence
      );

      addCommand(
        result,
        "set-coord-angles-rad",
        `M92 y${angleY.valueRad.toFixed(3)} z${angleZ.valueRad.toFixed(3)} (Set Coord. Angles in rad)`,
        ["shoulder.angleY", "forearm.angleZ"],
        cmdConfidence
      );
    }

    // Ellbow / Zusatzschätzung
    if (row222 || row226 || row229 || row198 || row243 || row242 || row200 || row204) {
      let x226 = 0;
      let xCount = 0;

      if (row226) {
        x226 += row226.x_mm * 5;
        xCount += 5;
      }
      if(row222){
        /// 222 should have the same as x226
        x226 += row222.x_mm * 5;
        xCount += 5;
      }
      if (row229) {
        x226 += row229.x_mm + 90;
        xCount += 1;
      }
      if (row198) {
        x226 += row198.x_mm + 90;
        xCount += 1;
      }
      if (row243) {
        x226 += row243.x_mm + 90;
        xCount += 1;
      }
      if (row242) {
        x226 += row242.x_mm + 90;
        xCount += 1;
      }
      if (row200) {
        x226 += row200.x_mm + 154;
        xCount += 1;
      }
      if (row204) {
        x226 += row204.x_mm + 160;
        xCount += 1;
      }

      if (xCount > 0) {
        x226 = x226 / xCount;
        addLog(result, `Ellbogen x226=${x226}`);

        addCalculation(result, {
          type: "elbowXEstimate",
          source: {
            rowIds: [row226, row229, row198, row243, row242, row200, row204].filter(Boolean).map(r => r.id)
          },
          output: {
            x226
          }
        });
      }

      if (row218 || row219) {
        let x219 = 0;
        let x219Count = 0;

        if (row218) {
          x219 += row218.x_mm;
          x219Count += 1;
        }
        if (row219) {
          x219 += row219.x_mm;
          x219Count += 1;
        }

        if (x219Count > 0) {
          x219 = x219 / x219Count;
          addLog(result, `Ellbogen x219=${x219}`);

          const xDelta = x219 - x226;

          addCalculation(result, {
            type: "elbowXComparison",
            input: {
              x226,
              x219,
              xDelta
            }
          });

          if (Math.abs(xDelta) < 35) {
            addLog(result, `Ellbogen xDelta / 35=${xDelta / 35}`);
            const angleRad = Math.asin(xDelta / 35);
            const angleDeg = 90 - angleRad * 180 / Math.PI;
            addLog(result, `(xEllbow = ${angleDeg.toFixed(2)}° = ${angleRad.toFixed(4)} rad ) aus x von 218 bzw. 219`);

            addCalculation(result, {
              type: "elbowAngleFromX",
              input: {
                x226,
                x219,
                xDelta
              },
              output: {
                angleRad,
                angleDeg
              }
            });
          }
        }
      }

      // Ellbow-Rotation wenn X Position OK und 223 oder so bekannt ist.
      if(row223 && xCount > 2){
        // unterarm-roll => a    aus der position von 223  
        dx = row223.x_mm - x226;
        // aus der X Position kann der Unterarm-Winkel (a) berechnet werden

        const angleRad = Math.asin(dx / 35);
        const angleDeg = 90 - angleRad * 180 / Math.PI;
        addLog(result, `(xEllbowRotation = ${angleDeg.toFixed(2)}° = ${angleRad.toFixed(4)} rad ) aus x von 223 und Ellbogen x226`);
        addCalculation(result, {
          type: "elbowRotationAFromX223",
          input: {  
            x223: row223.x_mm,
            x226
          },
          output: {
            angleRad, angleDeg
          }
        });
      }
    }

    result.summary = {
      observationCount: result.observations.length,
      calculationCount: result.calculations.length,
      featureCount: Object.keys(result.features).length,
      commandCount: result.commands.length
    };

    addLog(
      result,
      `Berechnung fertig: ${result.summary.featureCount} Features, ${result.summary.commandCount} Commands.`
    );

    return result;
  } catch (err) {
    addError(result, err.message, err);
    return result;
  }
}

if (typeof window !== "undefined") {
  window.calculate = calculate;
  window.createAnalysisResult = createAnalysisResult;
}

if (typeof module !== "undefined") {
  module.exports = {
    calculate,
    createAnalysisResult
  };
}