import fs from "node:fs/promises";
import http from "node:http";
import path from "node:path";
import { createHash } from "node:crypto";
import puppeteer from "puppeteer-core";
import { PNG } from "pngjs";
import {
  AlignmentType,
  Document,
  HeadingLevel,
  ImageRun,
  Packer,
  Paragraph,
  Table,
  TableCell,
  TableRow,
  TextRun,
  WidthType,
} from "docx";

const REPO_ROOT = path.resolve("/home/meswork/cnc_wams");
const QA_ROOT = path.join(REPO_ROOT, "qa/web-rtcp-5axis-site-test");
const OUTPUT_DIR = path.join(QA_ROOT, "output");
const SCREENSHOT_DIR = path.join(QA_ROOT, "screenshots", "test-linuxcnc-source-run");
const TEST_SOURCE_DIR = path.join(REPO_ROOT, "web-rtcp-5axis-sim-plan/working_run/test_linuxcnc_source");
const TEST_INI_PATH = path.join(TEST_SOURCE_DIR, "xyzac-trt.ini");
const TEST_GCODE_PATH = path.join(TEST_SOURCE_DIR, "impeller-7bl-xyzac.ngc");
const VENDORED_GCODE_REL = "configs/sim/axis/vismach/5axis/table-rotary-tilting/demos/impeller-7bl-xyzac.ngc";
const CHROME_PATH = process.env.CHROME_PATH || "/usr/bin/google-chrome";
const FIXTURE_URL = "/web-rtcp-5axis-sim-plan/app/index.html";

await fs.mkdir(OUTPUT_DIR, { recursive: true });
await fs.mkdir(SCREENSHOT_DIR, { recursive: true });

const iniText = await fs.readFile(TEST_INI_PATH, "utf8");
const gcodeText = await fs.readFile(TEST_GCODE_PATH, "utf8");
const sourceEvidence = {
  iniPath: TEST_INI_PATH,
  iniSha256: sha256(iniText),
  gcodePath: TEST_GCODE_PATH,
  gcodeSha256: sha256(gcodeText),
  gcodeLineCount: gcodeText.split(/\r?\n/).length,
  gcodeBytes: Buffer.byteLength(gcodeText),
};

const server = createStaticServer(REPO_ROOT);
await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
const address = server.address();
if (!address || typeof address === "string") throw new Error("failed to start static server");
const baseUrl = `http://127.0.0.1:${address.port}`;

const browser = await puppeteer.launch({
  headless: true,
  executablePath: CHROME_PATH,
  defaultViewport: { width: 1600, height: 1200, deviceScaleFactor: 1 },
  args: [
    "--disable-gpu",
    "--enable-webgl",
    "--use-angle=swiftshader",
    "--enable-unsafe-swiftshader",
    "--no-sandbox",
  ],
});

const page = await browser.newPage();
const consoleErrors = [];
page.on("console", (msg) => {
  if (msg.type() === "error") consoleErrors.push(msg.text());
});
page.on("pageerror", (error) => consoleErrors.push(error.message));

const report = {
  generatedAt: new Date().toISOString(),
  targetUrl: `${baseUrl}${FIXTURE_URL}`,
  chromePath: CHROME_PATH,
  sourceEvidence,
  screenshots: {},
  steps: [],
  checks: [],
  samples: [],
  consoleErrors,
};

try {
  await page.goto(`${baseUrl}${FIXTURE_URL}`, { waitUntil: "networkidle2", timeout: 60000 });
  await page.waitForSelector('[data-shell="gmoccapy-5axis"]', { timeout: 15000 });
  await page.waitForFunction(() => Boolean(window.webRtcp5AxisSimulation?.getState), { timeout: 15000 });
  await waitForState((state) => state.kinematicsRuntimeReadiness?.loaded === true, 20000, "kinematics runtime ready");
  await waitForCanvasReady();
  await wait(800);
  await captureStep("01-initial-ui", "初始界面", "确认浏览器应用、五轴预览区、G-code 区和 DRO 面板已渲染。");

  await page.evaluate(async ({ ini, gcode, sourceRel }) => {
    await window.webRtcp5AxisSimulation.stageMachineFiles({
      iniText: ini,
      storageMode: "memory",
      sourceTextOverrides: {
        [sourceRel]: gcode,
      },
    });
  }, { ini: iniText, gcode: gcodeText, sourceRel: VENDORED_GCODE_REL });
  await waitForState((state) => state.machineFileStaging?.status === "staged", 20000, "test INI staged");
  await captureStep("02-stage-test-ini", "Stage test_linuxcnc_source INI", "使用 working_run/test_linuxcnc_source/xyzac-trt.ini 重新 staging machine files。");

  await page.evaluate(({ sourceRel }) => {
    window.webRtcp5AxisSimulation.dispatch({ type: "LOAD_LINUXCNC_GCODE_SOURCE", sourceRel });
  }, { sourceRel: VENDORED_GCODE_REL });
  await waitForState((state) => (
    state.activeProgram?.endsWith("impeller-7bl-xyzac.ngc") &&
    state.programExecutionSourceMode === "linuxcnc-interpreter-wasm" &&
    state.taskHalSession?.programPath?.endsWith("impeller-7bl-xyzac.ngc") &&
    state.loadedSourceBytes === sourceEvidence.gcodeBytes
  ), 25000, "impeller program loaded");
  await waitForCanvasReady();
  await wait(1200);
  await captureStep("03-toolpath-preview", "刀具路径预览", "加载 test_linuxcnc_source/impeller-7bl-xyzac.ngc 对应程序，确认 canonical motion 预览路径、TCP 球和刀轴线可见。");

  await setMachineReady();
  await captureStep("04-ready-before-run", "RUN 前准备", "POWER ON、HOME、AUTO、TCP 模式就绪，RUN gate 所需条件已满足。");

  await page.evaluate(() => document.querySelector('[data-action="RUN"]').click());
  await waitForState((state) => (
    ["running", "complete"].includes(state.runState) &&
    state.programRuntimeFeedback?.sourceMode === "linuxcnc-task-motion-hal-wasm"
  ), 15000, "RUN feedback started");

  const startedAt = Date.now();
  for (const [elapsedMs, title] of [
    [200, "G-code 执行 200ms"],
    [500, "G-code 执行 500ms"],
    [1000, "G-code 执行 1000ms"],
    [2000, "G-code 执行 2000ms"],
    [5000, "G-code 执行 5000ms"],
    [17000, "G-code 执行 17000ms"],
  ]) {
    const delay = Math.max(startedAt + elapsedMs - Date.now(), 0);
    if (delay > 0) await wait(delay);
    await waitForCanvasReady();
    await captureRunSample(elapsedMs, `05-run-${String(elapsedMs).padStart(4, "0")}ms`, title);
  }

  await page.evaluate(() => document.querySelector('[data-action="STOP"]').click());
  await waitForState((state) => state.taskHalStatusLoop?.active === false, 10000, "RUN stopped");
  await captureStep("06-stop-after-run", "STOP 后状态", "停止 RUN，确认 status loop 停止且执行证据已保留。");

  addChecks();
  report.status = report.checks.every((check) => check.pass) ? "PASS" : "FAIL";

  const jsonPath = path.join(OUTPUT_DIR, "test-linuxcnc-source-run-report.json");
  await fs.writeFile(jsonPath, `${JSON.stringify(report, null, 2)}\n`, "utf8");
  report.jsonPath = jsonPath;

  const docxPath = await writeDocxReport(report);
  report.docxPath = docxPath;
  await fs.writeFile(jsonPath, `${JSON.stringify(report, null, 2)}\n`, "utf8");
  console.log(`test_linuxcnc_source_run_status=${report.status}`);
  console.log(`test_linuxcnc_source_run_json=${jsonPath}`);
  console.log(`test_linuxcnc_source_run_docx=${docxPath}`);
} finally {
  await page.close().catch(() => {});
  await browser.close().catch(() => {});
  await new Promise((resolve) => server.close(resolve));
}

async function setMachineReady() {
  await page.evaluate(() => {
    const state = window.webRtcp5AxisSimulation.getState();
    if (state.machine?.taskState !== "on") document.querySelector('[data-action="power"]').click();
  });
  await waitForState((state) => state.machine.taskState === "on", 10000, "machine power on");
  await page.evaluate(() => document.querySelector('[data-action="mode-manual"]').click());
  await waitForState((state) => state.machine.mode === "manual", 10000, "manual mode");
  await page.evaluate(() => document.querySelector('[data-action="HOME"]').click());
  await waitForState((state) => state.machine.allHomed === true, 10000, "homed");
  await page.evaluate(() => document.querySelector('[data-action="mode-auto"]').click());
  await waitForState((state) => state.machine.mode === "auto", 10000, "auto mode");
  await page.evaluate(() => document.querySelector('[data-action="kins-tcp"]').click());
  await waitForState((state) => state.rtcpState === "on" && state.kinsType === "tcp-xyzac", 10000, "tcp mode");
}

async function captureRunSample(elapsedMs, name, title) {
  const step = await captureStep(name, title, "采集 G-code 当前高亮行、执行轨迹、实时 DRO/axisPose 和 task/HAL feedback。");
  const state = step.state;
  const sample = {
    elapsedMs,
    screenshotPath: step.screenshotPath,
    activeLine: state.activeLine,
    activeUiLine: state.activeUiLine,
    activeLineMatchesUi: state.activeLine === state.activeUiLine,
    runState: state.runState,
    axisPose: state.axisPose,
    dro: state.dro,
    droMatchesAxisPose: axesMatch(state.dro, state.programRuntimeFeedback?.axisPose),
    velocity: state.programRuntimeFeedback?.currentVelocityMmPerMin ?? null,
    expectedVelocity: state.currentTimingSegment?.velocityMmPerMin ?? null,
    feedRate: state.currentTimingSegment?.feedRate ?? null,
    feedMode: state.currentTimingSegment?.feedMode ?? null,
    segmentDurationSeconds: state.currentTimingSegment?.durationSeconds ?? null,
    distanceToGo: state.programRuntimeFeedback?.distanceToGo ?? null,
    feedbackSource: state.programRuntimeFeedback?.sourceMode ?? null,
    taskCycle: state.programRuntimeFeedback?.taskCycle ?? null,
    servoCycle: state.programRuntimeFeedback?.cycle ?? null,
    historyLength: state.programRuntimeFeedbackHistory?.length || 0,
    lineExecution: state.currentLineExecution,
    lineExecutionVisible: state.currentLineExecutionVisible,
    executedPathPoints: Number(step.dataset.threeExecutedPathPoints || 0),
    currentSegmentHighlight: step.dataset.threeCurrentSegmentHighlight,
  };
  report.samples.push(sample);
  return sample;
}

async function captureStep(name, title, description) {
  const screenshotPath = path.join(SCREENSHOT_DIR, `${name}.png`);
  await page.screenshot({ path: screenshotPath, fullPage: true });
  const dataset = await getCanvasDataset();
  const state = await getStateWithUi();
  const pixelStats = await analyzePng(screenshotPath);
  const step = {
    name,
    title,
    description,
    screenshotPath,
    dataset,
    pixelStats,
    state: summarizeState(state),
  };
  report.screenshots[name] = screenshotPath;
  report.steps.push(step);
  return step;
}

function addChecks() {
  const finalState = report.steps.at(-1)?.state || {};
  const previewStep = report.steps.find((step) => step.name === "03-toolpath-preview");
  const runSamples = report.samples;
  const movingVelocities = runSamples
    .map((sample) => Number(sample.velocity || 0))
    .filter((velocity) => velocity > 0);
  const distinctVelocities = new Set(movingVelocities.map((velocity) => Math.round(velocity * 1000) / 1000));
  const sourceState = previewStep?.state || {};
  report.checks.push(
    check("test_linuxcnc_source INI used", sourceState.iniPath?.endsWith("xyzac-trt.ini"), sourceState.iniPath || "-"),
    check("test_linuxcnc_source G-code hash matches loaded source", sourceEvidence.gcodeSha256 === "e90f0b4b6c43809da94a8170ee1029b5afc3e1bbe9bf2ae66298a8baefad013c", sourceEvidence.gcodeSha256),
    check("刀具路径预览点可见", Number(previewStep?.dataset?.threePathPoints || 0) > 100, `pathPoints=${previewStep?.dataset?.threePathPoints}`),
    check("刀具路径使用完整 canonical motion 点", Number(previewStep?.dataset?.threePathPoints || 0) === Number(sourceState.programSummary?.motionEventCount || 0), `threePathPoints=${previewStep?.dataset?.threePathPoints}, motionEventCount=${sourceState.programSummary?.motionEventCount}`),
    check("TCP/刀轴线可见", previewStep?.dataset?.threeTcpMarker === "sphere" && previewStep?.dataset?.threeToolAxisMarker === "line", `tcp=${previewStep?.dataset?.threeTcpMarker}, axis=${previewStep?.dataset?.threeToolAxisMarker}`),
    check("RUN 采样数量", runSamples.length >= 5, `samples=${runSamples.length}`),
    check("每行执行高亮同步", runSamples.every((sample) => sample.activeLineMatchesUi), runSamples.map((sample) => `${sample.activeLine}/${sample.activeUiLine}`).join(", ")),
    check("程序列表显示每行执行过程", runSamples.every((sample) => sample.lineExecution?.line === sample.activeLine && sample.lineExecutionVisible === true), runSamples.map((sample) => `${sample.activeLine}:${sample.lineExecution?.status || "-"}:${sample.lineExecutionVisible}`).join(", ")),
    check("执行轨迹可见", runSamples.every((sample) => sample.executedPathPoints >= 1 && sample.currentSegmentHighlight === "ok"), runSamples.map((sample) => `${sample.executedPathPoints}/${sample.currentSegmentHighlight}`).join(", ")),
    check("实时轴值来自 task/HAL feedback", runSamples.every((sample) => sample.feedbackSource === "linuxcnc-task-motion-hal-wasm" && sample.droMatchesAxisPose), runSamples.map((sample) => `${sample.feedbackSource}/${sample.droMatchesAxisPose}`).join(", ")),
    check("RUN feed 不是固定 3600 mm/min", movingVelocities.length > 0 && movingVelocities.every((velocity) => Math.abs(velocity - 3600) > 0.001), runSamples.map((sample) => `${sample.elapsedMs}ms=${sample.velocity}`).join(", ")),
    check("RUN feed 随实际 G-code F/G93 段变化", distinctVelocities.size >= 3, [...distinctVelocities].join(", ")),
    check("RUN 使用 G93 inverse-time feed", runSamples.some((sample) => sample.feedMode === "inverse-time" && Number(sample.segmentDurationSeconds || 0) > 0), runSamples.map((sample) => `${sample.elapsedMs}ms F${sample.feedRate} ${sample.feedMode} ${sample.segmentDurationSeconds}s`).join(", ")),
    check("task/HAL cycle 推进", runSamples.some((sample) => Number(sample.taskCycle || 0) > 0 && Number(sample.servoCycle || 0) > 0), runSamples.map((sample) => `${sample.taskCycle}/${sample.servoCycle}`).join(", ")),
    check("STOP 后 loop 停止", finalState.taskHalStatusLoop?.active === false, `active=${finalState.taskHalStatusLoop?.active}, stopReason=${finalState.taskHalStatusLoop?.stopReason}`),
  );
}

function summarizeState(state) {
  const currentTimingSegment = currentTimingSegmentForState(state);
  return {
    activeProgram: state.activeProgram,
    programSource: state.programSource,
    programExecutionSourceMode: state.programExecutionSourceMode,
    programSummary: state.programExecution?.summary || null,
    machineProfile: state.machineProfile,
    iniPath: state.iniConfigReadiness?.path || state.linuxCncIniConfig?.path || null,
    selectedGcodeSourceRel: state.machineFileStaging?.selectedGcodeSourceRel || null,
    loadedSourceBytes: state.machineFileStaging?.save?.files?.find((file) => file.sourceRel === state.machineFileStaging?.selectedGcodeSourceRel)?.bytes || null,
    taskHalProgramPath: state.taskHalSession?.programPath || null,
    runState: state.runState,
    activeLine: state.activeLine,
    activeUiLine: state.__activeUiLine,
    machine: state.machine,
    rtcpState: state.rtcpState,
    kinsType: state.kinsType,
    dro: pickAxes(state.dro),
    axisPose: pickAxes(state.axisPose),
    programRuntimeFeedback: state.programRuntimeFeedback,
    currentTimingSegment,
    currentLineExecution: state.programLineExecution?.[state.activeLine] || null,
    currentLineExecutionVisible: Boolean(state.__activeUiLineExecutionText?.includes("F ") && state.__activeUiLineExecutionText?.includes("cycle")),
    feedbackHistoryLength: state.programRuntimeFeedbackHistory?.length || 0,
    taskHalStatusLoop: state.taskHalStatusLoop,
    taskHalStatus: state.taskHalStatus ? {
      taskState: state.taskHalStatus.ui?.taskState || state.taskHalStatus.task?.state || null,
      taskMode: state.taskHalStatus.ui?.taskMode || state.taskHalStatus.task?.mode || null,
      interpState: state.taskHalStatus.ui?.interpState || state.taskHalStatus.task?.interpState || null,
      activeLine: state.taskHalStatus.ui?.activeLine || null,
      taskCycle: state.taskHalStatus.ui?.taskCycle || null,
      servoCycle: state.taskHalStatus.ui?.servoCycle || null,
    } : null,
  };
}

function currentTimingSegmentForState(state) {
  const activeLine = Number(state.activeLine || 0);
  const segments = state.programExecutionTiming?.segments || [];
  if (!Number.isFinite(activeLine) || !Array.isArray(segments) || segments.length === 0) {
    return null;
  }
  return segments.find((segment) => Number(segment.line) === activeLine)
    || [...segments].reverse().find((segment) => Number(segment.line) <= activeLine)
    || null;
}

async function wait(ms) {
  await new Promise((resolve) => setTimeout(resolve, ms));
}

async function waitForState(predicate, timeoutMs, label) {
  const start = Date.now();
  while (Date.now() - start < timeoutMs) {
    const state = await getStateWithUi();
    if (predicate(state)) return state;
    await wait(100);
  }
  throw new Error(`timeout waiting for ${label}`);
}

async function waitForCanvasReady(timeoutMs = 20000) {
  await page.waitForFunction(() => {
    const canvas = document.querySelector("[data-five-axis-canvas]");
    return canvas?.dataset?.threeReady === "true"
      && canvas?.dataset?.threePreviewScope === "machine-reference-and-toolpath";
  }, { timeout: timeoutMs });
}

async function getStateWithUi() {
  return page.evaluate(() => {
    const state = JSON.parse(JSON.stringify(window.webRtcp5AxisSimulation.getState()));
    const activeRow = document.querySelector(".gcode-row.active");
    state.__activeUiLine = Number(activeRow?.dataset.programLine || 0);
    state.__activeUiLineExecutionText = activeRow?.querySelector("[data-line-execution]")?.textContent || "";
    state.loadedSourceBytes = state.machineFileStaging?.save?.files
      ?.find((file) => file.sourceRel === state.machineFileStaging?.selectedGcodeSourceRel)
      ?.bytes || null;
    return state;
  });
}

async function getCanvasDataset() {
  return page.$eval("[data-five-axis-canvas]", (canvas) => ({ ...canvas.dataset }));
}

function createStaticServer(rootDir) {
  return http.createServer(async (request, response) => {
    try {
      const requestPath = decodeURIComponent(new URL(request.url || "/", "http://127.0.0.1").pathname);
      const relativePath = requestPath === "/" ? "/index.html" : requestPath;
      const targetPath = path.resolve(rootDir, `.${relativePath}`);
      if (!targetPath.startsWith(rootDir)) {
        response.writeHead(403);
        response.end("forbidden");
        return;
      }
      let filePath = targetPath;
      let stat = await fs.stat(filePath).catch(() => null);
      if (stat?.isDirectory()) {
        filePath = path.join(filePath, "index.html");
        stat = await fs.stat(filePath).catch(() => null);
      }
      if (!stat?.isFile()) {
        response.writeHead(404);
        response.end("not found");
        return;
      }
      const body = await fs.readFile(filePath);
      response.writeHead(200, {
        "Content-Type": contentTypeFor(filePath),
        "Content-Length": String(body.byteLength),
        "Cache-Control": "no-store",
      });
      response.end(body);
    } catch (error) {
      response.writeHead(500);
      response.end(error instanceof Error ? error.message : String(error));
    }
  });
}

function contentTypeFor(filePath) {
  const ext = path.extname(filePath).toLowerCase();
  return {
    ".css": "text/css; charset=utf-8",
    ".html": "text/html; charset=utf-8",
    ".js": "text/javascript; charset=utf-8",
    ".json": "application/json; charset=utf-8",
    ".mjs": "text/javascript; charset=utf-8",
    ".svg": "image/svg+xml",
    ".wasm": "application/wasm",
    ".xml": "application/xml; charset=utf-8",
  }[ext] || "application/octet-stream";
}

async function analyzePng(filePath) {
  const png = PNG.sync.read(await fs.readFile(filePath));
  let luminanceSum = 0;
  let nonBlack = 0;
  for (let index = 0; index < png.data.length; index += 4) {
    const luminance = png.data[index] * 0.2126 + png.data[index + 1] * 0.7152 + png.data[index + 2] * 0.0722;
    luminanceSum += luminance;
    if (luminance > 8) nonBlack += 1;
  }
  const total = png.width * png.height;
  return {
    width: png.width,
    height: png.height,
    averageLuminance: Number((luminanceSum / total).toFixed(2)),
    nonBlackRatio: Number((nonBlack / total).toFixed(4)),
  };
}

async function writeDocxReport(data) {
  const generated = new Date(data.generatedAt);
  const ymd = generated.toISOString().slice(0, 10);
  const docxPath = path.join(OUTPUT_DIR, `test-linuxcnc-source-run-report-${ymd}.docx`);
  const children = [
    new Paragraph({
      text: "test_linuxcnc_source RUN 功能测试报告",
      heading: HeadingLevel.TITLE,
      alignment: AlignmentType.CENTER,
    }),
    centered(`测试对象：${data.targetUrl}`),
    centered(`生成时间：${formatDateTime(generated)}`),
    blank(),
    heading("1. 测试结论"),
    para(`本次使用 working_run/test_linuxcnc_source 中的 INI 与 G-code 文件执行 RUN 测试，结果：${data.status}。`),
    checksTable(data.checks),
    heading("2. 测试源文件"),
    kvTable([
      ["INI", data.sourceEvidence.iniPath],
      ["INI SHA-256", data.sourceEvidence.iniSha256],
      ["G-code", data.sourceEvidence.gcodePath],
      ["G-code SHA-256", data.sourceEvidence.gcodeSha256],
      ["G-code 行数/字节", `${data.sourceEvidence.gcodeLineCount} / ${data.sourceEvidence.gcodeBytes}`],
    ]),
    heading("3. 测试过程"),
  ];

  for (const step of data.steps) {
    children.push(...(await stepBlock(step)));
  }

  children.push(
    heading("4. RUN 采样明细"),
    sampleTable(data.samples),
    heading("5. 原始证据"),
    kvTable([
      ["JSON", data.jsonPath || path.join(OUTPUT_DIR, "test-linuxcnc-source-run-report.json")],
      ["截图目录", SCREENSHOT_DIR],
      ["Word", docxPath],
      ["Console error", String(data.consoleErrors.length)],
      ["Chrome", data.chromePath],
    ]),
  );

  if (data.consoleErrors.length > 0) {
    children.push(heading("6. Console Error"), ...data.consoleErrors.map((entry) => para(entry)));
  }

  const doc = new Document({ sections: [{ properties: {}, children }] });
  await fs.writeFile(docxPath, await Packer.toBuffer(doc));
  return docxPath;
}

async function stepBlock(step) {
  const image = await fs.readFile(step.screenshotPath);
  return [
    new Paragraph({
      text: `${step.name} - ${step.title}`,
      heading: HeadingLevel.HEADING_2,
      spacing: { before: 180, after: 120 },
    }),
    para(step.description),
    kvTable([
      ["activeProgram", step.state.activeProgram],
      ["runState / activeLine", `${step.state.runState} / ${step.state.activeLine}`],
      ["program source", `${step.state.programSource} / ${step.state.programExecutionSourceMode}`],
      ["selected G-code", step.state.selectedGcodeSourceRel],
      ["task/HAL program", step.state.taskHalProgramPath],
      ["DRO XYZAC", axesText(step.state.dro)],
      ["axisPose XYZAC", axesText(step.state.axisPose)],
      ["path/executed", `${step.dataset.threePathPoints || 0} / ${step.dataset.threeExecutedPathPoints || 0}`],
      ["RTCP / kins", `${step.state.rtcpState} / ${step.state.kinsType}`],
      ["pixel", `luma=${step.pixelStats.averageLuminance}, nonBlack=${step.pixelStats.nonBlackRatio}`],
    ]),
    new Paragraph({
      alignment: AlignmentType.CENTER,
      children: [new ImageRun({
        data: image,
        type: "png",
        transformation: { width: 520, height: 390 },
      })],
    }),
    para(`截图文件：${step.screenshotPath}`),
  ];
}

function sampleTable(samples) {
  return new Table({
    width: { size: 100, type: WidthType.PERCENTAGE },
    rows: [
      new TableRow({
      children: ["时间", "行号", "状态", "DRO XYZAC", "速度/feed", "轨迹点", "反馈"].map((text) => cell(text, true)),
      }),
      ...samples.map((sample) => new TableRow({
        children: [
          cell(`${sample.elapsedMs}ms`),
          cell(`${sample.activeLine} / UI ${sample.activeUiLine}`),
          cell(sample.runState),
          cell(axesText(sample.dro)),
          cell(`${sample.velocity ?? "-"} mm/min\nF${sample.feedRate ?? "-"} ${sample.feedMode ?? "-"}`),
          cell(String(sample.executedPathPoints)),
          cell(`${sample.feedbackSource}\ncycle=${sample.taskCycle}/${sample.servoCycle}`),
        ],
      })),
    ],
  });
}

function checksTable(checks) {
  return new Table({
    width: { size: 100, type: WidthType.PERCENTAGE },
    rows: [
      new TableRow({ children: [cell("检查项", true), cell("结果", true), cell("证据", true)] }),
      ...checks.map((item) => new TableRow({
        children: [cell(item.name), cell(item.pass ? "PASS" : "FAIL"), cell(item.detail)],
      })),
    ],
  });
}

function kvTable(rows) {
  return new Table({
    width: { size: 100, type: WidthType.PERCENTAGE },
    rows: [
      new TableRow({ children: [cell("项目", true), cell("内容", true)] }),
      ...rows.map(([key, value]) => new TableRow({ children: [cell(key), cell(value)] })),
    ],
  });
}

function centered(text) {
  return new Paragraph({ alignment: AlignmentType.CENTER, children: [new TextRun(String(text))] });
}

function heading(text) {
  return new Paragraph({ text, heading: HeadingLevel.HEADING_1, spacing: { before: 240, after: 120 } });
}

function blank() {
  return new Paragraph({ text: "" });
}

function para(text) {
  return new Paragraph({ children: [new TextRun(String(text ?? "-"))], spacing: { after: 100 } });
}

function cell(text, bold = false) {
  return new TableCell({
    width: { size: 25, type: WidthType.PERCENTAGE },
    children: String(text ?? "-").split("\n").map((line) => new Paragraph({
      children: [new TextRun({ text: line, bold })],
    })),
  });
}

function check(name, pass, detail) {
  return { name, pass: Boolean(pass), detail: String(detail ?? "-") };
}

function pickAxes(value = {}) {
  return {
    x: Number(value.x || 0),
    y: Number(value.y || 0),
    z: Number(value.z || 0),
    a: Number(value.a || 0),
    b: Number(value.b || 0),
    c: Number(value.c || 0),
  };
}

function axesMatch(left = {}, right = {}) {
  return ["x", "y", "z", "a", "b", "c"].every((axis) => Math.abs(Number(left?.[axis] || 0) - Number(right?.[axis] || 0)) < 1e-9);
}

function axesText(value = {}) {
  const axes = pickAxes(value);
  return `X=${fmt(axes.x)} Y=${fmt(axes.y)} Z=${fmt(axes.z)} A=${fmt(axes.a)} B=${fmt(axes.b)} C=${fmt(axes.c)}`;
}

function fmt(value) {
  return Number(value || 0).toFixed(3);
}

function sha256(text) {
  return createHash("sha256").update(text).digest("hex");
}

function formatDateTime(date) {
  return date.toISOString().replace("T", " ").replace(/\.\d+Z$/, " UTC");
}