#!/usr/bin/env node

import readline from "node:readline";
import { mkdir } from "node:fs/promises";
import { appendFileSync } from "node:fs";
import { chromium } from "playwright-core";

const ERP_URL = process.env.DEWU_1688_ERP_URL || "https://www.erp321.com/epaas";
const USERNAME = process.env.DEWU_1688_ERP_USERNAME || "";
const PASSWORD = process.env.DEWU_1688_ERP_PASSWORD || "";
const BROWSER_CODE = process.env.DEWU_1688_BROWSER_CODE || "ERP-UNASSIGNED";
const PROFILE_DIR =
  process.env.DEWU_1688_BROWSER_PROFILE ||
  `/opt/dalongxia-chat-api/data/dewu-1688-browser-profiles/${BROWSER_CODE}`;
const EXECUTABLE =
  process.env.DEWU_1688_CHROMIUM_PATH || "/snap/bin/chromium";
const HEADLESS = !["0", "false", "no"].includes(
  String(process.env.DEWU_1688_HEADLESS || "1").toLowerCase(),
);
const ACTION_TIMEOUT = Number(process.env.DEWU_1688_ACTION_TIMEOUT_MS || 15000);
const ONLINE_VERIFY_TIMEOUT = Number(
  process.env.DEWU_1688_ONLINE_VERIFY_TIMEOUT_MS || 20000,
);
const BATCH_VERIFY_TIMEOUT = Number(
  process.env.DEWU_1688_BATCH_VERIFY_TIMEOUT_MS || 180000,
);
const BATCH_VERIFY_POLL_INTERVAL = Number(
  process.env.DEWU_1688_BATCH_VERIFY_POLL_INTERVAL_MS || 30000,
);
const BATCH_VERIFY_MAX_ATTEMPTS = Number(
  process.env.DEWU_1688_BATCH_VERIFY_MAX_ATTEMPTS || 3,
);
const DEBUG_LOG =
  process.env.DEWU_1688_DEBUG_LOG ||
  "/opt/dalongxia-chat-api/data/dewu-1688-worker.log";

let context;
let page;

function clean(value, limit = 300) {
  return String(value || "").replace(/\s+/g, " ").trim().slice(0, limit);
}

function safeOrderFailure(message) {
  const error = new Error(message);
  error.safeToContinue = true;
  return error;
}

function normalizedContactText(value) {
  return String(value || "")
    .toLowerCase()
    .replace(/[^0-9a-z\u4e00-\u9fff]/g, "");
}

function withoutPrivacySuffix(value) {
  return String(value || "")
    .replace(/\s*[\[\uff3b]\d{4,8}[\]\uff3d]\s*$/u, "")
    .trim();
}

function erpRecipientText(value) {
  const source = withoutPrivacySuffix(value);
  const chinese = (
    source.match(/[\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff]/gu) || []
  ).join("");
  return String(chinese || source).trim().slice(0, 30);
}

function normalizedRecipientText(value) {
  return normalizedContactText(withoutPrivacySuffix(value));
}

function privacyPhoneSuffix(value) {
  const matched = String(value || "").match(/(?:-|\u2014|\uff0d)(\d{4})\s*$/u);
  return matched ? matched[1] : "";
}

function normalizedPhoneDigits(value) {
  const source = String(value || "").trim();
  const privacyNumber = source.match(
    /^\s*(1[3-9]\d{9})\s*(?:-|\u2014|\uff0d)\s*\d{4}\s*$/u,
  );
  return privacyNumber ? privacyNumber[1] : source.replace(/\D/g, "");
}

function phoneValueDiagnostic(value) {
  const source = String(value || "").trim();
  const digits = normalizedPhoneDigits(source);
  return [
    source ? "filled" : "empty",
    isMaskedContactValue(source) ? "masked" : "plain",
    `digits=${digits.length}`,
    `tail=${digits ? digits.slice(-4) : "-"}`,
  ].join(":");
}

function isMaskedContactValue(value) {
  return /[*\uff0a•●]{2,}/u.test(String(value || ""));
}

function normalizedMaskedRecipientPattern(value) {
  return withoutPrivacySuffix(value)
    .toLowerCase()
    .replace(/[*\uff0a•●]+/gu, "*")
    .replace(/[^0-9a-z\u4e00-\u9fff*]/gu, "");
}

function isMaskedRecipientValue(value) {
  return /[*\uff0a•●]/u.test(String(value || ""));
}

function maskedRecipientMatchesExpected(actual, expected) {
  const pattern = normalizedMaskedRecipientPattern(actual);
  const normalizedExpected = normalizedRecipientText(expected);
  if (!pattern.includes("*") || !normalizedExpected) return false;
  const visibleText = pattern.replace(/\*/g, "");
  if (!visibleText) return true;
  const expression = pattern
    .split("*")
    .map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
    .join(".+");
  return new RegExp(`^${expression}$`, "u").test(normalizedExpected);
}

function collapseRepeatedAddressSegments(value) {
  let current = value;
  for (let attempt = 0; attempt < 4; attempt += 1) {
    const collapsed = current.replace(
      /([\u4e00-\u9fff]{2,12}(?:省|市|区|县|镇|乡|街道))\1/gu,
      "$1",
    );
    if (collapsed === current) break;
    current = collapsed;
  }
  return current;
}

function canonicalAddressText(value, administrativeParts = []) {
  let text = normalizedContactText(withoutPrivacySuffix(value));
  const removable = new Set();
  for (const part of administrativeParts) {
    const normalized = normalizedContactText(part);
    if (!normalized) continue;
    removable.add(normalized);
    const alias = normalized.replace(/(?:省|市|区|县)$/u, "");
    if (alias.length >= 2) removable.add(alias);
  }
  for (const token of [...removable].sort((a, b) => b.length - a.length)) {
    text = text.split(token).join("");
  }
  return collapseRepeatedAddressSegments(text);
}

function addressTextMatches(
  expected,
  actual,
  administrativeParts = [],
) {
  const expectedText = canonicalAddressText(expected, administrativeParts);
  const actualText = canonicalAddressText(actual, administrativeParts);
  const minimumComparableLength =
    administrativeParts.filter((part) => normalizedContactText(part)).length >= 3
      ? 4
      : 6;
  return (
    expectedText.length >= minimumComparableLength &&
    actualText.length >= minimumComparableLength &&
    (actualText.includes(expectedText) || expectedText.includes(actualText))
  );
}

function contactTextMatchesOrder(order, actual) {
  const text = normalizedContactText(actual);
  const verified = order.__verifiedDelivery || {};
  const recipient = normalizedRecipientText(
    verified.recipient || order.recipient,
  );
  const phone = normalizedPhoneDigits(verified.phone || order.phone);
  const privacySuffix = privacyPhoneSuffix(order.phone);
  const address = verified.address || order.address;
  return (
    recipient.length > 0 &&
    phone.length >= 7 &&
    text.includes(recipient) &&
    text.includes(phone) &&
    (!privacySuffix || text.includes(privacySuffix)) &&
    addressTextMatches(address, actual)
  );
}

const SUBMISSION_RISK_STEPS = new Set([
  "supplier.1688.save.started",
  "supplier.1688.save.completed",
  "supplier.1688.save_confirm.started",
  "supplier.1688.save_confirm.completed",
  "supplier.1688.native_confirm.started",
  "supplier.1688.native_confirm.completed",
  "supplier.1688.order.waiting",
  "supplier.1688.verify.started",
  "supplier.1688.submission.accepted",
  "supplier.1688.confirm.started",
  "supplier.1688.confirm.completed",
  "supplier.1688.dialog.closed",
  "supplier.1688.dialog.success",
]);

function stepMayHaveChangedExternalState(stepCode) {
  const code = clean(stepCode, 100);
  return (
    code === "address.save.started" ||
    code === "purchase.generate.submit.started" ||
    code.startsWith("purchase.audit.submit.") ||
    SUBMISSION_RISK_STEPS.has(code)
  );
}

function publicFailure(error, fallback = "ERP 页面状态与预期不一致") {
  const text = clean(error?.message || error, 180);
  const mappings = [
    [
      /Existing purchase number verification failed/i,
      "订单详情中的采购单号与预检记录不一致，本单已隔离待人工核对，后续订单继续处理",
    ],
    [
      /Existing purchase number was not loaded/i,
      "订单详情暂未加载出已有采购单号，本单已隔离且不会重复生成采购单，后续订单继续处理",
    ],
    [
      /Generated purchase number was not found/i,
      "采购单已提交生成，但暂未读取到采购单号，本单已隔离待人工核对，后续订单继续处理",
    ],
    [
      /Purchase is not waiting for audit/i,
      "采购单状态不是待审核或已审核，本单已隔离待人工核对，后续订单继续处理",
    ],
    [
      /Purchase audit confirmation was not completed/i,
      "采购单审核确认未完成，本单已隔离；采购单已保留，请人工核对审核状态",
    ],
    [
      /Purchase audit failed/i,
      "ERP返回采购单审核失败，本单已隔离，请人工核对采购单；后续订单继续处理",
    ],
    [
      /purchase row container count is not one|Purchase row selection was not isolated/i,
      "采购单行定位暂不稳定，本单已隔离待人工核对，后续订单继续处理",
    ],
    [
      /1688 online order (?:number was not found|verification (?:failed|timed out))/i,
      "1688线上单号复核未通过，本单转入待复核，后续订单继续处理",
    ],
    [
      /1688 submission (?:was rejected|confirmation was not received)/i,
      "ERP未返回1688下单成功确认，本单未完成，系统不会将其计为成功",
    ],
    [
      /Address parse verification failed/i,
      "收货地址识别结果与原始资料不一致，本单已跳过且未保存，后续订单继续处理",
    ],
    [
      /Saved address verification failed/i,
      "ERP保存后回读的收货信息与上传资料不一致，本单已阻止1688下单，后续订单继续处理",
    ],
    [
      /1688 (?:delivery address verification|default delivery address capture) failed/i,
      "1688页面未切换到当前订单的收货地址，已阻止使用默认公司地址下单，后续订单继续处理",
    ],
    [
      /1688 account was not ready/i,
      "1688账号暂未加载完成，本轮未重复提交下单，请稍后重试",
    ],
  ];
  for (const [pattern, message] of mappings) {
    if (pattern.test(text)) return message;
  }
  if (
    !text ||
    /(selector|locator|playwright|browsertype|chromium|chrome|timeout|stack|\/opt\/|\/snap\/|cookie|token|password|credential|iframe|frame|welcome|not found|ambiguous|unexpected|control|page\.goto|net::|call log|launchpersistentcontext|referenceerror|typeerror|is not defined|cannot read (?:properties|property))/i.test(
      text,
    )
  ) {
    return fallback;
  }
  return text;
}

function logInternalError(error, scope = "worker") {
  try {
    const value = String(error?.stack || error?.message || error)
      .replace(/\r?\n/g, " | ")
      .slice(0, 4000);
    appendFileSync(
      DEBUG_LOG,
      `${new Date().toISOString()} ${BROWSER_CODE} ${scope} ${value}\n`,
      { encoding: "utf8", mode: 0o600 },
    );
  } catch {
    // Diagnostics must never change task behavior.
  }
}

async function ensureBrowser() {
  if (context && page && !page.isClosed()) return;
  if (!USERNAME || !PASSWORD) {
    throw new Error("ERP credentials are not configured");
  }
  await mkdir(PROFILE_DIR, { recursive: true });
  context = await chromium.launchPersistentContext(PROFILE_DIR, {
    executablePath: EXECUTABLE,
    headless: HEADLESS,
    viewport: { width: 1440, height: 960 },
    args: ["--no-sandbox", "--disable-dev-shm-usage", "--disable-gpu"],
  });
  context.setDefaultTimeout(ACTION_TIMEOUT);
  const pages = context.pages();
  page = pages[0] || (await context.newPage());
  for (const extra of pages.slice(1)) {
    await extra.close().catch(() => {});
  }
  context.on("page", async (candidate) => {
    if (page && !page.isClosed() && candidate !== page) {
      await candidate.close().catch(() => {});
    }
  });
}

async function firstVisible(locator) {
  let count = 0;
  try {
    count = await locator.count();
  } catch {
    return [];
  }
  const visible = [];
  for (let index = 0; index < count; index += 1) {
    const item = locator.nth(index);
    if (await item.isVisible().catch(() => false)) visible.push(item);
  }
  return visible;
}

async function oneVisible(locator, label) {
  const visible = await firstVisible(locator);
  if (visible.length !== 1) {
    throw new Error(`${label} visible count ${visible.length}`);
  }
  return visible[0];
}

async function waitForOneVisible(locator, label, timeoutMs = 25000) {
  const deadline = Date.now() + timeoutMs;
  while (Date.now() < deadline) {
    const visible = await firstVisible(locator);
    if (visible.length === 1) return visible[0];
    if (visible.length > 1) {
      throw new Error(`${label} visible count ${visible.length}`);
    }
    await page.waitForTimeout(250);
  }
  throw new Error(`${label} visible count 0`);
}

async function clickExactText(frame, text, label = text) {
  const item = await oneVisible(frame.getByText(text, { exact: true }), label);
  await item.click();
}

async function dismissBlockingTips(frame) {
  const tips = frame.locator("#TopPoolTip");
  const count = await tips.count();
  for (let index = 0; index < count; index += 1) {
    const tip = tips.nth(index);
    if (!(await tip.isVisible().catch(() => false))) continue;
    await tip.evaluate((element) => {
      const overlay = element.closest("div.contip") || element;
      overlay.style.display = "none";
      overlay.style.pointerEvents = "none";
    });
  }
}

async function waitForFrameWithVisibleTexts(
  texts,
  label,
  timeoutMs = 25000,
) {
  const deadline = Date.now() + timeoutMs;
  while (Date.now() < deadline) {
    const matches = [];
    for (const candidate of page.frames()) {
      let matched = true;
      for (const text of texts) {
        const visible = await firstVisible(
          candidate.getByText(text, { exact: true }),
        );
        if (visible.length !== 1) {
          matched = false;
          break;
        }
      }
      if (matched) matches.push(candidate);
    }
    if (matches.length === 1) return matches[0];
    if (matches.length > 1) {
      throw new Error(`${label} frame count ${matches.length}`);
    }
    await page.waitForTimeout(250);
  }
  throw new Error(`${label} frame not found`);
}

async function waitForPurchasePreviewFrame(timeoutMs = 25000) {
  const deadline = Date.now() + timeoutMs;
  while (Date.now() < deadline) {
    const matches = [];
    for (const candidate of page.frames()) {
      const plaintext = await firstVisible(
        candidate.getByText("明文", { exact: true }),
      );
      const generate = await firstVisible(
        candidate.getByText("生成采购单", { exact: true }),
      );
      if (plaintext.length === 1 && generate.length === 1) {
        matches.push(candidate);
      }
      if (
        candidate.url().includes("/epaas-dialog-frame.html") &&
        (await frameChainVisible(candidate).catch(() => false))
      ) {
        const body = clean(
          await candidate.locator("body").innerText().catch(() => ""),
          500,
        );
        if (/不支持[\s\S]{0,120}生成采购单|生成采购单[\s\S]{0,120}不支持/.test(body)) {
          const close = await firstVisible(
            candidate.getByText("关闭", { exact: true }),
          );
          if (close.length === 1) await close[0].click().catch(() => {});
          throw new Error(`ERP拒绝生成采购单：${body}`);
        }
      }
    }
    if (matches.length === 1) return matches[0];
    if (matches.length > 1) {
      throw new Error(`purchase preview frame count ${matches.length}`);
    }
    await page.waitForTimeout(250);
  }
  throw new Error("purchase preview frame not found");
}

async function closeVisibleEpaasDialogs(timeoutMs = 8000) {
  const deadline = Date.now() + timeoutMs;
  while (Date.now() < deadline) {
    const visibleDialogs = [];
    for (const candidate of page.frames()) {
      if (
        candidate.url().includes("/epaas-dialog-frame.html") &&
        (await frameChainVisible(candidate).catch(() => false))
      ) {
        visibleDialogs.push(candidate);
      }
    }
    if (!visibleDialogs.length) return;
    for (const candidate of visibleDialogs.reverse()) {
      for (const label of ["确定", "确认", "关闭", "取消"]) {
        const controls = await firstVisible(
          candidate.getByText(label, { exact: true }),
        );
        if (controls.length === 1) {
          await controls[0].click({ force: true }).catch(() => {});
          await page.waitForTimeout(250);
          break;
        }
      }
      await candidate.locator("body").press("Escape").catch(() => {});
    }
    await page.keyboard.press("Escape").catch(() => {});
    await page.waitForTimeout(250);
  }
  const body = [];
  for (const candidate of page.frames()) {
    if (
      candidate.url().includes("/epaas-dialog-frame.html") &&
      (await frameChainVisible(candidate).catch(() => false))
    ) {
      body.push(
        clean(
          await candidate.locator("body").innerText().catch(() => ""),
          500,
        ),
      );
    }
  }
  if (!body.some(Boolean)) {
    const blankOverlays = page.locator("iframe#epaasDialogFrame");
    const count = await blankOverlays.count();
    for (let index = 0; index < count; index += 1) {
      const overlay = blankOverlays.nth(index);
      if (!(await overlay.isVisible().catch(() => false))) continue;
      await overlay.evaluate((element) => {
        element.style.display = "none";
        element.style.pointerEvents = "none";
        element.setAttribute("aria-hidden", "true");
      });
    }
    return;
  }
  throw new Error(`ERP弹窗未关闭：${clean(body.join(" | "), 500)}`);
}

async function hideBlankEpaasPointerOverlays(navigationFrame) {
  const overlays = page.locator("iframe#epaasDialogFrame");
  const count = await overlays.count();
  let hidden = 0;
  for (let index = 0; index < count; index += 1) {
    const overlay = overlays.nth(index);
    if (!(await overlay.isVisible().catch(() => false))) continue;
    const handle = await overlay.elementHandle().catch(() => null);
    const candidate = handle
      ? await handle.contentFrame().catch(() => null)
      : null;
    if (!candidate || isDescendantFrame(candidate, navigationFrame)) continue;
    const body = clean(
      await candidate.locator("body").innerText().catch(() => ""),
      500,
    );
    if (body) continue;
    await overlay.evaluate((element) => {
      element.style.display = "none";
      element.style.pointerEvents = "none";
      element.setAttribute("aria-hidden", "true");
    });
    hidden += 1;
  }
  return hidden;
}

async function waitForVisibleTextAcrossFrames(
  text,
  label,
  timeoutMs = 25000,
  exact = false,
) {
  const deadline = Date.now() + timeoutMs;
  while (Date.now() < deadline) {
    const matches = [];
    for (const candidate of page.frames()) {
      if (!(await frameChainVisible(candidate).catch(() => false))) continue;
      for (const item of await firstVisible(
        candidate.getByText(text, { exact }),
      )) {
        matches.push({ frame: candidate, item });
      }
    }
    if (matches.length === 1) return matches[0];
    if (matches.length > 1) {
      throw new Error(`${label} visible count ${matches.length}`);
    }
    await page.waitForTimeout(250);
  }
  throw new Error(`${label} not found`);
}

async function waitForVisibleLocatorAcrossFrames(
  selector,
  label,
  timeoutMs = 25000,
) {
  const deadline = Date.now() + timeoutMs;
  while (Date.now() < deadline) {
    const matches = [];
    for (const candidate of page.frames()) {
      if (!(await frameChainVisible(candidate).catch(() => false))) continue;
      for (const item of await firstVisible(candidate.locator(selector))) {
        matches.push({ frame: candidate, item });
      }
    }
    if (matches.length === 1) return matches[0];
    if (matches.length > 1) {
      throw new Error(`${label} visible count ${matches.length}`);
    }
    await page.waitForTimeout(250);
  }
  throw new Error(`${label} not found`);
}

async function loginFormVisible() {
  return page
    .locator('input[placeholder="邮箱地址/手机号码"]')
    .isVisible()
    .catch(() => false);
}

async function otpFormVisible() {
  return page
    .locator('input[placeholder="输入验证码"]')
    .isVisible()
    .catch(() => false);
}

async function gotoErp() {
  try {
    await page.goto(ERP_URL, { waitUntil: "domcontentloaded" });
  } catch (error) {
    if (!/net::ERR_ABORTED/i.test(String(error?.message || error))) {
      throw error;
    }
    await page.waitForTimeout(800);
  }
}

function erpApplicationVisible() {
  return page.frames().some(
    (frame) =>
      frame.url().includes("/erp-web-group/home/") ||
      frame.url().includes("/app/order/order/list.aspx"),
  );
}

async function submitCredentials() {
  const account = page.locator('input[placeholder="邮箱地址/手机号码"]');
  const password = page.locator('input[placeholder="请输入密码"]');
  if ((await account.count()) !== 1 || (await password.count()) !== 1) {
    throw new Error("Unexpected login form");
  }
  await account.fill(USERNAME);
  await password.fill(PASSWORD);
  const checkbox = page.locator('input[type="checkbox"]').first();
  if ((await checkbox.count()) === 1 && !(await checkbox.isChecked())) {
    await checkbox.check();
  }
  await clickExactText(page, "立即登录", "login button");
  await page.waitForTimeout(700);
}

async function sendSmsIfNeeded(force = false) {
  const resend = page.getByText(
    /^(获取验证码|重新获取(?:\(\d+s\))?)$/,
    { exact: true },
  );
  const visible = await firstVisible(resend);
  if (visible.length !== 1) {
    throw new Error("Unexpected SMS control");
  }
  const label = clean(await visible[0].innerText(), 60);
  const waitSeconds = Number(label.match(/\((\d+)s\)/)?.[1] || 0);
  if (label === "获取验证码" || label === "重新获取") {
    await visible[0].click();
    await page.waitForTimeout(500);
    return { sent: true, waitSeconds: 0 };
  }
  return { sent: false, waitSeconds, force };
}

async function ensureLoggedIn(otp = "", resendSms = false) {
  await ensureBrowser();
  let navigated = false;
  if (!page.url().startsWith("https://www.erp321.com/")) {
    await gotoErp();
    navigated = true;
  }
  if (
    !navigated &&
    !erpApplicationVisible() &&
    !(await loginFormVisible()) &&
    !(await otpFormVisible())
  ) {
    await gotoErp();
  }
  await page.waitForTimeout(800);
  if (await loginFormVisible()) {
    await submitCredentials();
  }
  if (await otpFormVisible()) {
    if (!otp) {
      const sms = await sendSmsIfNeeded(resendSms);
      return {
        status: "needs_sms",
        message: sms.sent
          ? "ERP 已发送登录验证码。"
          : sms.waitSeconds
            ? `验证码已发送，${sms.waitSeconds} 秒后可重新发送。`
            : "验证码已发送，请检查登录手机号。",
      };
    }
    const input = page.locator('input[placeholder="输入验证码"]');
    await input.fill(otp);
    await clickExactText(page, "确 定", "OTP confirmation");
    await page.waitForTimeout(1600);
    if (await otpFormVisible()) {
      const errorText = clean(
        await page.locator("body").innerText().catch(() => ""),
        500,
      );
      if (/验证码.*(错误|失效|过期)|Fid field/i.test(errorText)) {
        const sms = await sendSmsIfNeeded(true).catch(() => ({
          sent: false,
          waitSeconds: 0,
        }));
        return {
          status: "needs_sms",
          message: sms.sent
            ? "验证码已失效，ERP 已重新发送验证码。"
            : sms.waitSeconds
              ? `验证码未通过，${sms.waitSeconds} 秒后可重新发送。`
              : "验证码未通过，请回复“重新发送验证码”后再试。",
        };
      }
      throw new Error("OTP was not accepted");
    }
  }
  const deadline = Date.now() + 30000;
  while (Date.now() < deadline) {
    if (erpApplicationVisible()) return { status: "ok" };
    if (await loginFormVisible()) {
      throw new Error("Login form remained visible");
    }
    if (await otpFormVisible()) return { status: "needs_sms" };
    await page.waitForTimeout(250);
  }
  throw new Error("ERP application did not become ready");
}

function frameByUrl(fragment) {
  return page.frames().find((frame) => frame.url().includes(fragment));
}

async function frameChainVisible(frame) {
  let current = frame;
  while (current && current.parentFrame()) {
    const element = await current.frameElement().catch(() => null);
    if (!element || !(await element.isVisible().catch(() => false))) {
      return false;
    }
    current = current.parentFrame();
  }
  return true;
}

async function visibleFrameByUrl(fragment) {
  const candidates = page
    .frames()
    .filter((frame) => frame.url().includes(fragment));
  for (const frame of candidates.reverse()) {
    if (await frameChainVisible(frame)) return frame;
  }
  return null;
}

async function dismissWelcomeDialogs() {
  const welcome = frameByUrl("/erp-web-group/home/");
  if (!welcome) return;
  for (const selector of [
    'button[aria-label="Close"]',
    ".ant-modal-close",
    ".anticon-close",
  ]) {
    const candidates = welcome.locator(selector);
    const visible = await firstVisible(candidates);
    if (visible.length === 1) {
      await visible[0].click({ force: true }).catch(() => {});
      await welcome.waitForTimeout(200);
    }
  }
}

async function readyOrderFrame() {
  const candidates = page
    .frames()
    .filter((frame) => frame.url().includes("/app/order/order/list.aspx"))
    .reverse();
  for (const frame of candidates) {
    if (!(await frameChainVisible(frame))) continue;
    if ((await visibleOrderInputs(frame)).length) return frame;
  }
  return null;
}

async function openOrderList() {
  let orderFrame =
    (await readyOrderFrame()) ||
    (await visibleFrameByUrl("/app/order/order/list.aspx"));
  if (orderFrame) {
    const tabs = await firstVisible(
      page.getByRole("tab", { name: "订单", exact: true }),
    );
    if (tabs.length === 1) await tabs[0].click().catch(() => {});
    return (await readyOrderFrame()) || orderFrame;
  }
  await gotoErp();
  await page.waitForTimeout(1200);
  await dismissWelcomeDialogs();
  const welcome = frameByUrl("/erp-web-group/home/");
  if (!welcome) throw new Error("Welcome frame not found");
  const candidates = [
    ...(await firstVisible(
      page.getByRole("tab", { name: "订单", exact: true }),
    )),
    ...(await firstVisible(welcome.getByText("订单", { exact: true }))),
  ];
  if (!candidates.length) throw new Error("Order shortcut not found");
  for (const candidate of candidates) {
    await candidate.evaluate((element) => element.click()).catch(() => {});
    const deadline = Date.now() + 12000;
    while (Date.now() < deadline) {
      orderFrame = await visibleFrameByUrl("/app/order/order/list.aspx");
      if (orderFrame) return orderFrame;
      await page.waitForTimeout(250);
    }
  }
  throw new Error("Order list did not open");
}

async function visibleOrderInputs(orderFrame) {
  const candidates = [];
  for (const frame of page.frames()) {
    if (!isDescendantFrame(frame, orderFrame)) continue;
    const input = frame.locator(
      "input#so_id, textarea#so_id, [contenteditable='true']#so_id",
    );
    if (
      (await input.count()) === 1 &&
      (await frameChainVisible(frame)) &&
      (await input.isVisible().catch(() => false))
    ) {
      candidates.push(input);
    }
  }
  return candidates;
}

async function waitForOrderInputs(orderFrame) {
  const readyDeadline = Date.now() + ACTION_TIMEOUT;
  while (Date.now() < readyDeadline) {
    const candidates = await visibleOrderInputs(orderFrame);
    if (candidates.length) return candidates;
    await orderFrame.waitForTimeout(250);
  }
  return [];
}

async function resetToOrderList() {
  if (!context || !page || page.isClosed()) return;
  const pages = context.pages();
  for (const candidate of pages) {
    if (candidate !== page) await candidate.close().catch(() => {});
  }
  if (await loginFormVisible() || (await otpFormVisible())) {
    throw new Error("Browser returned to an authentication page");
  }
  await gotoErp();
  await page.waitForTimeout(800);
  await dismissWelcomeDialogs();
  await openOrderList();
  const orderTabs = await firstVisible(
    page.getByRole("tab", { name: "订单", exact: true }),
  );
  if (orderTabs.length === 1) await orderTabs[0].click();
  if (context.pages().length !== 1) {
    throw new Error("Browser did not return to one main window");
  }
}

async function warmBrowserAtOrderList() {
  let lastError;
  for (let attempt = 0; attempt < 2; attempt += 1) {
    try {
      const auth = await ensureLoggedIn();
      if (auth.status !== "ok") return auth;
      const orderFrame = await openOrderList();
      const inputs = await waitForOrderInputs(orderFrame);
      if (!inputs.length) throw new Error("Order input did not become ready");
      if (context.pages().length !== 1) {
        throw new Error("Warm browser has more than one window");
      }
      return {
        status: "ok",
        browser_reset: "order_list",
        message: "ERP 浏览器已登录并停在订单页面。",
      };
    } catch (error) {
      lastError = error;
      await context?.close().catch(() => {});
      context = undefined;
      page = undefined;
      if (attempt === 0) {
        await new Promise((resolve) => setTimeout(resolve, 800));
      }
    }
  }
  throw lastError || new Error("ERP browser warmup failed");
}

async function recycleBrowserToOrderList() {
  await resetToOrderList();
  await context.close();
  context = undefined;
  page = undefined;
  const warmed = await warmBrowserAtOrderList();
  if (warmed.status !== "ok") {
    throw new Error("Browser authentication was not retained during recycle");
  }
}

function isDescendantFrame(frame, parent) {
  let current = frame;
  while (current) {
    if (current === parent) return true;
    current = current.parentFrame();
  }
  return false;
}

async function searchOrder(orderFrame, orderId) {
  const normalizedOrderId = clean(orderId, 40);
  const maxSearchAttempts = 3;
  for (
    let attempt = 1;
    attempt <= maxSearchAttempts;
    attempt += 1
  ) {
    const candidates = await waitForOrderInputs(orderFrame);
    if (!candidates.length) throw new Error("Online order input not found");
    for (const input of candidates.reverse()) {
      await input.fill(normalizedOrderId);
      await input.press("Enter");
      const deadline = Date.now() + (attempt === 1 ? 6000 : 10000);
      while (Date.now() < deadline) {
        const visible = await firstVisible(
          orderFrame.locator(`text="${normalizedOrderId}"`),
        );
        if (visible.length === 1) return visible[0];
        if (visible.length > 1) {
          throw new Error("More than one order row matched");
        }
        await orderFrame.waitForTimeout(250);
      }
    }
    if (attempt < maxSearchAttempts) {
      await orderFrame.waitForTimeout(1000);
    }
  }
  return null;
}

async function orderRowInfo(orderLocator, orderId) {
  return orderLocator.evaluate((element, expectedOrderId) => {
    let node = element;
    let best = element;
    while (node && node !== document.body) {
      const text = (node.innerText || "").replace(/\s+/g, " ").trim();
      const hasCheckbox = Boolean(
        node.querySelector?.('input[type="checkbox"]'),
      );
      if (
        text.includes(expectedOrderId) &&
        text.length >= expectedOrderId.length &&
        text.length <= 5000
      ) {
        best = node;
        if (hasCheckbox && /得物|1688一件代发/.test(text)) break;
      }
      node = node.parentElement;
    }
    const text = (best.innerText || "").replace(/\s+/g, " ").trim();
    const rowElement = element.closest("._jt_row") || best;
    const cellText = (dataId) => {
      const cell = rowElement.querySelector?.(`[data-id="${dataId}"]`);
      return (cell?.innerText || cell?.textContent || "")
        .replace(/\s+/g, " ")
        .trim();
    };
    const explicitOrderStatus = cellText("status");
    const orderStatus =
      explicitOrderStatus ||
      (text.match(/异常\s*1688\s*一件代发/) || [""])[0] ||
      (text.match(/已发货|已完成|已取消|交易关闭|已作废/) || [""])[0];
    const explicitPurchaseOrderNo = cellText("po_id");
    return {
      text,
      orderStatus,
      purchaseOrderNo:
        explicitPurchaseOrderNo.match(/^\d{5,20}$/)?.[0] || "",
      shopName:
        (text.match(/得物-[^\s]+|店铺-得物/) || [""])[0],
      hasDropshipMarker: text.includes("1688一件代发"),
      hasPurchaseTag: text.includes("采购订单"),
      blockedLifecycleStatus:
        (orderStatus.match(/已发货|已完成|已取消|交易关闭|已作废/) || [""])[0],
    };
  }, orderId);
}

function isErpOrderEditorFrame(frame) {
  try {
    const url = new URL(frame.url());
    return (
      (url.hostname === "erp321.com" ||
        url.hostname.endsWith(".erp321.com")) &&
      url.pathname.toLowerCase() ===
        "/app/order/order/ordereditornew.aspx"
    );
  } catch {
    return false;
  }
}

async function openOrderDetail(
  orderFrame,
  orderLocator,
  expectedOrderId = "",
) {
  const priorFrames = new Set(
    page
      .frames()
      .filter((frame) => isErpOrderEditorFrame(frame))
  );
  await orderLocator.click({ button: "right" });
  const menuItems = orderFrame.getByText("订单详情", { exact: true });
  const visible = await firstVisible(menuItems);
  if (visible.length !== 1) {
    throw new Error("Order detail menu is ambiguous");
  }
  await visible[0].click();
  const deadline = Date.now() + 20000;
  while (Date.now() < deadline) {
    const candidates = page
      .frames()
      .filter((frame) => isErpOrderEditorFrame(frame))
      .reverse();
    const visibleCandidates = [];
    for (const candidate of candidates) {
      if (await frameChainVisible(candidate).catch(() => false)) {
        visibleCandidates.push(candidate);
      }
    }
    const fresh = visibleCandidates.find(
      (candidate) => !priorFrames.has(candidate),
    );
    if (fresh) return fresh;
    if (expectedOrderId) {
      for (const candidate of visibleCandidates) {
        const body = clean(
          await candidate.locator("body").innerText().catch(() => ""),
          12000,
        );
        if (body.includes(expectedOrderId)) return candidate;
      }
    }
    if (visibleCandidates.length === 1) return visibleCandidates[0];
    await page.waitForTimeout(200);
  }
  throw new Error("Order detail did not open");
}

async function readOrderDetail(detailFrame) {
  const body = clean(await detailFrame.locator("body").innerText(), 15000);
  const purchaseMatch = body.match(/生成采购单号[：:]?\s*(\d{5,20})/);
  const value = async (selector) => {
    const item = detailFrame.locator(selector);
    return (await item.count()) === 1
      ? clean(await item.inputValue().catch(() => ""), 300)
      : "";
  };
  return {
    purchaseOrderNo: purchaseMatch?.[1] || "",
    receiverState: await value("#receiver_state"),
    receiverCity: await value("#receiver_city"),
    receiverDistrict: await value("#receiver_district"),
    receiverAddress: await value("#receiver_address"),
    receiverName: await value("#receiver_name"),
    logText: body,
  };
}

async function waitForOrderDetailPurchase(
  detailFrame,
  expectedPurchaseOrderNo = "",
  timeoutMs = 12000,
) {
  const expected = clean(expectedPurchaseOrderNo, 40);
  const deadline = Date.now() + timeoutMs;
  let detail = {};
  let nextScrollAt = 0;
  while (Date.now() < deadline) {
    if (Date.now() >= nextScrollAt) {
      await detailFrame
        .evaluate(() => {
          window.scrollTo(0, document.documentElement.scrollHeight);
          document.scrollingElement?.scrollTo(
            0,
            document.scrollingElement.scrollHeight,
          );
          for (const element of document.querySelectorAll("*")) {
            if (element.scrollHeight > element.clientHeight + 20) {
              element.scrollTop = element.scrollHeight;
            }
          }
          const logSection = [...document.querySelectorAll("*")].find(
            (element) =>
              /订单操作进程及日志|生成采购单号/.test(
                element.textContent || "",
              ),
          );
          logSection?.scrollIntoView({ block: "center" });
        })
        .catch(() => {});
      nextScrollAt = Date.now() + 1000;
    }
    detail = await readOrderDetail(detailFrame);
    const current = clean(detail.purchaseOrderNo, 40);
    if (!expected && current) return detail;
    if (expected && current === expected) return detail;
    if (expected) {
      const links = await firstVisible(
        detailFrame.getByText(expected, { exact: true }),
      );
      if (links.length === 1) {
        detail.purchaseOrderNo = expected;
        return detail;
      }
    }
    await detailFrame.waitForTimeout(250);
  }
  return detail;
}

async function closeOrderDetail(detailFrame) {
  await detailFrame.locator("body").press("Escape").catch(() => {});
  const deadline = Date.now() + 2500;
  while (Date.now() < deadline) {
    if (!(await frameChainVisible(detailFrame).catch(() => false))) return;
    await page.waitForTimeout(150);
  }
  await closeVisibleEpaasDialogs().catch(() => {});
}

async function inspectSingleOrder(orderFrame, order, report = () => {}) {
  const orderId = clean(order.order_id, 40);
  report("order.search.started", "正在输入线上订单号并搜索", "started");
  const orderLocator = await searchOrder(orderFrame, orderId);
  if (!orderLocator) {
    report("order.search.not_found", "线上订单号未匹配", "failed");
    return {
      order_id: orderId,
      state: "not_found",
      order_status: "未找到",
      message: "线上订单号未匹配",
    };
  }
  report("order.search.completed", "已定位订单行", "completed");
  const row = await orderRowInfo(orderLocator, orderId);
  report("order.status.read", "已读取订单状态", "completed");
  let detail = {};
  try {
    report("order.detail.open.started", "正在打开订单详情", "started");
    const detailFrame = await openOrderDetail(
      orderFrame,
      orderLocator,
      orderId,
    );
    report("order.detail.open.completed", "订单详情已打开", "completed");
    detail = await waitForOrderDetailPurchase(detailFrame, "", 1800);
    report("order.detail.read", "已读取订单详情和操作日志", "completed");
    await closeOrderDetail(detailFrame);
    report("order.detail.closed", "订单详情已关闭", "completed");
  } catch {
    detail = {};
    report("order.detail.read.skipped", "订单详情读取失败，继续核对订单行", "skipped");
  }
  const purchaseOrderNo =
    clean(detail.purchaseOrderNo, 40) || clean(row.purchaseOrderNo, 40);
  if (purchaseOrderNo || row.hasPurchaseTag) {
    if (purchaseOrderNo) {
      report(
        "order.preflight.resume_purchase",
        "检测到已有采购单，将从采购审核步骤继续",
        "completed",
        { purchase_order_no: purchaseOrderNo },
      );
      return {
        order_id: orderId,
        state: "resume_purchase",
        shop_name: row.shopName,
        order_status: "1688一件代发 / 已生成采购",
        purchase_order_no: purchaseOrderNo,
        current_address: clean(detail.receiverAddress, 120),
        message: "继续处理现有采购单",
      };
    }
    report(
      "order.preflight.duplicate_blocked",
      "检测到采购记录但无法确认采购单号，已阻止重复生成",
      "failed",
    );
    return {
      order_id: orderId,
      state: "already_processed",
      shop_name: row.shopName,
      order_status: row.hasDropshipMarker
        ? "1688一件代发 / 已生成采购"
        : "已生成采购",
      purchase_order_no: purchaseOrderNo,
      current_address: clean(detail.receiverAddress, 120),
      message: "已存在采购单或采购标记",
    };
  }
  if (!row.shopName.includes("得物")) {
    return {
      order_id: orderId,
      state: "blocked",
      shop_name: row.shopName,
      order_status: "非得物订单",
      message: "店铺不是得物渠道",
    };
  }
  if (row.blockedLifecycleStatus) {
    report(
      "order.preflight.lifecycle_blocked",
      "订单已进入不可发起采购的终态",
      "failed",
    );
    return {
      order_id: orderId,
      state: "blocked",
      shop_name: row.shopName,
      order_status: row.blockedLifecycleStatus,
      message: "订单已进入不可发起采购的终态",
    };
  }
  if (
    !row.hasDropshipMarker ||
    (row.orderStatus && !row.orderStatus.includes("异常"))
  ) {
    report(
      "order.preflight.status_blocked",
      "订单状态不符合异常1688一件代发",
      "failed",
    );
    return {
      order_id: orderId,
      state: "blocked",
      shop_name: row.shopName,
      order_status: row.orderStatus || "状态未识别",
      message: row.orderStatus
        ? `ERP状态不符合执行条件：${row.orderStatus}`
        : "未读取到订单状态",
    };
  }
  report(
    "order.preflight.ready",
    "订单状态符合异常1688一件代发",
    "completed",
  );
  return {
    order_id: orderId,
    state: "ready",
    shop_name: row.shopName,
    order_status: row.orderStatus || "1688一件代发",
    purchase_order_no: "",
    current_address: clean(detail.receiverAddress, 120),
  };
}

async function inspectBatch(payload) {
  writeProgress({
    phase: "inspect",
    step_code: "auth.check.started",
    step_state: "started",
    message: "正在检查 ERP 登录状态",
  });
  const auth = await ensureLoggedIn(
    clean(payload.otp, 12),
    Boolean(payload.resend_sms),
  );
  if (auth.status !== "ok") {
    writeProgress({
      phase: "inspect",
      step_code: "auth.check.waiting",
      step_state: "waiting",
      message: "ERP 登录等待短信验证码",
    });
    return auth;
  }
  writeProgress({
    phase: "inspect",
    step_code: "auth.check.completed",
    step_state: "completed",
    message: "ERP 登录状态正常",
  });
  writeProgress({
    phase: "inspect",
    step_code: "order.list.open.started",
    step_state: "started",
    message: "正在打开订单列表",
  });
  const orderFrame = await openOrderList();
  writeProgress({
    phase: "inspect",
    step_code: "order.list.open.completed",
    step_state: "completed",
    message: "订单列表已就绪",
  });
  const orders = [];
  const inputOrders = payload.orders || [];
  for (let index = 0; index < inputOrders.length; index += 1) {
    const order = inputOrders[index];
    const orderContext = {
      purchase_order_no: "",
      online_1688_order_no: "",
      external_state_may_have_changed: false,
      submission_may_have_started: false,
      last_step_code: "",
    };
    const report = (stepCode, message, stepState = "started", extra = {}) => {
      if (extra.purchase_order_no) {
        orderContext.purchase_order_no = clean(
          extra.purchase_order_no,
          60,
        );
      }
      if (extra.online_1688_order_no) {
        orderContext.online_1688_order_no = clean(
          extra.online_1688_order_no,
          80,
        );
      }
      writeProgress({
        phase: "inspect",
        completed: index,
        total: inputOrders.length,
        order_index: index + 1,
        order_total: inputOrders.length,
        current_order_id: clean(order.order_id, 40),
        step_code: stepCode,
        step_state: stepState,
        message,
        purchase_order_no: orderContext.purchase_order_no,
        online_1688_order_no: orderContext.online_1688_order_no,
        ...extra,
      });
    };
    report("order.preflight.started", "开始核对当前订单", "started");
    const result = await inspectSingleOrder(orderFrame, order, report);
    orders.push(result);
    writeProgress({
      phase: "inspect",
      completed: index + 1,
      total: inputOrders.length,
      order_index: index + 1,
      order_total: inputOrders.length,
      current_order_id: clean(order.order_id, 40),
      step_code: "order.preflight.completed",
      step_state:
        result.state === "ready" || result.state === "resume_purchase"
          ? "completed"
          : "skipped",
      message:
        result.state === "ready" || result.state === "resume_purchase"
          ? "当前订单预检通过"
          : "当前订单预检结束，执行阶段将跳过",
      purchase_order_no: clean(result.purchase_order_no, 60),
      online_1688_order_no: clean(result.online_1688_order_no, 80),
    });
  }
  return { status: "ok", orders };
}

async function fillAndSaveAddress(detailFrame, order, report = () => {}) {
  const paste = await waitForOneVisible(
    detailFrame.locator("#input_receiver_address"),
    "address paste control",
  );
  const save = await waitForOneVisible(
    detailFrame.locator("#save_btn"),
    "address save control",
  );
  const expectedRecipient = erpRecipientText(order.recipient);
  const composite = `${expectedRecipient} ${clean(
    order.phone,
    20,
  )} ${clean(order.address, 300)}`;
  report("address.paste.started", "正在粘贴收货资料", "started");
  await paste.fill(composite);
  report("address.paste.completed", "收货资料已粘贴", "completed");
  report("address.parse.started", "正在识别填充收货地址", "started");
  await clickExactText(detailFrame, "识别填充", "address parse");
  const recipientControl = await waitForOneVisible(
    detailFrame.locator("#receiver_name"),
    "recipient control",
  );
  const addressControl = await waitForOneVisible(
    detailFrame.locator("#receiver_address"),
    "address control",
  );
  const stateControl = await waitForOneVisible(
    detailFrame.locator("#receiver_state"),
    "state control",
  );
  const cityControl = await waitForOneVisible(
    detailFrame.locator("#receiver_city"),
    "city control",
  );
  const districtControl = await waitForOneVisible(
    detailFrame.locator("#receiver_district"),
    "district control",
  );
  let phoneControl = null;
  for (const selector of ["#receiver_mobile", "#receiver_phone"]) {
    const controls = await firstVisible(detailFrame.locator(selector));
    if (controls.length > 1) {
      throw new Error("Phone control is ambiguous");
    }
    if (controls.length === 1) {
      phoneControl = controls[0];
      break;
    }
  }
  const expectedPhoneDigits = normalizedPhoneDigits(clean(order.phone, 20));
  const expectedPrivacySuffix = privacyPhoneSuffix(order.phone);
  const deadline = Date.now() + 5000;
  let verificationIssues = [];
  let verifiedAddressState = null;
  do {
    const recipient = clean(await recipientControl.inputValue(), 30);
    const parsedPhone = phoneControl
      ? clean(await phoneControl.inputValue(), 30)
      : "";
    let address = clean(await addressControl.inputValue(), 300);
    const state = clean(await stateControl.inputValue(), 60);
    const city = clean(await cityControl.inputValue(), 60);
    const district = clean(await districtControl.inputValue(), 60);
    if (
      expectedPrivacySuffix &&
      !normalizedContactText(address).includes(expectedPrivacySuffix)
    ) {
      await addressControl.fill(`${withoutPrivacySuffix(address)}[${expectedPrivacySuffix}]`);
      address = clean(await addressControl.inputValue(), 300);
    }
    verificationIssues = [];
    verifiedAddressState = {
      recipient,
      phone: parsedPhone,
      address: `${state}${city}${district}${address}`,
      administrativeParts: [state, city, district],
    };
    if (
      normalizedRecipientText(recipient) !==
      normalizedRecipientText(expectedRecipient)
    ) {
      verificationIssues.push("recipient");
    }
    if (normalizedPhoneDigits(parsedPhone) !== expectedPhoneDigits) {
      verificationIssues.push("phone");
    }
    if (
      expectedPrivacySuffix &&
      !normalizedContactText(address).includes(expectedPrivacySuffix)
    ) {
      verificationIssues.push("privacy_suffix");
    }
    if (!address) verificationIssues.push("address");
    if (!state) verificationIssues.push("state");
    if (!city) verificationIssues.push("city");
    if (!district) verificationIssues.push("district");
    if (
      !addressTextMatches(
        order.address,
        `${state}${city}${district}${address}`,
        [state, city, district],
      )
    ) {
      verificationIssues.push("full_address");
    }
    if (!verificationIssues.length) break;
    await detailFrame.waitForTimeout(250);
  } while (Date.now() < deadline);
  if (
    verificationIssues.length === 1 &&
    verificationIssues[0] === "recipient"
  ) {
    report(
      "address.recipient.restore.started",
      "ERP识别调整了收件人，正在按原始资料恢复",
      "started",
    );
    const restoredRecipient = withoutPrivacySuffix(expectedRecipient);
    await recipientControl.fill(restoredRecipient);
    if (
      normalizedRecipientText(await recipientControl.inputValue()) ===
      normalizedRecipientText(restoredRecipient)
    ) {
      verificationIssues = [];
      if (verifiedAddressState) {
        verifiedAddressState.recipient = restoredRecipient;
      }
      report(
        "address.recipient.restore.completed",
        "收件人已按原始资料恢复并复核通过",
        "completed",
      );
    }
  }
  if (verificationIssues.length) {
    throw safeOrderFailure(
      `Address parse verification failed fields=${verificationIssues.join(",")}`,
    );
  }
  order.__verifiedDelivery = verifiedAddressState;
  report("address.parse.completed", "收货地址识别填充完成", "completed");
  report("address.verify.completed", "收件人、手机号和地区字段校验通过", "completed");
  report("address.save.started", "正在保存订单基本及收货地址信息", "started");
  await save.click();
  await detailFrame.waitForTimeout(800);
  report("address.save.submitted", "收货地址保存已提交，等待回读复核", "completed");
}

async function readOrderAddressForm(detailFrame) {
  const recipientControl = await waitForOneVisible(
    detailFrame.locator("#receiver_name"),
    "recipient control",
  );
  const addressControl = await waitForOneVisible(
    detailFrame.locator("#receiver_address"),
    "address control",
  );
  const stateControl = await waitForOneVisible(
    detailFrame.locator("#receiver_state"),
    "state control",
  );
  const cityControl = await waitForOneVisible(
    detailFrame.locator("#receiver_city"),
    "city control",
  );
  const districtControl = await waitForOneVisible(
    detailFrame.locator("#receiver_district"),
    "district control",
  );
  const phoneCandidates = [];
  for (const selector of ["#receiver_mobile", "#receiver_phone"]) {
    const controls = await firstVisible(detailFrame.locator(selector));
    if (controls.length > 1) throw new Error("Phone control is ambiguous");
    if (controls.length === 1) {
      phoneCandidates.push({
        selector,
        value: clean(await controls[0].inputValue(), 30),
      });
    }
  }
  const populatedPhones = phoneCandidates.filter((item) => item.value);
  const distinctPhones = new Set(
    populatedPhones.map((item) => normalizedPhoneDigits(item.value)),
  );
  if (distinctPhones.size > 1) {
    throw new Error("Visible phone controls contain conflicting values");
  }
  const selectedPhone = populatedPhones[0] || phoneCandidates[0] || null;
  return {
    recipient: clean(await recipientControl.inputValue(), 30),
    phone: selectedPhone ? selectedPhone.value : "",
    phoneControlsPresent: phoneCandidates.length,
    phoneControlsAllEmpty: phoneCandidates.every((item) => !item.value),
    phoneControlStates: phoneCandidates.map(
      (item) => `${item.selector}:${phoneValueDiagnostic(item.value)}`,
    ),
    address: clean(await addressControl.inputValue(), 300),
    state: clean(await stateControl.inputValue(), 60),
    city: clean(await cityControl.inputValue(), 60),
    district: clean(await districtControl.inputValue(), 60),
  };
}

function administrativePartMatchesAddress(address, part) {
  const source = normalizedContactText(address);
  const normalized = normalizedContactText(part);
  if (!source || !normalized) return false;
  const alias = normalized.replace(/(?:省|市|区|县)$/u, "");
  return source.includes(normalized) || (alias.length >= 2 && source.includes(alias));
}

function persistedPhoneIsPermissionHidden(order, actual) {
  const expectedPhone = normalizedPhoneDigits(order.phone);
  const verifiedPhone = normalizedPhoneDigits(order.__verifiedDelivery?.phone);
  return Boolean(
    expectedPhone
      && verifiedPhone === expectedPhone
      && !String(actual.phone || "").trim()
      && Number(actual.phoneControlsPresent || 0) > 0
      && actual.phoneControlsAllEmpty === true
  );
}

function orderAddressFormVerificationIssues(order, actual) {
  const expectedPhone = normalizedPhoneDigits(order.phone);
  const expectedPrivacySuffix = privacyPhoneSuffix(order.phone);
  const expectedRecipient = String(
    order.__verifiedDelivery?.recipient || erpRecipientText(order.recipient),
  ).trim().slice(0, 30);
  const issues = [];
  const recipientMatches = isMaskedRecipientValue(actual.recipient)
    ? maskedRecipientMatchesExpected(actual.recipient, expectedRecipient)
    : normalizedRecipientText(actual.recipient) ===
      normalizedRecipientText(expectedRecipient);
  if (!recipientMatches) {
    issues.push("recipient");
  }
  if (
    !isMaskedContactValue(actual.phone) &&
    normalizedPhoneDigits(actual.phone) !== expectedPhone
  ) {
    issues.push("phone");
  }
  if (
    expectedPrivacySuffix &&
    !isMaskedContactValue(actual.address) &&
    !normalizedContactText(actual.address).includes(expectedPrivacySuffix) &&
    !normalizedContactText(actual.recipient).includes(expectedPrivacySuffix)
  ) {
    issues.push("privacy_suffix");
  }
  for (const [name, value] of [
    ["state", actual.state],
    ["city", actual.city],
    ["district", actual.district],
  ]) {
    if (!value || !administrativePartMatchesAddress(order.address, value)) {
      issues.push(name);
    }
  }
  if (!actual.address) {
    issues.push("address");
  } else if (
    !isMaskedContactValue(actual.address) &&
    !addressTextMatches(
      order.address,
      `${actual.state}${actual.city}${actual.district}${actual.address}`,
      [actual.state, actual.city, actual.district],
    )
  ) {
    issues.push("full_address");
  }
  return issues;
}

async function verifyPersistedOrderAddress(orderFrame, order, report = () => {}) {
  report(
    "address.persisted.verify.started",
    "正在重新打开订单回读收货信息",
    "started",
  );
  const orderLocator = await searchOrder(orderFrame, order.order_id);
  if (!orderLocator) throw safeOrderFailure("Saved address verification failed");
  const detailFrame = await openOrderDetail(
    orderFrame,
    orderLocator,
    order.order_id,
  );
  const deadline = Date.now() + 5000;
  let persisted = null;
  let verificationIssues = [];
  do {
    persisted = await readOrderAddressForm(detailFrame);
    verificationIssues = orderAddressFormVerificationIssues(order, persisted);
    if (!verificationIssues.length) break;
    await detailFrame.waitForTimeout(250);
  } while (Date.now() < deadline);
  if (
    verificationIssues.includes("phone")
    && persistedPhoneIsPermissionHidden(order, persisted)
  ) {
    verificationIssues = verificationIssues.filter((issue) => issue !== "phone");
    report(
      "address.persisted.phone.hidden",
      "ERP重新打开后按权限隐藏手机号，已沿用保存前核验结果",
      "completed",
    );
  }
  if (verificationIssues.length) {
    const phoneDiagnostic = verificationIssues.includes("phone")
      ? ` expected=${phoneValueDiagnostic(order.phone)}`
        + ` actual=${phoneValueDiagnostic(persisted?.phone)}`
        + ` controls=${(persisted?.phoneControlStates || []).join(";") || "none"}`
      : "";
    throw safeOrderFailure(
      `Saved address verification failed fields=${verificationIssues.join(",")}`
        + phoneDiagnostic,
    );
  }
  const previous = order.__verifiedDelivery || {};
  order.__verifiedDelivery = {
    recipient: isMaskedRecipientValue(persisted.recipient)
      ? previous.recipient
      : persisted.recipient,
    phone: !persisted.phone || isMaskedContactValue(persisted.phone)
      ? previous.phone
      : persisted.phone,
    address: isMaskedContactValue(persisted.address)
      ? previous.address
      : `${persisted.state}${persisted.city}${persisted.district}${persisted.address}`,
    administrativeParts: [
      persisted.state,
      persisted.city,
      persisted.district,
    ],
  };
  report(
    "address.persisted.verify.completed",
    "ERP保存后的收货信息与上传资料一致",
    "completed",
  );
  await closeOrderDetail(detailFrame);
  report("address.save.completed", "收货地址保存并回读复核成功", "completed");
}

async function rowCheckbox(orderLocator) {
  const checkbox = orderLocator.locator(
    "xpath=ancestor::*[.//input[@type='checkbox']][1]//input[@type='checkbox'][1]",
  );
  if ((await checkbox.count()) !== 1) {
    throw new Error("Order row checkbox is ambiguous");
  }
  return checkbox;
}

async function generatePurchaseOrder(
  orderFrame,
  orderLocator,
  report = () => {},
) {
  report("purchase.order.select.started", "正在勾选订单", "started");
  const checkbox = await rowCheckbox(orderLocator);
  if (!(await checkbox.isChecked())) await checkbox.check();
  report("purchase.order.select.completed", "订单已勾选", "completed");
  await dismissBlockingTips(orderFrame);
  const additional = orderFrame.locator("#__AppendTool_Btn");
  const visibleAdditional = await oneVisible(additional, "additional menu");
  report("purchase.additional.open.started", "正在打开附加菜单", "started");
  await visibleAdditional.click();
  report("purchase.additional.open.completed", "附加菜单已打开", "completed");
  await dismissBlockingTips(orderFrame);
  report(
    "purchase.generate.menu.started",
    "正在选择按订单生成采购单",
    "started",
  );
  await clickExactText(orderFrame, "按订单生成采购单", "generate purchase");
  report(
    "purchase.preview.open.started",
    "正在打开采购单预览",
    "started",
  );
  const previewFrame = await waitForPurchasePreviewFrame();
  report(
    "purchase.preview.open.completed",
    "采购单预览已打开",
    "completed",
  );
  report(
    "purchase.plaintext.enable.started",
    "正在开启采购单明文",
    "started",
  );
  await clickExactText(previewFrame, "明文", "plaintext toggle");
  report(
    "purchase.plaintext.enable.completed",
    "采购单明文已开启",
    "completed",
  );
  report(
    "purchase.generate.submit.started",
    "正在提交生成采购单",
    "started",
  );
  await clickExactText(
    previewFrame,
    "生成采购单",
    "generate purchase confirmation",
  );
  const success = await waitForVisibleTextAcrossFrames(
    /订单生成采购单成功|生成采购单成功/,
    "purchase success",
  );
  report(
    "purchase.generate.success",
    "系统提示采购单生成成功",
    "completed",
  );
  const confirmButtons = success.frame.getByText(/^(确定|确认)$/);
  const visible = await firstVisible(confirmButtons);
  if (visible.length === 1) await visible[0].click();
  await closeVisibleEpaasDialogs();
  report(
    "purchase.generate.dialog.closed",
    "采购单成功提示已确认并关闭",
    "completed",
  );
}

async function debugAdditionalControls(payload) {
  const auth = await ensureLoggedIn();
  if (auth.status !== "ok") return auth;
  const orderFrame = await openOrderList();
  const orderId = clean(payload.order_id, 40);
  const orderLocator = await searchOrder(orderFrame, orderId);
  const checkbox = await rowCheckbox(orderLocator);
  if (!(await checkbox.isChecked())) await checkbox.check();
  const candidates = orderFrame.getByText("附加", { exact: true });
  const diagnostics = [];
  for (const item of await firstVisible(candidates)) {
    diagnostics.push(
      await item.evaluate((element) => {
        const ancestors = [];
        let node = element;
        for (let depth = 0; node && depth < 5; depth += 1) {
          ancestors.push({
            tag: node.tagName,
            id: node.id || "",
            className:
              typeof node.className === "string" ? node.className : "",
            role: node.getAttribute("role") || "",
            title: node.getAttribute("title") || "",
            text: (node.innerText || node.textContent || "")
              .replace(/\s+/g, " ")
              .trim()
              .slice(0, 180),
          });
          node = node.parentElement;
        }
        return { ancestors };
      }),
    );
  }
  const additional = await oneVisible(
    orderFrame.locator("#__AppendTool_Btn"),
    "additional menu",
  );
  await dismissBlockingTips(orderFrame);
  await additional.click();
  await orderFrame.waitForTimeout(300);
  await dismissBlockingTips(orderFrame);
  const purchaseCandidates = orderFrame.getByText("按订单生成采购单", {
    exact: true,
  });
  const purchaseDiagnostics = [];
  for (const item of await firstVisible(purchaseCandidates)) {
    purchaseDiagnostics.push(
      await item.evaluate((element) => {
        const ancestors = [];
        let node = element;
        for (let depth = 0; node && depth < 5; depth += 1) {
          ancestors.push({
            tag: node.tagName,
            id: node.id || "",
            className:
              typeof node.className === "string" ? node.className : "",
            role: node.getAttribute("role") || "",
            title: node.getAttribute("title") || "",
            text: (node.innerText || node.textContent || "")
              .replace(/\s+/g, " ")
              .trim()
              .slice(0, 180),
          });
          node = node.parentElement;
        }
        return { ancestors };
      }),
    );
  }
  const purchaseAction = await oneVisible(
    purchaseCandidates,
    "generate purchase",
  );
  await purchaseAction.click();
  await orderFrame.waitForTimeout(3000);
  const previewDiagnostics = {};
  for (const text of ["明文", "生成采购单"]) {
    const items = orderFrame.getByText(text, { exact: true });
    const details = [];
    for (const item of await firstVisible(items)) {
      details.push(
        await item.evaluate((element) => {
          const ancestors = [];
          let node = element;
          for (let depth = 0; node && depth < 5; depth += 1) {
            ancestors.push({
              tag: node.tagName,
              id: node.id || "",
              className:
                typeof node.className === "string" ? node.className : "",
              role: node.getAttribute("role") || "",
              title: node.getAttribute("title") || "",
              text: (node.innerText || node.textContent || "")
                .replace(/\s+/g, " ")
                .trim()
                .slice(0, 180),
            });
            node = node.parentElement;
          }
          return { ancestors };
        }),
      );
    }
    previewDiagnostics[text] = details;
  }
  const previewFrames = [];
  const frameSnapshots = [];
  for (const candidateFrame of page.frames()) {
    const frameResult = {
      url: candidateFrame.url(),
      plaintext_count: 0,
      generate_count: 0,
    };
    frameResult.plaintext_count = (
      await firstVisible(
        candidateFrame.getByText("明文", { exact: true }),
      )
    ).length;
    frameResult.generate_count = (
      await firstVisible(
        candidateFrame.getByText("生成采购单", { exact: true }),
      )
    ).length;
    if (frameResult.plaintext_count || frameResult.generate_count) {
      previewFrames.push(frameResult);
    }
    frameSnapshots.push({
      url: candidateFrame.url(),
      text: clean(
        await candidateFrame
          .locator("body")
          .innerText()
          .catch(() => ""),
        5000,
      ),
    });
  }
  const screenshotPath = `/opt/dalongxia-chat-api/data/${BROWSER_CODE}-purchase-preview.png`;
  await page
    .screenshot({ path: screenshotPath, fullPage: true })
    .catch(() => {});
  return {
    status: "ok",
    order_id: orderId,
    visible_count: diagnostics.length,
    diagnostics,
    purchase_visible_count: purchaseDiagnostics.length,
    purchase_diagnostics: purchaseDiagnostics,
    preview_diagnostics: previewDiagnostics,
    preview_frames: previewFrames,
    frame_snapshots: frameSnapshots,
    screenshot_path: screenshotPath,
  };
}

async function openPurchaseFromDetail(detailFrame, purchaseOrderNo) {
  const link = detailFrame.getByText(purchaseOrderNo, { exact: true });
  const item = await oneVisible(link, "purchase log link");
  const linkDiagnostics = await item.evaluate((element) => ({
    href: element.closest("a")?.href || element.getAttribute("href") || "",
    target:
      element.closest("a")?.target || element.getAttribute("target") || "",
    onclick:
      element.closest("[onclick]")?.getAttribute("onclick") ||
      element.getAttribute("onclick") ||
      "",
  }));
  await item.click();
  const deadline = Date.now() + 8000;
  while (Date.now() < deadline) {
    const frame = await visibleFrameByUrl(
      "/app/scm/purchase/purchasemode.aspx",
    );
    if (frame) return frame;
    await page.waitForTimeout(250);
  }

  logInternalError(
    new Error(
      "Purchase link did not open the expected frame; falling back to the " +
        `validated purchase page ${JSON.stringify(linkDiagnostics)}`,
    ),
    `purchase-navigation-${purchaseOrderNo}`,
  );
  await page.goto(
    "https://www.erp321.com/app/scm/purchase/purchasemode.aspx?_c=jst-epaas&epaas=true",
    { waitUntil: "domcontentloaded", timeout: 45000 },
  );
  await page.waitForSelector("#_jt", {
    state: "visible",
    timeout: 30000,
  });
  const purchaseFrame = page.mainFrame();
  const purchaseNumberInput = purchaseFrame.locator("#po_id");
  await purchaseNumberInput.fill(purchaseOrderNo);
  const searchButton = await oneVisible(
    purchaseFrame.locator("a.search").filter({ hasText: "搜索" }),
    "purchase search button",
  );
  await searchButton.click();
  await waitForOneVisible(
    purchaseFrame.getByText(purchaseOrderNo, { exact: true }),
    "purchase row after direct navigation",
  );
  return purchaseFrame;
}

async function purchaseRowLocator(purchaseFrame, purchaseOrderNo) {
  const purchase = await waitForOneVisible(
    purchaseFrame.getByText(purchaseOrderNo, { exact: true }),
    "purchase row",
  );
  const directRow = purchase.locator(
    "xpath=ancestor-or-self::*[contains(concat(' ', normalize-space(@class), ' '), ' _jt_row ')][1]",
  );
  if ((await directRow.count()) === 1) return directRow;

  const rows = purchaseFrame.locator("._jt_row");
  const matchingRows = rows.filter({ hasText: purchaseOrderNo });
  const visibleMatchingRows = await firstVisible(matchingRows);
  if (visibleMatchingRows.length !== 1) {
    throw new Error(
      `purchase row container count is not one direct=${await directRow.count()}`
        + ` fallback=${visibleMatchingRows.length} visible=${await rows.count()}`,
    );
  }
  return visibleMatchingRows[0];
}

async function readPurchaseRow(purchaseFrame, purchaseOrderNo) {
  const purchase = await purchaseRowLocator(
    purchaseFrame,
    purchaseOrderNo,
  );
  return clean(
    await purchase.evaluate((row) => {
      return (row.innerText || row.textContent || "")
        .replace(/\s+/g, " ")
        .trim();
    }),
    5000,
  );
}

function verified1688Order(rowBody) {
  const onlineOrderNo =
    String(rowBody || "").match(/\b\d{16,30}\b/)?.[0] || "";
  const stateVerified =
    /等待买家付款|等待卖家发货|等待供应商发货|下单成功/.test(
      String(rowBody || ""),
    );
  return {
    onlineOrderNo,
    verified: Boolean(onlineOrderNo && stateVerified),
  };
}

async function inspectPurchaseForOrder(payload) {
  const auth = await ensureLoggedIn();
  if (auth.status !== "ok") return auth;
  const orderFrame = await openOrderList();
  const orderId = clean(payload.order_id, 40);
  const orderLocator = await searchOrder(orderFrame, orderId);
  if (!orderLocator) throw new Error("Inspection order was not found");
  const detailFrame = await openOrderDetail(
    orderFrame,
    orderLocator,
    orderId,
  );
  const detail = await waitForOrderDetailPurchase(
    detailFrame,
    "",
    12000,
  );
  const purchaseOrderNo = clean(detail.purchaseOrderNo, 40);
  if (!purchaseOrderNo) {
    return { status: "ok", order_id: orderId, purchase_order_no: "" };
  }
  if (payload.detail_only === true) {
    return {
      status: "ok",
      order_id: orderId,
      purchase_order_no: purchaseOrderNo,
      detail_log_text: clean(detail.logText, 15000),
    };
  }
  const purchaseFrame = await openPurchaseFromDetail(
    detailFrame,
    purchaseOrderNo,
  );
  const row = await readPurchaseRow(purchaseFrame, purchaseOrderNo);
  return {
    status: "ok",
    order_id: orderId,
    purchase_order_no: purchaseOrderNo,
    online_1688_order_no: row.match(/\b\d{16,30}\b/)?.[0] || "",
    row,
  };
}

async function describeAuditTrigger(purchaseFrame) {
  const exactMatches = await firstVisible(
    purchaseFrame.getByText("审核生效", { exact: true }),
  );
  const diagnostics = [];
  for (const item of exactMatches) {
    diagnostics.push(
      await item.evaluate((element) => {
        const describe = (node) => {
          const attribute = (name) =>
            typeof node.getAttribute === "function"
              ? node.getAttribute(name) || ""
              : "";
          const rect =
            typeof node.getBoundingClientRect === "function"
              ? node.getBoundingClientRect()
              : { x: 0, y: 0, width: 0, height: 0 };
          const jquery = window.jQuery || window.$;
          const jqueryEvents =
            jquery && typeof jquery._data === "function"
              ? Object.entries(jquery._data(node, "events") || {}).flatMap(
                  ([type, handlers]) =>
                    Array.from(handlers || []).slice(0, 20).map((handler) => ({
                      type,
                      selector: handler.selector || "",
                      namespace: handler.namespace || "",
                      source: String(handler.handler || handler)
                        .replace(/\s+/g, " ")
                        .slice(0, 500),
                    })),
                )
              : [];
          return {
            tag: node.tagName || node.nodeName || "",
            id: node.id || "",
            className:
              typeof node.className === "string"
                ? node.className.slice(0, 240)
                : "",
            role: attribute("role"),
            title: attribute("title"),
            onclick: attribute("onclick").slice(0, 500),
            hasOnclickProperty: typeof node.onclick === "function",
            onclickProperty: String(node.onclick || "")
              .replace(/\s+/g, " ")
              .slice(0, 500),
            jqueryEvents,
            text: (node.innerText || node.textContent || "")
              .replace(/\s+/g, " ")
              .trim()
              .slice(0, 240),
            rect: {
              x: Math.round(rect.x),
              y: Math.round(rect.y),
              width: Math.round(rect.width),
              height: Math.round(rect.height),
            },
          };
        };
        const ancestors = [];
        let node = element;
        for (let depth = 0; node && depth < 8; depth += 1) {
          ancestors.push(describe(node));
          node = node.parentElement;
        }
        const descendants = Array.from(
          element.parentElement?.querySelectorAll(
            "button,a,[role='button'],[onclick]",
          ) || [],
        )
          .slice(0, 30)
          .map(describe);
        const delegatedEvents = [document, document.body]
          .flatMap((node) => describe(node).jqueryEvents)
          .filter((event) =>
            /ding|OPTM_Tool_Confirm|optimize-filter/i.test(
              `${event.selector} ${event.source}`,
            ),
          )
          .slice(0, 50);
        const checkedRows = Array.from(
          document.querySelectorAll(
            "._jt_row input[type='checkbox']:checked",
          ),
        ).map((checkbox) => {
          const row = checkbox.closest("._jt_row");
          return {
            rowText: (row?.innerText || row?.textContent || "")
              .replace(/\s+/g, " ")
              .trim()
              .slice(0, 240),
            jqueryEvents: describe(checkbox).jqueryEvents,
          };
        });
        const tableApi = window.jTable || null;
        const tableApiKeys = tableApi
          ? Object.keys(tableApi)
              .filter((key) => /select|check|row/i.test(key))
              .slice(0, 100)
          : [];
        const visibleOverlays = Array.from(
          document.body.querySelectorAll("*"),
        )
          .filter((node) => {
            const style = window.getComputedStyle(node);
            const rect = node.getBoundingClientRect();
            const text = (node.innerText || node.textContent || "").trim();
            return (
              rect.width > 0 &&
              rect.height > 0 &&
              style.display !== "none" &&
              style.visibility !== "hidden" &&
              ["fixed", "absolute"].includes(style.position) &&
              Number.parseInt(style.zIndex || "0", 10) >= 100 &&
              /审核|采购|选择|失败|错误|权限|确认|预警/.test(text)
            );
          })
          .slice(0, 30)
          .map((node) => ({
            tag: node.tagName,
            id: node.id || "",
            className:
              typeof node.className === "string"
                ? node.className.slice(0, 180)
                : "",
            text: (node.innerText || node.textContent || "")
              .replace(/\s+/g, " ")
              .trim()
              .slice(0, 500),
          }));
        const runtimeSources = {};
        for (const name of [
          "GetCurrentJTableRow",
          "GetPoIdArray",
          "ConfirmCfm",
        ]) {
          runtimeSources[name] = String(window[name] || "")
            .replace(/\s+/g, " ")
            .slice(0, 8000);
        }
        return {
          ancestors,
          descendants,
          delegatedEvents,
          confirmV2Source: String(window.ConfirmV2 || "")
            .replace(/\s+/g, " ")
            .slice(0, 8000),
          tableApiKeys,
          checkedRows,
          visibleOverlays,
          runtimeSources,
          parentHtml: (element.parentElement?.outerHTML || "").slice(0, 3000),
        };
      }),
    );
  }
  return diagnostics;
}

async function inspectAuditForOrder(payload) {
  const auth = await ensureLoggedIn();
  if (auth.status !== "ok") return auth;
  const orderFrame = await openOrderList();
  const orderId = clean(payload.order_id, 40);
  const orderLocator = await searchOrder(orderFrame, orderId);
  if (!orderLocator) throw new Error("Inspection order was not found");
  const detailFrame = await openOrderDetail(
    orderFrame,
    orderLocator,
    orderId,
  );
  const detail = await waitForOrderDetailPurchase(detailFrame, "", 12000);
  const purchaseOrderNo = clean(detail.purchaseOrderNo, 40);
  if (!purchaseOrderNo) {
    return { status: "ok", order_id: orderId, purchase_order_no: "" };
  }
  const purchaseFrame = await openPurchaseFromDetail(
    detailFrame,
    purchaseOrderNo,
  );
  const row = await readPurchaseRow(purchaseFrame, purchaseOrderNo);
  return {
    status: "ok",
    order_id: orderId,
    purchase_order_no: purchaseOrderNo,
    audit_completed: purchaseAuditCompleted(row),
    online_1688_order_no: row.match(/\b\d{16,30}\b/)?.[0] || "",
    audit_diagnostics: await describeAuditTrigger(purchaseFrame),
  };
}

async function inspectAuditForPurchase(payload) {
  const auth = await ensureLoggedIn();
  if (auth.status !== "ok") return auth;
  const purchaseOrderNo = clean(payload.purchase_order_no, 40);
  if (!purchaseOrderNo) {
    throw new Error("Purchase number is required for inspection");
  }
  await page.goto(
    "https://www.erp321.com/app/scm/purchase/purchasemode.aspx?_c=jst-epaas&epaas=true",
    { waitUntil: "domcontentloaded", timeout: 45000 },
  );
  await page.waitForSelector("#_jt", {
    state: "visible",
    timeout: 30000,
  });
  const purchaseFrame = page.mainFrame();
  const purchase = await waitForOneVisible(
    purchaseFrame.getByText(purchaseOrderNo, { exact: true }),
    "purchase row",
  );
  const row = await readPurchaseRow(purchaseFrame, purchaseOrderNo);
  const checkbox = purchase.locator(
    "xpath=ancestor::*[.//input[@type='checkbox']][1]//input[@type='checkbox'][1]",
  );
  if ((await checkbox.count()) === 1) {
    const rowCheckboxes = purchaseFrame.locator(
      "._jt_row input[type='checkbox']",
    );
    const count = await rowCheckboxes.count();
    for (let index = 0; index < count; index += 1) {
      const item = rowCheckboxes.nth(index);
      if (
        (await item.isVisible().catch(() => false)) &&
        (await item.isChecked().catch(() => false))
      ) {
        await item.uncheck({ force: true });
      }
    }
    await checkbox.check({ force: true });
  }
  const selectionState = await purchaseFrame.evaluate(() => {
    const current =
      typeof window.GetCurrentJTableRow === "function"
        ? window.GetCurrentJTableRow("待审核") || []
        : [];
    const checked =
      window.jTable && typeof window.jTable.GetCheckedRows === "function"
        ? window.jTable.GetCheckedRows() || []
        : [];
    const summarize = (rows) =>
      Array.from(rows || []).slice(0, 20).map((item) => {
        const data = item?.Data || item || {};
        return {
          purchaseOrderNo: String(
            data.po_id || data.purchase_order_no || "",
          ).slice(0, 60),
          status: String(data.status || data.po_status || "").slice(0, 80),
        };
      });
    return {
      domCheckedCount: document.querySelectorAll(
        "._jt_row input[type='checkbox']:checked",
      ).length,
      checkedRows: summarize(checked),
      currentRows: summarize(current),
    };
  });
  return {
    status: "ok",
    purchase_order_no: purchaseOrderNo,
    audit_completed: purchaseAuditCompleted(row),
    online_1688_order_no: row.match(/\b\d{16,30}\b/)?.[0] || "",
    selection_state: selectionState,
    audit_diagnostics: await describeAuditTrigger(purchaseFrame),
  };
}

async function inspect1688Navigation(payload) {
  const auth = await ensureLoggedIn();
  if (auth.status !== "ok") return auth;
  const orderFrame = await openOrderList();
  const orderId = clean(payload.order_id, 40);
  const orderLocator = await searchOrder(orderFrame, orderId);
  if (!orderLocator) throw new Error("Inspection order was not found");
  const detailFrame = await openOrderDetail(
    orderFrame,
    orderLocator,
    orderId,
  );
  const detail = await waitForOrderDetailPurchase(detailFrame, "", 12000);
  const purchaseOrderNo = clean(detail.purchaseOrderNo, 40);
  if (!purchaseOrderNo) {
    return { status: "ok", order_id: orderId, purchase_order_no: "" };
  }
  const purchaseFrame = await openPurchaseFromDetail(
    detailFrame,
    purchaseOrderNo,
  );
  const rowBody = await readPurchaseRow(purchaseFrame, purchaseOrderNo);
  await clearPurchaseResultOverlays(purchaseFrame);
  const trigger = purchaseFrame.locator("#OPTM_Purhcase_Order_1688");
  if ((await trigger.count()) !== 1) {
    throw new Error("1688 toolbar entry is ambiguous");
  }
  await trigger.click();
  await clickExactText(
    purchaseFrame,
    "1688一键下单",
    "1688 one-click order",
  );
  const dropshipMatch = await waitForVisibleLocatorAcrossFrames(
    "#purchaseAddress",
    "1688 dropship option",
  );
  const accountState = await waitFor1688AccountReady(dropshipMatch.frame);
  let priceContrast = null;
  if (payload.check_price_contrast === true) {
    priceContrast = await dropshipMatch.frame.evaluate(
      () =>
        new Promise((resolve) => {
          if (typeof window._AsyncCallPage !== "function") {
            resolve({ error: "async_call_unavailable" });
            return;
          }
          const memberId = window.jQuery?.("#shopInfos").val() || "";
          let settled = false;
          const finish = (value) => {
            if (settled) return;
            settled = true;
            resolve(value);
          };
          const timer = setTimeout(
            () => finish({ error: "price_contrast_timeout" }),
            20000,
          );
          window._AsyncCallPage(
            "PriceContrast",
            (value) => {
              clearTimeout(timer);
              finish({ value });
            },
            true,
            memberId,
          );
        }),
    );
  }
  if (payload.open_confirmation === true) {
    const dropshipVisible = dropshipMatch.item;
    if (!(await dropshipVisible.isChecked())) {
      await dropshipVisible.check();
    }
    await dropshipMatch.frame.locator("#save_btn").click();
    await dropshipMatch.frame.waitForTimeout(1200);
  }
  const controls = await dropshipMatch.frame.evaluate(() => {
    const visible = (element) => {
      const rect = element.getBoundingClientRect();
      const style = window.getComputedStyle(element);
      return (
        rect.width > 0 &&
        rect.height > 0 &&
        style.display !== "none" &&
        style.visibility !== "hidden"
      );
    };
    const eventSummary = (element) => {
      const events =
        window.jQuery && typeof window.jQuery._data === "function"
          ? window.jQuery._data(element, "events") || {}
          : {};
      return Object.entries(events).flatMap(([type, handlers]) =>
        Array.from(handlers || []).map((handler) => ({
          type,
          selector: String(handler?.selector || "").slice(0, 120),
          source: String(handler?.handler || "").slice(0, 1000),
        })),
      );
    };
    const summarize = (element) => ({
      tag: element.tagName,
      id: element.id || "",
      className: String(element.className || "").slice(0, 200),
      text: String(element.innerText || element.textContent || "")
        .replace(/\s+/g, " ")
        .trim()
        .slice(0, 200),
      disabled: Boolean(element.disabled),
      onclick: String(element.getAttribute("onclick") || "").slice(0, 500),
      events: eventSummary(element),
      html: String(element.outerHTML || "").slice(0, 1200),
    });
    const saveControls = Array.from(
      document.querySelectorAll("button,a,input,span,div"),
    )
      .filter(
        (element) =>
          visible(element) &&
          String(element.innerText || element.value || element.textContent || "")
            .replace(/\s+/g, "")
            .trim() === "保存",
      )
      .slice(0, 20)
      .map((element) => ({
        element: summarize(element),
        ancestors: Array.from(
          (function* ancestors(start) {
            let current = start.parentElement;
            while (current && current !== document.body) {
              yield current;
              current = current.parentElement;
            }
          })(element),
        )
          .slice(0, 5)
          .map(summarize),
      }));
    const formControls = Array.from(
      document.querySelectorAll("input,select,textarea"),
    )
      .filter(visible)
      .slice(0, 80)
      .map((element) => ({
        tag: element.tagName,
        type: element.type || "",
        id: element.id || "",
        name: element.name || "",
        checked: Boolean(element.checked),
        disabled: Boolean(element.disabled),
        selectedIndex:
          typeof element.selectedIndex === "number"
            ? element.selectedIndex
            : -1,
      }));
    const runtimeSources = {};
    for (const name of [
      "CfmPurchaseTo1688",
      "SendTo1688",
      "PurchaseTo1688",
      "handlePurchaseResponse",
      "PlaceOrder",
      "Save",
    ]) {
      if (typeof window[name] === "function") {
        runtimeSources[name] = String(window[name]).slice(0, 5000);
      }
    }
    const relatedGlobals = Object.keys(window)
      .filter((name) => /1688|purchase.*order/i.test(name))
      .filter((name) => typeof window[name] === "function")
      .slice(0, 80);
    return {
      saveControls,
      formControls,
      runtimeSources,
      relatedGlobals,
      confirmSource: String(window.jQuery?.cfm || "")
        .replace(/\s+/g, " ")
        .slice(0, 5000),
      messageSource: String(window.jQuery?.msg || "")
        .replace(/\s+/g, " ")
        .slice(0, 5000),
      defaultPurchaseAddress:
        typeof window.defaultPurchaseAddress === "boolean"
          ? window.defaultPurchaseAddress
          : null,
      bodyText: String(document.body?.innerText || "")
        .replace(/\s+/g, " ")
        .trim()
        .slice(0, 1500),
    };
  });
  const visibleConfirmationLayers = [];
  for (const candidate of page.frames()) {
    if (!(await frameChainVisible(candidate).catch(() => false))) continue;
    const details = await candidate.evaluate(() => {
      const visible = (element) => {
        const rect = element.getBoundingClientRect();
        const style = window.getComputedStyle(element);
        return (
          rect.width > 0 &&
          rect.height > 0 &&
          style.display !== "none" &&
          style.visibility !== "hidden"
        );
      };
      const candidates = Array.from(
        document.querySelectorAll(
          "button,a,input,span,div,[id*='confirm'],[id*='cfm'],[class*='dialog']",
        ),
      )
        .filter(visible)
        .filter((element) => {
          const text = String(
            element.innerText || element.value || element.textContent || "",
          )
            .replace(/\s+/g, " ")
            .trim();
          const marker = `${element.id || ""} ${element.className || ""}`;
          return (
            /确认|确定|取消|继续|一键代发|一键下单/.test(text) ||
            /confirm|cfm|dialog/i.test(marker)
          );
        })
        .slice(0, 80)
        .map((element) => ({
          tag: element.tagName,
          id: element.id || "",
          className: String(element.className || "").slice(0, 200),
          text: String(
            element.innerText || element.value || element.textContent || "",
          )
            .replace(/\s+/g, " ")
            .trim()
            .slice(0, 300),
          onclick: String(element.getAttribute("onclick") || "").slice(0, 500),
          html: String(element.outerHTML || "").slice(0, 1200),
        }));
      return {
        bodyText: String(document.body?.innerText || "")
          .replace(/\s+/g, " ")
          .trim()
          .slice(0, 1200),
        candidates,
      };
    });
    visibleConfirmationLayers.push({
      url: candidate.url(),
      ...details,
    });
  }
  const screenshotPath =
    `/opt/dalongxia-chat-api/data/` +
    `${clean(BROWSER_CODE, 40)}-1688-navigation.png`;
  await page.screenshot({ path: screenshotPath, fullPage: true });
  return {
    status: "ok",
    order_id: orderId,
    purchase_order_no: purchaseOrderNo,
    audit_completed: purchaseAuditCompleted(rowBody),
    online_1688_order_no: rowBody.match(/\b\d{16,30}\b/)?.[0] || "",
    account_state: accountState,
    price_contrast: priceContrast,
    controls,
    visible_confirmation_layers: visibleConfirmationLayers,
    screenshot_path: screenshotPath,
  };
}

async function inspectOrderRow(payload) {
  const auth = await ensureLoggedIn();
  if (auth.status !== "ok") return auth;
  const orderFrame = await openOrderList();
  const orderId = clean(payload.order_id, 40);
  const orderLocator = await searchOrder(orderFrame, orderId);
  if (!orderLocator) {
    return { status: "ok", order_id: orderId, found: false };
  }
  const row = await orderRowInfo(orderLocator, orderId);
  const cells = await orderLocator.evaluate((element) => {
    const rowElement = element.closest("._jt_row");
    if (!rowElement) return [];
    return Array.from(rowElement.querySelectorAll("._jt_cell")).map((cell) => ({
      data_id: cell.getAttribute("data-id") || "",
      cell_index: cell.getAttribute("cellindex") || "",
      text: (cell.innerText || cell.textContent || "")
        .replace(/\s+/g, " ")
        .trim()
        .slice(0, 500),
    }));
  });
  return {
    status: "ok",
    order_id: orderId,
    found: true,
    row,
    cells,
  };
}

function purchaseAuditCompleted(rowBody) {
  return /已确认|已审核|审核通过/.test(String(rowBody || ""));
}

async function findAuditConfirmationControl() {
  const matches = [];
  const controlSelector = [
    "button",
    "a",
    "[role='button']",
    "input[type='button']",
    "input[type='submit']",
    ".btn",
    ".x-btn",
  ].join(",");
  for (const candidate of page.frames()) {
    if (!(await frameChainVisible(candidate).catch(() => false))) continue;
    const body = clean(
      await candidate.locator("body").innerText().catch(() => ""),
      1500,
    );
    const isAuditDialog =
      candidate.url().includes("/epaas-dialog-frame.html") &&
      /审核|生效/.test(body);
    const frameMatches = [];
    const controls = candidate.locator(controlSelector);
    const count = await controls.count().catch(() => 0);
    for (let index = 0; index < count; index += 1) {
      const item = controls.nth(index);
      if (!(await item.isVisible().catch(() => false))) continue;
      const label = clean(
        await item
          .evaluate(
            (element) =>
              element.innerText ||
              element.textContent ||
              element.value ||
              element.getAttribute("title") ||
              "",
          )
          .catch(() => ""),
        80,
      );
      const strongMatch =
        /全部确认审核|全部审核|确认并审核|确认审核/.test(label);
      const dialogMatch =
        isAuditDialog && /^(确认|确定|继续|确认并继续)$/.test(label);
      if (strongMatch || dialogMatch) {
        frameMatches.push({ frame: candidate, item, label });
      }
    }
    if (!frameMatches.length) {
      for (const label of [
        "全部确认审核",
        "全部审核",
        "确认并审核",
        "确认审核",
      ]) {
        const textMatches = await firstVisible(
          candidate.getByText(label, { exact: true }),
        );
        for (const item of textMatches) {
          frameMatches.push({ frame: candidate, item, label });
        }
        if (frameMatches.length) break;
      }
    }
    if (!frameMatches.length && isAuditDialog) {
      for (const label of ["确认", "确定", "继续", "确认并继续"]) {
        const textMatches = await firstVisible(
          candidate.getByText(label, { exact: true }),
        );
        for (const item of textMatches) {
          frameMatches.push({ frame: candidate, item, label });
        }
        if (frameMatches.length) break;
      }
    }
    matches.push(...frameMatches);
  }
  if (matches.length > 1) {
    const exact = matches.filter((match) =>
      /全部确认审核/.test(match.label),
    );
    if (exact.length === 1) return exact[0];
    throw new Error(`audit confirmation control count ${matches.length}`);
  }
  return matches[0] || null;
}

async function purchaseAuditResult(purchaseFrame) {
  const overlays = await firstVisible(
    purchaseFrame.locator(".jmx-result-wrapper"),
  );
  for (const overlay of overlays) {
    const body = clean(await overlay.innerText().catch(() => ""), 1000);
    if (/失败|错误|未成功/.test(body)) {
      throw new Error(`Purchase audit failed: ${body}`);
    }
    if (/成功|完成|已确认|已审核/.test(body)) {
      return { success: true, body, overlay };
    }
  }
  return { success: false, body: "", overlay: null };
}

async function hideAuditResultOverlay(result) {
  if (!result?.overlay) return;
  await result.overlay
    .evaluate((element) => {
      element.style.display = "none";
      element.style.pointerEvents = "none";
    })
    .catch(() => {});
}

async function clearPurchaseResultOverlays(
  purchaseFrame,
  timeoutMs = 5000,
) {
  const deadline = Date.now() + timeoutMs;
  let cleared = false;
  while (Date.now() < deadline) {
    const overlays = await firstVisible(
      purchaseFrame.locator(".jmx-result-wrapper"),
    );
    if (overlays.length) {
      for (const overlay of overlays) {
        await overlay
          .evaluate((element) => {
            element.style.display = "none";
            element.style.pointerEvents = "none";
            element.setAttribute("aria-hidden", "true");
          })
          .catch(() => {});
      }
      cleared = true;
      await purchaseFrame.waitForTimeout(250);
      continue;
    }
    if (cleared) return true;
    await purchaseFrame.waitForTimeout(200);
  }
  return cleared;
}

async function describe1688AccountControls(navigationFrame) {
  const controls = navigationFrame.locator(
    [
      "select",
      "input",
      "[role='combobox']",
      "[id*='account' i]",
      "[name*='account' i]",
      "[class*='select' i]",
    ].join(","),
  );
  const diagnostics = [];
  const count = Math.min(await controls.count(), 80);
  for (let index = 0; index < count; index += 1) {
    const item = controls.nth(index);
    diagnostics.push(
      await item
        .evaluate((element) => {
          const rect = element.getBoundingClientRect();
          const style = window.getComputedStyle(element);
          const visible =
            rect.width > 0 &&
            rect.height > 0 &&
            style.display !== "none" &&
            style.visibility !== "hidden";
          const options =
            element.tagName === "SELECT"
              ? Array.from(element.options || [])
                  .slice(0, 20)
                  .map((option) => ({
                    text: (option.textContent || "").trim().slice(0, 120),
                    selected: option.selected,
                    disabled: option.disabled,
                  }))
              : [];
          return {
            tag: element.tagName,
            id: element.id || "",
            name: element.getAttribute("name") || "",
            type: element.getAttribute("type") || "",
            role: element.getAttribute("role") || "",
            title: element.getAttribute("title") || "",
            placeholder: element.getAttribute("placeholder") || "",
            className:
              typeof element.className === "string"
                ? element.className.slice(0, 180)
                : "",
            text: (element.innerText || element.textContent || "")
              .replace(/\s+/g, " ")
              .trim()
              .slice(0, 240),
            parentText: (element.parentElement?.innerText || "")
              .replace(/\s+/g, " ")
              .trim()
              .slice(0, 240),
            checked: "checked" in element ? element.checked : undefined,
            hasValue:
              "value" in element &&
              String(element.value || "").trim().length > 0,
            visible,
            options,
          };
        })
        .catch(() => null),
    );
  }
  return diagnostics.filter(Boolean);
}

async function waitFor1688AccountReady(
  navigationFrame,
  timeoutMs = 8000,
) {
  const deadline = Date.now() + timeoutMs;
  const absenceDeadline = Date.now() + 2000;
  let latest = [];
  while (Date.now() < deadline) {
    latest = await describe1688AccountControls(navigationFrame);
    const candidates = latest.filter((item) => {
      if (!item.visible) return false;
      const label = [
        item.id,
        item.name,
        item.title,
        item.placeholder,
        item.className,
        item.parentText,
      ].join(" ");
      return /1688.*(账号|账户)|(账号|账户).*1688/i.test(label);
    });
    if (!candidates.length) {
      if (Date.now() >= absenceDeadline) {
        return { detected: false, ready: true, diagnostics: latest };
      }
    } else {
      const ready = candidates.some((item) => {
        if (item.tag === "SELECT") {
          return item.options.some(
            (option) =>
              option.selected &&
              !option.disabled &&
              option.text &&
              !/请选择|选择账号|选择账户/.test(option.text),
          );
        }
        return item.hasValue || Boolean(item.text);
      });
      if (ready) {
        return { detected: true, ready: true, diagnostics: candidates };
      }
    }
    await navigationFrame.waitForTimeout(250);
  }
  return { detected: true, ready: false, diagnostics: latest };
}

async function confirm1688DialogsAfterSave(
  navigationFrame,
  purchaseOrderNo,
  report = () => {},
  timeoutMs = 6000,
) {
  const deadline = Date.now() + timeoutMs;
  let quietSince = Date.now();
  let confirmed = 0;
  while (Date.now() < deadline) {
    const dialogs = [];
    for (const candidate of page.frames()) {
      if (
        !candidate.url().includes("/epaas-dialog-frame.html") ||
        !(await frameChainVisible(candidate).catch(() => false)) ||
        isDescendantFrame(navigationFrame, candidate)
      ) {
        continue;
      }
      const body = clean(
        await candidate.locator("body").innerText().catch(() => ""),
        1000,
      );
      if (/1688|一键下单|一键代发|明文|密文/.test(body)) {
        dialogs.push({ frame: candidate, body });
      }
    }
    if (dialogs.length > 1) {
      throw new Error(`1688 pre-save dialog count ${dialogs.length}`);
    }
    if (!dialogs.length) {
      if (Date.now() - quietSince >= 1000) return confirmed;
      await page.waitForTimeout(200);
      continue;
    }
    const dialog = dialogs[0];
    let control = null;
    for (const label of [
      "确认并继续",
      "确认",
      "确定",
      "继续",
      "是",
    ]) {
      const controls = await firstVisible(
        dialog.frame.getByText(label, { exact: true }),
      );
      if (controls.length > 1) {
        throw new Error(`1688 pre-save confirmation count ${controls.length}`);
      }
      if (controls.length === 1) {
        control = controls[0];
        break;
      }
    }
    if (!control) {
      const accountDiagnostics = /1688账号不能为空/.test(dialog.body)
        ? await describe1688AccountControls(navigationFrame)
        : [];
      logInternalError(
        new Error(
          `1688 pre-save confirmation diagnostics ${dialog.body}; ` +
            `account_controls=${JSON.stringify(accountDiagnostics)}`,
        ),
        `1688-pre-save-${purchaseOrderNo}`,
      );
      throw new Error("1688 pre-save confirmation was not found");
    }
    report(
      "supplier.1688.save_confirm.started",
      "正在确认1688一件代发提示",
      "started",
      { purchase_order_no: purchaseOrderNo },
    );
    await control.click({ force: true });
    confirmed += 1;
    report(
      "supplier.1688.save_confirm.completed",
      "1688一件代发提示已确认",
      "completed",
      { purchase_order_no: purchaseOrderNo },
    );
    quietSince = Date.now();
    await page.waitForTimeout(500);
  }
  return confirmed;
}

async function click1688SaveWithOverlayRecovery(
  navigationFrame,
  purchaseOrderNo,
  report = () => {},
) {
  try {
    await clickExactText(navigationFrame, "保存", "save 1688 navigation");
    return;
  } catch (error) {
    const message = String(error?.message || error || "");
    if (!/epaasDialogFrame|intercepts pointer events/i.test(message)) {
      throw error;
    }
    const confirmed = await confirm1688DialogsAfterSave(
      navigationFrame,
      purchaseOrderNo,
      report,
      2500,
    );
    const hidden = await hideBlankEpaasPointerOverlays(navigationFrame);
    if (!confirmed && !hidden) throw error;
    report(
      "supplier.1688.save.overlay_recovered",
      "1688保存遮罩已安全处理，正在重试保存",
      "completed",
      { purchase_order_no: purchaseOrderNo },
    );
    await navigationFrame.waitForTimeout(250);
    await clickExactText(navigationFrame, "保存", "save 1688 navigation");
  }
}

async function setLegacyCheckboxChecked(locator) {
  if (!(await locator.isChecked())) {
    await locator.check();
  }
  const state = await locator.evaluate((element) => {
    element.setAttribute("checked", "checked");
    if (window.jQuery) {
      window.jQuery(element).prop("checked", true);
      window.jQuery(element).attr("checked", "checked");
    }
    return {
      checked: Boolean(element.checked),
      checkedAttribute: element.getAttribute("checked") || "",
    };
  });
  if (!state.checked || state.checkedAttribute !== "checked") {
    throw new Error("1688 dropship checkbox verification failed");
  }
}

async function read1688DeliveryAddressState(frame, checkbox) {
  return frame.evaluate((purchaseAddress) => {
    const visible = (element) => {
      const rect = element.getBoundingClientRect();
      const style = window.getComputedStyle(element);
      return (
        rect.width > 0 &&
        rect.height > 0 &&
        style.display !== "none" &&
        style.visibility !== "hidden"
      );
    };
    const values = Array.from(
      document.querySelectorAll("select,input:not([type='hidden']),textarea"),
    )
      .filter(visible)
      .map((element) => {
        if (element.tagName === "SELECT") {
          return String(element.selectedOptions?.[0]?.textContent || "");
        }
        return String(element.value || "");
      })
      .map((value) => value.replace(/\s+/g, " ").trim())
      .filter(Boolean);
    return {
      checked: Boolean(purchaseAddress?.checked),
      values,
      bodyText: String(document.body?.innerText || "")
        .replace(/\s+/g, " ")
        .trim()
        .slice(0, 5000),
    };
  }, await checkbox.elementHandle());
}

async function capture1688DefaultAddressState(frame, checkbox) {
  if (await checkbox.isChecked()) {
    await checkbox.uncheck();
  }
  const deadline = Date.now() + 5000;
  let latest = { checked: true, values: [] };
  while (Date.now() < deadline) {
    latest = await read1688DeliveryAddressState(frame, checkbox);
    if (!latest.checked && latest.values.length) {
      await frame.waitForTimeout(400);
      return read1688DeliveryAddressState(frame, checkbox);
    }
    await frame.waitForTimeout(200);
  }
  throw safeOrderFailure("1688 default delivery address capture failed");
}

function deliveryAddressMatchDiagnostics(order, currentValues) {
  const values = currentValues || [];
  const currentText = values.join(" ");
  const text = normalizedContactText(currentText);
  const verified = order.__verifiedDelivery || {};
  const recipient = normalizedRecipientText(
    verified.recipient || order.recipient,
  );
  const phone = normalizedPhoneDigits(verified.phone || order.phone);
  const privacySuffix = privacyPhoneSuffix(order.phone);
  const address = verified.address || order.address;
  const administrativeParts = verified.administrativeParts || [];
  const recipientMatch = recipient.length > 0 && text.includes(recipient);
  const phoneMatch = phone.length >= 7 && text.includes(phone);
  const privacySuffixMatch = Boolean(
    privacySuffix && text.includes(privacySuffix),
  );
  const addressMatch = values.some((value) =>
    addressTextMatches(address, value, administrativeParts),
  );
  return {
    recipientMatch,
    phoneMatch,
    privacySuffixMatch,
    addressMatch,
    contactMatch: Boolean(
      privacySuffix
        ? privacySuffixMatch && addressMatch
        : recipientMatch && phoneMatch && addressMatch
    ),
  };
}

function deliveryAddressStateMatchesOrder(
  order,
  currentValues,
  defaultValues,
  currentBodyText = "",
  defaultBodyText = "",
) {
  const currentContactValues = [
    ...(currentValues || []),
    currentBodyText,
  ].filter(Boolean);
  const currentText = currentContactValues.join(" ");
  const currentFingerprint = normalizedContactText(currentText);
  const defaultFingerprint = normalizedContactText(
    [...(defaultValues || []), defaultBodyText].filter(Boolean).join(" "),
  );
  const diagnostics = deliveryAddressMatchDiagnostics(
    order,
    currentContactValues,
  );
  return Boolean(
    diagnostics.contactMatch
      && currentFingerprint
      && currentFingerprint !== defaultFingerprint
  );
}

async function waitFor1688BuyerAddress(
  frame,
  checkbox,
  order,
  forbiddenState,
) {
  const deadline = Date.now() + 10000;
  let latest = { checked: false, values: [] };
  while (Date.now() < deadline) {
    latest = await read1688DeliveryAddressState(frame, checkbox);
    if (
      latest.checked &&
      deliveryAddressStateMatchesOrder(
        order,
        latest.values,
        forbiddenState.values,
        latest.bodyText,
        forbiddenState.bodyText,
      )
    ) {
      return latest;
    }
    await frame.waitForTimeout(250);
  }
  const currentText = latest.values.join(" ");
  const matchDiagnostics = deliveryAddressMatchDiagnostics(
    order,
    [...latest.values, latest.bodyText].filter(Boolean),
  );
  logInternalError(
    new Error(
      "1688 delivery address diagnostics "
        + JSON.stringify({
          checked: latest.checked,
          value_count: latest.values.length,
          recipient_match: matchDiagnostics.recipientMatch,
          phone_match: matchDiagnostics.phoneMatch,
          privacy_suffix_match: matchDiagnostics.privacySuffixMatch,
          address_match: matchDiagnostics.addressMatch,
          differs_from_default:
            normalizedContactText(currentText)
              !== normalizedContactText(
                [...(forbiddenState.values || []), forbiddenState.bodyText]
                  .filter(Boolean)
                  .join(" "),
              ),
        }),
    ),
    `1688-address-${order.order_id}`,
  );
  throw safeOrderFailure("1688 delivery address verification failed");
}

async function install1688AsyncRecorder(frame, purchaseOrderNo) {
  await frame.evaluate((expectedPurchaseOrderNo) => {
    const recorderKey = "__dewu1688AsyncRecorder";
    const current = window[recorderKey];
    if (current?.installed) {
      current.records = [];
      current.confirmations = [];
      current.messages = [];
      current.purchaseOrderNo = String(expectedPurchaseOrderNo || "");
      return;
    }
    if (typeof window._AsyncCallPage !== "function") {
      throw new Error("1688 async call recorder unavailable");
    }
    const recorder = {
      installed: true,
      records: [],
      confirmations: [],
      messages: [],
      purchaseOrderNo: String(expectedPurchaseOrderNo || ""),
      original: window._AsyncCallPage,
      originalCfm: window.jQuery?.cfm,
      originalMsg: window.jQuery?.msg,
    };
    const clone = (value) => {
      try {
        return JSON.parse(JSON.stringify(value));
      } catch {
        return String(value ?? "").slice(0, 4000);
      }
    };
    window[recorderKey] = recorder;
    window._AsyncCallPage = function (
      method,
      callback,
      ...args
    ) {
      const wrappedCallback = function (...callbackArgs) {
        recorder.records.push({
          method: String(method || "").slice(0, 80),
          response: clone(callbackArgs[0]),
          receivedAt: Date.now(),
        });
        if (typeof callback === "function") {
          return callback.apply(this, callbackArgs);
        }
        return undefined;
      };
      return recorder.original.call(
        this,
        method,
        wrappedCallback,
        ...args
      );
    };
    if (typeof recorder.originalCfm === "function") {
      window.jQuery.cfm = function (
        message,
        callback,
        ...args
      ) {
        const text = String(
          message?.text || message?.html || message || "",
        )
          .replace(/\s+/g, " ")
          .trim()
          .slice(0, 1200);
        const expected = recorder.purchaseOrderNo;
        const targetScopedConfirmation =
          Boolean(expected && text.includes(expected)) &&
          /分销|代发|下单|1688/.test(text) &&
          !/失败|错误|不能|禁止|下架|库存不足|不支持|异常/.test(text);
        const autoConfirm =
          /^请确认一键下单更改成一键代发[?？]?$/.test(text) ||
          /^存在本地商品单价高于1688线上产品单价商品,?是否继续下单/.test(
            text,
          ) ||
          /^如您选择密文对淘宝店铺分销代发/.test(text) ||
          targetScopedConfirmation;
        const entry = {
          message: text,
          autoConfirmed: autoConfirm,
          resolved: autoConfirm,
          receivedAt: Date.now(),
        };
        recorder.confirmations.push(entry);
        if (autoConfirm) {
          setTimeout(() => {
            if (typeof callback === "function") callback(true);
          }, 0);
          return true;
        }
        return recorder.originalCfm.call(
          this,
          message,
          function (value) {
            entry.resolved = true;
            entry.accepted = Boolean(value);
            if (typeof callback === "function") {
              return callback.apply(this, arguments);
            }
            return undefined;
          },
          ...args
        );
      };
    }
    if (typeof recorder.originalMsg === "function") {
      window.jQuery.msg = function (message, ...args) {
        recorder.messages.push({
          message: String(
            message?.text || message?.html || message || "",
          )
            .replace(/\s+/g, " ")
            .trim()
            .slice(0, 1200),
          receivedAt: Date.now(),
        });
        return recorder.originalMsg.call(this, message, ...args);
      };
    }
  }, String(purchaseOrderNo || ""));
}

async function read1688RecorderState(frame) {
  return frame.evaluate(() => {
    const recorder = window.__dewu1688AsyncRecorder || {};
    return {
      records: Array.from(recorder.records || []).slice(-30),
      confirmations: Array.from(
        recorder.confirmations || [],
      ).slice(-20),
      messages: Array.from(recorder.messages || []).slice(-20),
    };
  });
}

function exact1688SuccessMessage(messages, purchaseOrderNo) {
  const expected = String(purchaseOrderNo || "");
  return (messages || []).find((item) => {
    const text = clean(item?.message ?? item, 1200);
    return Boolean(
      expected &&
        text.includes(expected) &&
        /成功/.test(text) &&
        !/失败|错误/.test(text),
    );
  });
}

function parseMaybeJson(value) {
  if (typeof value !== "string") return value;
  try {
    return JSON.parse(value);
  } catch {
    return value;
  }
}

function inspect1688SubmissionRecords(records) {
  for (const record of records || []) {
    const method = clean(record?.method, 80);
    const response = parseMaybeJson(record?.response);
    if (method === "PriceContrast" && Array.isArray(response)) {
      const blocked = response.find(
        (item) =>
          ["0", "3"].includes(String(item?.Key ?? item?.key ?? "")) &&
          clean(item?.Value ?? item?.value, 500),
      );
      if (blocked) {
        return {
          state: "rejected",
          reason: clean(blocked.Value ?? blocked.value, 500),
        };
      }
    }
    if (method !== "PurchaseTo1688V3" || !response) continue;
    if (response.isComfrimFenXiao) {
      continue;
    }
    const results = Array.isArray(response?.poResults)
      ? response.poResults
      : [];
    const messages = results
      .map((item) => clean(item?.Value ?? item?.value, 500))
      .filter(Boolean);
    if (messages.some((message) => /成功/.test(message))) {
      return { state: "accepted", reason: messages.join("；") };
    }
    return {
      state: "rejected",
      reason:
        messages.join("；") ||
        (response.needSplit
          ? "采购单需要拆分"
          : "ERP未返回下单成功"),
    };
  }
  return { state: "pending", reason: "" };
}

function create1688NativeDialogGuard(
  purchaseOrderNo,
  report,
  confirmationTexts,
) {
  let tasks = [];
  const handler = (dialog) => {
    const task = (async () => {
      const message = clean(dialog.message(), 1000);
      if (message) confirmationTexts.push(message);
      if (!/1688|一键|代发|下单|明文|密文|确认/.test(message)) {
        await dialog.dismiss().catch(() => {});
        return { accepted: false, message };
      }
      report(
        "supplier.1688.native_confirm.started",
        "正在确认浏览器1688下单提示",
        "started",
        { purchase_order_no: purchaseOrderNo },
      );
      await dialog.accept();
      report(
        "supplier.1688.native_confirm.completed",
        "浏览器1688下单提示已确认",
        "completed",
        { purchase_order_no: purchaseOrderNo },
      );
      return { accepted: true, message };
    })().catch((error) => ({
      accepted: false,
      message: clean(error?.message || error, 500),
    }));
    tasks.push(task);
  };
  page.on("dialog", handler);
  return {
    async drain() {
      while (tasks.length) {
        const current = tasks;
        tasks = [];
        const results = await Promise.all(current);
        if (results.some((result) => !result.accepted)) {
          throw new Error("1688 native confirmation was not accepted");
        }
      }
    },
    stop() {
      page.off("dialog", handler);
    },
  };
}

async function auditConfirmationDiagnostics() {
  const frames = [];
  const selector = [
    "button",
    "a",
    "[role='button']",
    "input[type='button']",
    "input[type='submit']",
    "[onclick]",
  ].join(",");
  for (const candidate of page.frames()) {
    if (!(await frameChainVisible(candidate).catch(() => false))) continue;
    const labels = [];
    const controls = candidate.locator(selector);
    const count = Math.min(
      await controls.count().catch(() => 0),
      500,
    );
    for (let index = 0; index < count; index += 1) {
      const item = controls.nth(index);
      if (!(await item.isVisible().catch(() => false))) continue;
      const label = clean(
        await item
          .evaluate(
            (element) =>
              element.innerText ||
              element.textContent ||
              element.value ||
              element.getAttribute("title") ||
              "",
          )
          .catch(() => ""),
        120,
      );
      if (label && /审核|确认|确定|生效|继续/.test(label)) {
        labels.push(label);
      }
    }
    const isDialog = candidate.url().includes("/epaas-dialog-frame.html");
    const dialogText = isDialog
      ? clean(
          await candidate.locator("body").innerText().catch(() => ""),
          1000,
        )
      : "";
    if (labels.length || dialogText) {
      let framePath = "";
      try {
        const parsed = new URL(candidate.url());
        framePath = `${parsed.origin}${parsed.pathname}`;
      } catch {
        framePath = clean(candidate.url().split("?")[0], 300);
      }
      frames.push({
        url: framePath,
        labels: [...new Set(labels)].slice(0, 30),
        dialog_text: dialogText,
      });
    }
  }
  return frames;
}

async function purchaseAuditPrimaryControl(purchaseFrame) {
  const preferred = await firstVisible(
    purchaseFrame.locator(
      "#MM_OPTM_Tool_Confirm > .ding_db_txt, " +
        "#MM_OPTM_Tool_Confirm .ding_db_txt",
    ),
  );
  if (preferred.length === 1) return preferred[0];
  if (preferred.length > 1) {
    throw new Error("Primary audit control is ambiguous");
  }
  const exact = await firstVisible(
    purchaseFrame.getByText("审核生效", { exact: true }),
  );
  if (exact.length !== 1) throw new Error("Audit control is ambiguous");
  return exact[0];
}

async function clickPurchaseAuditDropdownAction(purchaseFrame) {
  const arrows = await firstVisible(
    purchaseFrame.locator("#MM_OPTM_Tool_Confirm .ding_db_arrow"),
  );
  if (arrows.length !== 1) return false;
  await arrows[0].click({ force: true });
  await purchaseFrame.waitForTimeout(250);
  const actions = await firstVisible(
    purchaseFrame.locator(
      "#MM_OPTM_Tool_Confirm " +
        ".ding_db_itembox[ding='OPTM_Tool_Confirm'] .ding_db_item",
    ),
  );
  if (actions.length !== 1) return false;
  await actions[0].click({ force: true });
  return true;
}

async function invokePurchaseAuditFunction(purchaseFrame) {
  return purchaseFrame.evaluate(() => {
    if (typeof window.ConfirmV2 !== "function") return false;
    window.ConfirmV2();
    return true;
  });
}

async function invokeValidatedPurchaseAudit(purchaseFrame) {
  return purchaseFrame.evaluate(async () => {
    if (
      typeof window.GetCurrentJTableRow !== "function" ||
      typeof window.GetPoIdArray !== "function" ||
      typeof window._ACP !== "function" ||
      typeof window.ToConfirm !== "function"
    ) {
      return { submitted: false, reason: "required_functions_unavailable" };
    }
    const checkedRows = window.GetCurrentJTableRow("待审核") || [];
    if (checkedRows.length !== 1) {
      return {
        submitted: false,
        reason: "selected_purchase_count_invalid",
        selected_count: checkedRows.length,
      };
    }
    const errorPurchases = [];
    let purchaseIds = window.GetPoIdArray(checkedRows) || [];
    let checkStep = 1;
    const precheck = (ids, step) =>
      new Promise((resolve) => {
        let settled = false;
        let timer = null;
        const finish = (value) => {
          if (settled) return;
          settled = true;
          if (timer) clearTimeout(timer);
          resolve(value);
        };
        timer = setTimeout(
          () => finish({ __timeout: true }),
          20000,
        );
        try {
          window._ACP(
            "CheckBeforeConfirm",
            (result) => finish(result || null),
            ids.join(","),
            step,
          );
        } catch (error) {
          finish({
            __error: String(error?.message || error || "precheck_failed"),
          });
        }
      });
    for (let attempt = 1; attempt <= 8; attempt += 1) {
      if (!purchaseIds.length) {
        return { submitted: false, reason: "no_valid_purchase_ids" };
      }
      const result = await precheck(purchaseIds, checkStep);
      if (!result || result.__timeout || result.__error) {
        return {
          submitted: false,
          reason: result?.__timeout
            ? "precheck_timeout"
            : result?.__error || "precheck_empty",
        };
      }
      errorPurchases.push(...(result.FailedPurs || []));
      const warningIds = [
        ...new Set(
          (result.WarningPurs || [])
            .map((row) => row?.PoId)
            .filter(Boolean),
        ),
      ];
      const nextIds = [
        ...(result.SuccessPoId || []),
        ...warningIds,
      ];
      const nextStep = Number(result.NextStep || 0);
      if (nextStep > 0) {
        purchaseIds = nextIds;
        checkStep = nextStep;
        continue;
      }
      if (!nextIds.length) {
        return {
          submitted: false,
          reason: "precheck_rejected_all_purchases",
        };
      }
      window.ToConfirm(
        nextIds,
        errorPurchases,
        checkedRows,
        result.Confirmed,
      );
      return {
        submitted: true,
        confirmed_count: nextIds.length,
        warning_count: warningIds.length,
        failed_count: errorPurchases.length,
      };
    }
    return { submitted: false, reason: "precheck_step_limit" };
  });
}

async function selectPurchaseRowForAudit(
  purchaseFrame,
  purchaseOrderNo,
) {
  for (let attempt = 1; attempt <= 3; attempt += 1) {
    const rowCheckboxes = purchaseFrame.locator(
      "._jt_row input[type='checkbox']",
    );
    const rowCheckboxCount = await rowCheckboxes.count();
    for (let index = 0; index < rowCheckboxCount; index += 1) {
      const item = rowCheckboxes.nth(index);
      if (!(await item.isVisible().catch(() => false))) continue;
      await item.evaluate((element) => {
        element.checked = false;
        element.removeAttribute("checked");
        element.dispatchEvent(new Event("input", { bubbles: true }));
        element.dispatchEvent(new Event("change", { bubbles: true }));
      }).catch(() => {});
    }

    const targetRow = await purchaseRowLocator(
      purchaseFrame,
      purchaseOrderNo,
    );
    const selected = await targetRow.evaluate((row) => {
      const checkbox = row.querySelector("input[type='checkbox']");
      if (!checkbox) return false;
      checkbox.checked = true;
      checkbox.setAttribute("checked", "checked");
      checkbox.dispatchEvent(new Event("input", { bubbles: true }));
      checkbox.dispatchEvent(new Event("change", { bubbles: true }));
      return checkbox.checked;
    }).catch(() => false);
    await purchaseFrame.waitForTimeout(200);
    const selectedRows = await purchaseFrame
      .locator("._jt_row")
      .evaluateAll((rows) =>
        rows
          .filter((row) => {
            const checkbox = row.querySelector("input[type='checkbox']");
            return checkbox?.checked && row.offsetParent !== null;
          })
          .map((row) =>
            String(row.innerText || row.textContent || "")
              .replace(/\s+/g, " ")
              .trim(),
          ),
      );
    if (
      selected &&
      selectedRows.length === 1 &&
      selectedRows[0].includes(String(purchaseOrderNo))
    ) {
      return;
    }
    if (attempt < 3) {
      await purchaseFrame.waitForTimeout(500);
    }
  }
  throw new Error("Purchase row selection was not isolated");
}

async function auditPurchase(
  purchaseFrame,
  purchaseOrderNo,
  report = () => {},
) {
  report(
    "purchase.audit.status.started",
    "正在核对采购单状态",
    "started",
    { purchase_order_no: purchaseOrderNo },
  );
  const rowBody = await readPurchaseRow(purchaseFrame, purchaseOrderNo);
  if (purchaseAuditCompleted(rowBody)) {
    report(
      "purchase.audit.already_completed",
      "采购单已经审核生效，无需重复审核",
      "skipped",
      { purchase_order_no: purchaseOrderNo },
    );
    return;
  }
  if (!rowBody.includes("待审核")) {
    throw new Error("Purchase is not waiting for audit");
  }
  report(
    "purchase.audit.status.completed",
    "采购单状态确认为待审核",
    "completed",
    { purchase_order_no: purchaseOrderNo },
  );
  report(
    "purchase.audit.select.started",
    "正在勾选采购单",
    "started",
    { purchase_order_no: purchaseOrderNo },
  );
  await selectPurchaseRowForAudit(purchaseFrame, purchaseOrderNo);
  report(
    "purchase.audit.select.completed",
    "采购单已勾选",
    "completed",
    { purchase_order_no: purchaseOrderNo },
  );
  const auditTarget = await purchaseAuditPrimaryControl(purchaseFrame);
  report(
    "purchase.audit.submit.started",
    "正在点击审核生效",
    "started",
    { purchase_order_no: purchaseOrderNo },
  );
  let nativeDialogTask = null;
  let nativeDialogReported = false;
  let confirmationSubmitted = false;
  let functionFallbackSubmitted = false;
  let dropdownFallbackSubmitted = false;
  let validatedFallbackSubmitted = false;
  let auditResult = { success: false, body: "", overlay: null };
  const nativeDialogHandler = (dialog) => {
    nativeDialogTask = (async () => {
      const message = clean(dialog.message(), 500);
      if (!/审核|生效|确认/.test(message)) {
        await dialog.dismiss().catch(() => {});
        return { accepted: false, message };
      }
      await dialog.accept().catch(() => {});
      return { accepted: true, message };
    })();
  };
  page.on("dialog", nativeDialogHandler);
  try {
    await auditTarget.click({ force: true });
    const auditTriggeredAt = Date.now();
    report(
      "purchase.audit.confirm.started",
      "正在识别并处理审核确认",
      "started",
      { purchase_order_no: purchaseOrderNo },
    );
    const deadline = Date.now() + 30000;
    let nextRefreshAt = Date.now() + 3000;
    while (Date.now() < deadline) {
      if (nativeDialogTask) {
        const nativeResult = await nativeDialogTask;
        if (!nativeResult.accepted) {
          throw new Error("Purchase audit confirmation was not completed");
        }
        confirmationSubmitted = true;
        if (!nativeDialogReported) {
          report(
            "purchase.audit.confirm.native.completed",
            "浏览器审核确认已提交",
            "completed",
            { purchase_order_no: purchaseOrderNo },
          );
          nativeDialogReported = true;
        }
      }
      if (!confirmationSubmitted) {
        const confirmAudit = await findAuditConfirmationControl();
        if (confirmAudit) {
          await confirmAudit.item.click({ force: true });
          confirmationSubmitted = true;
          report(
            "purchase.audit.confirm.completed",
            "采购单审核确认已提交",
            "completed",
            { purchase_order_no: purchaseOrderNo },
          );
          await purchaseFrame.waitForTimeout(500);
        }
      }
      auditResult = await purchaseAuditResult(purchaseFrame);
      const currentRowBody = await readPurchaseRow(
        purchaseFrame,
        purchaseOrderNo,
      ).catch(() => "");
      if (purchaseAuditCompleted(currentRowBody)) {
        if (!confirmationSubmitted) {
          report(
            "purchase.audit.confirm.not_required",
            "ERP已直接完成审核，无需二次确认",
            "skipped",
            { purchase_order_no: purchaseOrderNo },
          );
        }
        report(
          "purchase.audit.status.verified",
          "已回读采购单状态，确认审核生效",
          "completed",
          { purchase_order_no: purchaseOrderNo },
        );
        break;
      }
      if (
        !confirmationSubmitted &&
        !nativeDialogTask &&
        !auditResult.success &&
        !functionFallbackSubmitted &&
        Date.now() - auditTriggeredAt >= 2500
      ) {
        functionFallbackSubmitted = true;
        report(
          "purchase.audit.submit.function.started",
          "主审核按钮未响应，正在调用页面审核动作",
          "started",
          { purchase_order_no: purchaseOrderNo },
        );
        const invoked = await invokePurchaseAuditFunction(purchaseFrame);
        report(
          invoked
            ? "purchase.audit.submit.function.completed"
            : "purchase.audit.submit.function.skipped",
          invoked
            ? "页面审核动作已调用"
            : "页面审核动作当前不可用，继续尝试审核菜单",
          invoked ? "completed" : "skipped",
          { purchase_order_no: purchaseOrderNo },
        );
      }
      if (
        !confirmationSubmitted &&
        !nativeDialogTask &&
        !auditResult.success &&
        !dropdownFallbackSubmitted &&
        Date.now() - auditTriggeredAt >= 5000
      ) {
        dropdownFallbackSubmitted = true;
        report(
          "purchase.audit.submit.fallback.started",
          "主审核按钮未响应，正在通过审核下拉项继续",
          "started",
          { purchase_order_no: purchaseOrderNo },
        );
        const clicked = await clickPurchaseAuditDropdownAction(
          purchaseFrame,
        );
        report(
          clicked
            ? "purchase.audit.submit.fallback.completed"
            : "purchase.audit.submit.fallback.skipped",
          clicked
            ? "审核下拉项已提交"
            : "审核下拉项当前不可用，继续等待页面响应",
          clicked ? "completed" : "skipped",
          { purchase_order_no: purchaseOrderNo },
        );
      }
      if (
        !confirmationSubmitted &&
        !nativeDialogTask &&
        !auditResult.success &&
        !validatedFallbackSubmitted &&
        Date.now() - auditTriggeredAt >= 8000
      ) {
        validatedFallbackSubmitted = true;
        report(
          "purchase.audit.submit.validated.started",
          "审核确认层未出现，正在通过ERP预审结果提交目标采购单",
          "started",
          { purchase_order_no: purchaseOrderNo },
        );
        const validated = await invokeValidatedPurchaseAudit(
          purchaseFrame,
        );
        if (validated.submitted) {
          confirmationSubmitted = true;
        }
        report(
          validated.submitted
            ? "purchase.audit.submit.validated.completed"
            : "purchase.audit.submit.validated.skipped",
          validated.submitted
            ? "ERP预审通过，目标采购单审核已提交"
            : "ERP预审未返回可提交结果，继续等待页面状态",
          validated.submitted ? "completed" : "skipped",
          {
            purchase_order_no: purchaseOrderNo,
            audit_reason: clean(validated.reason, 120),
          },
        );
      }
      if (confirmationSubmitted && Date.now() >= nextRefreshAt) {
        await hideAuditResultOverlay(auditResult);
        const searchControls = await firstVisible(
          purchaseFrame.getByText("搜索", { exact: true }),
        );
        if (searchControls.length === 1) {
          await searchControls[0].click().catch(() => {});
          await purchaseFrame.waitForTimeout(900);
        }
        nextRefreshAt = Date.now() + 3000;
      }
      await purchaseFrame.waitForTimeout(250);
    }
    const verifiedRowBody = await readPurchaseRow(
      purchaseFrame,
      purchaseOrderNo,
    ).catch(() => "");
    if (!purchaseAuditCompleted(verifiedRowBody)) {
      const diagnostics = await auditConfirmationDiagnostics().catch(
        () => [],
      );
      logInternalError(
        new Error(
          `Purchase audit confirmation diagnostics ${JSON.stringify(
            diagnostics,
          )}`,
        ),
        `audit-controls-${purchaseOrderNo}`,
      );
      throw new Error("Purchase audit confirmation was not completed");
    }
  } finally {
    page.off("dialog", nativeDialogHandler);
    await hideAuditResultOverlay(auditResult);
  }
  if (await clearPurchaseResultOverlays(purchaseFrame)) {
    report(
      "purchase.audit.result.closed",
      "采购单审核结果层已关闭",
      "completed",
      { purchase_order_no: purchaseOrderNo },
    );
  }
  report(
    "purchase.audit.success",
    "采购单审核生效成功",
    "completed",
    { purchase_order_no: purchaseOrderNo },
  );
}

async function place1688Order(
  purchaseFrame,
  purchaseOrderNo,
  order,
  report = () => {},
) {
  report(
    "supplier.1688.status.started",
    "正在核对是否已有1688线上单号",
    "started",
    { purchase_order_no: purchaseOrderNo },
  );
  let rowBody = await readPurchaseRow(purchaseFrame, purchaseOrderNo);
  const existingOrder = verified1688Order(rowBody);
  if (existingOrder.verified) {
    const online = existingOrder.onlineOrderNo;
    report(
      "supplier.1688.already_completed",
      "已存在1688线上单号，无需重复下单",
      "skipped",
      {
        purchase_order_no: purchaseOrderNo,
        online_1688_order_no: online,
      },
    );
    return { onlineOrderNo: online, reused: true };
  }
  await clearPurchaseResultOverlays(purchaseFrame);
  const trigger = purchaseFrame.locator("#OPTM_Purhcase_Order_1688");
  if ((await trigger.count()) !== 1) {
    throw new Error("1688 toolbar entry is ambiguous");
  }
  report(
    "supplier.sync.open.started",
    "正在打开同步供应商菜单",
    "started",
    { purchase_order_no: purchaseOrderNo },
  );
  await trigger.click();
  report(
    "supplier.sync.open.completed",
    "同步供应商菜单已打开",
    "completed",
    { purchase_order_no: purchaseOrderNo },
  );
  report(
    "supplier.1688.menu.started",
    "正在选择1688一键下单",
    "started",
    { purchase_order_no: purchaseOrderNo },
  );
  await clickExactText(purchaseFrame, "1688一键下单", "1688 one-click order");
  report(
    "supplier.1688.navigation.started",
    "正在打开1688下单导航",
    "started",
    { purchase_order_no: purchaseOrderNo },
  );
  const dropshipMatch = await waitForVisibleLocatorAcrossFrames(
    "#purchaseAddress",
    "1688 dropship option",
  );
  report(
    "supplier.1688.navigation.completed",
    "1688下单导航已打开",
    "completed",
    { purchase_order_no: purchaseOrderNo },
  );
  report(
    "supplier.1688.account.waiting",
    "正在等待1688账号加载",
    "waiting",
    { purchase_order_no: purchaseOrderNo },
  );
  const accountState = await waitFor1688AccountReady(dropshipMatch.frame);
  if (!accountState.ready) {
    logInternalError(
      new Error(
        `1688 account was not ready; ` +
          `account_controls=${JSON.stringify(accountState.diagnostics)}`,
      ),
      `1688-account-${purchaseOrderNo}`,
    );
    throw new Error("1688 account was not ready");
  }
  report(
    "supplier.1688.account.ready",
    accountState.detected
      ? "1688账号已加载"
      : "1688下单导航已完成加载",
    "completed",
    { purchase_order_no: purchaseOrderNo },
  );
  const dropshipVisible = dropshipMatch.item;
  report(
    "supplier.1688.address_guard.started",
    "正在记录并禁用公司默认收货地址",
    "started",
    { purchase_order_no: purchaseOrderNo },
  );
  const defaultAddressState = await capture1688DefaultAddressState(
    dropshipMatch.frame,
    dropshipVisible,
  );
  report(
    "supplier.1688.dropship.started",
    "正在勾选1688下单一件代发",
    "started",
    { purchase_order_no: purchaseOrderNo },
  );
  await setLegacyCheckboxChecked(dropshipVisible);
  await waitFor1688BuyerAddress(
    dropshipMatch.frame,
    dropshipVisible,
    order,
    defaultAddressState,
  );
  report(
    "supplier.1688.address_guard.completed",
    "1688收货信息已匹配当前订单，且已排除公司默认地址",
    "completed",
    { purchase_order_no: purchaseOrderNo },
  );
  report(
    "supplier.1688.dropship.completed",
    "1688一件代发已勾选，收货信息已切换为当前订单",
    "completed",
    { purchase_order_no: purchaseOrderNo },
  );
  await install1688AsyncRecorder(
    dropshipMatch.frame,
    purchaseOrderNo,
  );
  const confirmationTexts = [];
  let latestAsyncRecords = [];
  let latestRecorderState = {
    records: [],
    confirmations: [],
    messages: [],
  };
  let submissionAccepted = false;
  let submissionAcceptedReported = false;
  const nativeDialogGuard = create1688NativeDialogGuard(
    purchaseOrderNo,
    report,
    confirmationTexts,
  );
  try {
  report(
    "supplier.1688.save.started",
    "正在保存1688下单导航",
    "started",
    { purchase_order_no: purchaseOrderNo },
  );
  await click1688SaveWithOverlayRecovery(
    dropshipMatch.frame,
    purchaseOrderNo,
    report,
  );
  await nativeDialogGuard.drain();
  await confirm1688DialogsAfterSave(
    dropshipMatch.frame,
    purchaseOrderNo,
    report,
    15000,
  );
  await nativeDialogGuard.drain();
  report(
    "supplier.1688.save.completed",
    "1688下单保存操作已提交",
    "completed",
    { purchase_order_no: purchaseOrderNo },
  );
  report(
    "supplier.1688.order.waiting",
    "正在等待1688下单确认和线上单号",
    "waiting",
    { purchase_order_no: purchaseOrderNo },
  );
  report(
    "supplier.1688.verify.started",
    "正在回读采购单并复核1688线上单号和下单状态",
    "started",
    { purchase_order_no: purchaseOrderNo },
  );
  const onlineDeadline = Date.now() + ONLINE_VERIFY_TIMEOUT;
  let nextRefreshAt = Date.now() + 5000;
  while (Date.now() < onlineDeadline) {
    await nativeDialogGuard.drain();
    const currentRecorderState = await read1688RecorderState(
      dropshipMatch.frame,
    ).catch(() => null);
    if (currentRecorderState) {
      latestRecorderState = currentRecorderState;
      if (currentRecorderState.records.length) {
        latestAsyncRecords = currentRecorderState.records;
      }
    }
    const submission = inspect1688SubmissionRecords(latestAsyncRecords);
    if (submission.state === "rejected") {
      logInternalError(
        new Error(
          `1688 submission was rejected: ${submission.reason}`,
        ),
        `1688-submit-${purchaseOrderNo}`,
      );
      throw new Error("1688 submission was rejected");
    }
    if (submission.state === "accepted") {
      submissionAccepted = true;
      if (!submissionAcceptedReported) {
        submissionAcceptedReported = true;
        report(
          "supplier.1688.submission.accepted",
          "ERP已确认接收1688下单请求",
          "completed",
          { purchase_order_no: purchaseOrderNo },
        );
      }
    }
    const recordedSuccess = exact1688SuccessMessage(
      latestRecorderState.messages,
      purchaseOrderNo,
    );
    if (submissionAccepted && recordedSuccess) {
      await closeVisibleEpaasDialogs().catch(() => {});
      report(
        "supplier.1688.dialog.success",
        "ERP已确认目标采购单下单成功",
        "completed",
        { purchase_order_no: purchaseOrderNo },
      );
      report(
        "supplier.1688.verify.completed",
        "ERP后端回执和目标采购单成功提示复核通过",
        "completed",
        { purchase_order_no: purchaseOrderNo },
      );
      report(
        "supplier.1688.order.success",
        "1688一件代发下单完成",
        "completed",
        { purchase_order_no: purchaseOrderNo },
      );
      return {
        onlineOrderNo: "",
        reused: false,
        submissionAcknowledged: true,
        submissionPurchaseOrderNo: purchaseOrderNo,
        completionEvidence: "erp_backend_and_success_dialog",
      };
    }
    rowBody = await readPurchaseRow(purchaseFrame, purchaseOrderNo);
    const verification = verified1688Order(rowBody);
    if (verification.verified) {
      await closeVisibleEpaasDialogs().catch(() => {});
      report(
        "supplier.1688.verify.completed",
        "1688线上单号和下单状态复核通过",
        "completed",
        {
          purchase_order_no: purchaseOrderNo,
          online_1688_order_no: verification.onlineOrderNo,
        },
      );
      report(
        "supplier.1688.order.success",
        "1688一件代发下单完成",
        "completed",
        {
          purchase_order_no: purchaseOrderNo,
          online_1688_order_no: verification.onlineOrderNo,
        },
      );
      return {
        onlineOrderNo: verification.onlineOrderNo,
        reused: false,
      };
    }
    let confirmation;
    for (const candidate of page.frames()) {
      if (!(await frameChainVisible(candidate).catch(() => false))) continue;
      const controls = await firstVisible(
        candidate.locator("#confirm_confirm"),
      );
      if (!controls.length) continue;
      if (controls.length > 1 || confirmation) {
        throw new Error("1688 confirmation control is ambiguous");
      }
      confirmation = { frame: candidate, item: controls[0] };
    }
    if (confirmation) {
      report(
        "supplier.1688.confirm.started",
        "正在确认1688下单弹窗",
        "started",
        { purchase_order_no: purchaseOrderNo },
      );
      confirmationTexts.push(
        clean(
          await confirmation.frame.locator("body").innerText().catch(() => ""),
          1000,
        ),
      );
      await confirmation.item.click();
      report(
        "supplier.1688.confirm.completed",
        "1688下单确认已提交",
        "completed",
        { purchase_order_no: purchaseOrderNo },
      );
      await purchaseFrame.waitForTimeout(900);
      continue;
    }
    let visibleDialog = false;
    let visibleDialogBody = "";
    let clickedDialog = false;
    for (const candidate of page.frames()) {
      if (
        !candidate.url().includes("/epaas-dialog-frame.html") ||
        !(await frameChainVisible(candidate).catch(() => false))
      ) {
        continue;
      }
      visibleDialog = true;
      const body = clean(
        await candidate.locator("body").innerText().catch(() => ""),
        1000,
      );
      visibleDialogBody = body;
      if (body) confirmationTexts.push(body);
      const dialogReportsSuccess = /下单成功/.test(body);
      if (
        dialogReportsSuccess &&
        !body.includes(String(purchaseOrderNo))
      ) {
        throw new Error("1688 success dialog purchase number mismatch");
      }
      const labels = dialogReportsSuccess
        ? ["关闭", "确定", "确认"]
        : ["确认并继续", "确认", "确定", "继续"];
      for (const label of labels) {
        const controls = await firstVisible(
          candidate.getByText(label, { exact: true }),
        );
        if (controls.length === 1) {
          await controls[0].click({ force: true });
          clickedDialog = true;
          break;
        }
      }
      if (clickedDialog) break;
    }
    if (visibleDialog) {
      if (clickedDialog) {
        report(
          "supplier.1688.dialog.closed",
          "1688下单结果弹窗已确认",
          "completed",
          { purchase_order_no: purchaseOrderNo },
        );
      }
      if (clickedDialog && /下单成功/.test(visibleDialogBody)) {
        const currentRecorderState = await read1688RecorderState(
          dropshipMatch.frame,
        ).catch(() => null);
        if (currentRecorderState) {
          latestRecorderState = currentRecorderState;
          if (currentRecorderState.records.length) {
            latestAsyncRecords = currentRecorderState.records;
          }
        }
        const dialogSubmission =
          inspect1688SubmissionRecords(latestAsyncRecords);
        if (dialogSubmission.state === "rejected") {
          logInternalError(
            new Error(
              `1688 submission was rejected: ${dialogSubmission.reason}`,
            ),
            `1688-submit-${purchaseOrderNo}`,
          );
          throw new Error("1688 submission was rejected");
        }
        if (dialogSubmission.state === "accepted") {
          submissionAccepted = true;
          if (!submissionAcceptedReported) {
            submissionAcceptedReported = true;
            report(
              "supplier.1688.submission.accepted",
              "ERP已确认接收1688下单请求",
              "completed",
              { purchase_order_no: purchaseOrderNo },
            );
          }
          report(
            "supplier.1688.dialog.success",
            "ERP已确认目标采购单下单成功",
            "completed",
            { purchase_order_no: purchaseOrderNo },
          );
          report(
            "supplier.1688.verify.completed",
            "ERP后端回执和目标采购单成功弹窗复核通过",
            "completed",
            { purchase_order_no: purchaseOrderNo },
          );
          report(
            "supplier.1688.order.success",
            "1688一件代发下单完成",
            "completed",
            { purchase_order_no: purchaseOrderNo },
          );
          return {
            onlineOrderNo: "",
            reused: false,
            submissionAcknowledged: true,
            submissionPurchaseOrderNo: purchaseOrderNo,
            completionEvidence: "erp_backend_and_success_dialog",
          };
        }
        report(
          "supplier.1688.dialog.success",
          "ERP已提示下单成功，正在核对后端下单回执",
          "completed",
          { purchase_order_no: purchaseOrderNo },
        );
      }
      if (
        clickedDialog &&
        !/下单成功/.test(visibleDialogBody) &&
        /失败|错误|无法|不能为空|已下架|库存不足|不支持|异常/.test(
          visibleDialogBody,
        )
      ) {
        logInternalError(
          new Error(
            `1688 submission was rejected: ${visibleDialogBody}`,
          ),
          `1688-submit-${purchaseOrderNo}`,
        );
        throw new Error("1688 submission was rejected");
      }
      await purchaseFrame.waitForTimeout(clickedDialog ? 900 : 500);
      continue;
    }
    if (Date.now() >= nextRefreshAt) {
      const searchControls = await firstVisible(
        purchaseFrame.getByText("搜索", { exact: true }),
      );
      if (searchControls.length === 1) {
        await searchControls[0].click().catch(() => {});
        await purchaseFrame.waitForTimeout(1200);
      }
      nextRefreshAt = Date.now() + 5000;
      continue;
    }
    await purchaseFrame.waitForTimeout(400);
  }
  rowBody = await readPurchaseRow(purchaseFrame, purchaseOrderNo).catch(
    () => "",
  );
  const finalVerification = verified1688Order(rowBody);
  if (finalVerification.verified) {
    report(
      "supplier.1688.verify.completed",
      "1688线上单号和下单状态复核通过",
      "completed",
      {
        purchase_order_no: purchaseOrderNo,
        online_1688_order_no: finalVerification.onlineOrderNo,
      },
    );
    report(
      "supplier.1688.order.success",
      "1688一件代发下单完成",
      "completed",
      {
        purchase_order_no: purchaseOrderNo,
        online_1688_order_no: finalVerification.onlineOrderNo,
      },
    );
    return {
      onlineOrderNo: finalVerification.onlineOrderNo,
      reused: false,
    };
  }
  const finalSubmission =
    inspect1688SubmissionRecords(latestAsyncRecords);
  if (finalSubmission.state === "rejected") {
    logInternalError(
      new Error(
        `1688 submission was rejected: ${finalSubmission.reason}`,
      ),
      `1688-submit-${purchaseOrderNo}`,
    );
    throw new Error("1688 submission was rejected");
  }
  submissionAccepted =
    submissionAccepted ||
    finalSubmission.state === "accepted" ||
    confirmationTexts.some((text) => /下单成功/.test(text));
  const existingOnlineOrderNotice = [
    ...confirmationTexts,
    ...(latestRecorderState.messages || []).map(
      (item) => item?.message || item?.text || "",
    ),
  ].some((text) => /已经存在线上订单号/.test(String(text || "")));
  if (existingOnlineOrderNotice) {
    report(
      "supplier.1688.already_completed",
      "ERP确认该采购单已存在线上订单，无需重复下单",
      "skipped",
      { purchase_order_no: purchaseOrderNo },
    );
    report(
      "supplier.1688.order.success",
      "1688一件代发订单已存在，本次未重复创建",
      "completed",
      { purchase_order_no: purchaseOrderNo },
    );
    return {
      onlineOrderNo: "",
      reused: true,
      submissionAcknowledged: true,
      submissionPurchaseOrderNo: purchaseOrderNo,
      completionEvidence: "erp_existing_online_order_notice",
    };
  }
  if (!submissionAccepted) {
    logInternalError(
      new Error(
          `1688 submission confirmation was not received; ` +
          `async_records=${JSON.stringify(
            latestAsyncRecords,
          ).slice(0, 3000)}; ` +
          `confirmations=${JSON.stringify(
            latestRecorderState.confirmations,
          ).slice(0, 2000)}; ` +
          `messages=${JSON.stringify(
            latestRecorderState.messages,
          ).slice(0, 2000)}; ` +
          `dialogs=${JSON.stringify(confirmationTexts).slice(0, 2000)}`,
      ),
      `1688-submit-${purchaseOrderNo}`,
    );
    throw new Error("1688 submission confirmation was not received");
  }
  report(
    "supplier.1688.verify.deferred",
    "1688下单已提交，转入整批复核队列",
    "waiting",
    { purchase_order_no: purchaseOrderNo },
  );
  return {
    onlineOrderNo: "",
    reused: false,
    verificationPending: true,
  };
  } finally {
    nativeDialogGuard.stop();
    await nativeDialogGuard.drain().catch(() => {});
  }
}

async function applySingle(orderFrame, order, report) {
  report(
    "order.recheck.started",
    "正在做执行前二次校验",
    "started",
  );
  const preflight = await inspectSingleOrder(orderFrame, order, report);
  report(
    "order.recheck.completed",
    "执行前二次校验已完成",
    "completed",
  );
  if (preflight.state === "resume_purchase") {
    const purchaseOrderNo = clean(preflight.purchase_order_no, 40);
    report(
      "purchase.resume.detail.started",
      "正在打开订单详情核对现有采购单号",
      "started",
      { purchase_order_no: purchaseOrderNo },
    );
    let detailFrame = null;
    let verifiedPurchaseNo = "";
    const maxVerificationAttempts = 5;
    for (
      let attempt = 1;
      attempt <= maxVerificationAttempts;
      attempt += 1
    ) {
      const orderLocator = await searchOrder(orderFrame, order.order_id);
      detailFrame = await openOrderDetail(
        orderFrame,
        orderLocator,
        order.order_id,
      );
      const detail = await waitForOrderDetailPurchase(
        detailFrame,
        purchaseOrderNo,
        12000,
      );
      verifiedPurchaseNo = clean(detail.purchaseOrderNo, 40);
      if (verifiedPurchaseNo === purchaseOrderNo) break;
      if (verifiedPurchaseNo || attempt === maxVerificationAttempts) break;
      await closeOrderDetail(detailFrame);
      detailFrame = null;
      report(
        "purchase.resume.detail.retry",
        "采购单号尚未加载，正在重新打开订单详情核对",
        "started",
        {
          purchase_order_no: purchaseOrderNo,
          attempt: attempt + 1,
          max_attempts: maxVerificationAttempts,
        },
      );
      await orderFrame.waitForTimeout(1000);
    }
    if (!verifiedPurchaseNo) {
      logInternalError(
        new Error(
          `Existing purchase number was not loaded expected=${purchaseOrderNo} ` +
            `url=${detailFrame?.url() || "CLOSED"}`,
        ),
        `purchase-number-${clean(order.order_id, 40)}`,
      );
      throw new Error("Existing purchase number was not loaded");
    }
    if (verifiedPurchaseNo !== purchaseOrderNo) {
      logInternalError(
        new Error(
          `Existing purchase number verification failed expected=${purchaseOrderNo} ` +
            `actual=${verifiedPurchaseNo} url=${detailFrame?.url() || "CLOSED"}`,
        ),
        `purchase-number-${clean(order.order_id, 40)}`,
      );
      throw new Error("Existing purchase number verification failed");
    }
    report(
      "purchase.resume.number.verified",
      "现有采购单号核对通过",
      "completed",
      { purchase_order_no: purchaseOrderNo },
    );
    report(
      "purchase.management.open.started",
      "正在进入采购单管理页面",
      "started",
      { purchase_order_no: purchaseOrderNo },
    );
    const purchaseFrame = await openPurchaseFromDetail(
      detailFrame,
      purchaseOrderNo,
    );
    report(
      "purchase.management.open.completed",
      "采购单管理页面已打开",
      "completed",
      { purchase_order_no: purchaseOrderNo },
    );
    await auditPurchase(purchaseFrame, purchaseOrderNo, report);
    const placement = await place1688Order(
      purchaseFrame,
      purchaseOrderNo,
      order,
      report,
    );
    const onlineOrderNo = placement.onlineOrderNo;
    if (placement.submissionAcknowledged) {
      return {
        order_id: order.order_id,
        state: "completed",
        purchase_order_no: purchaseOrderNo,
        online_1688_order_no: "",
        submission_acknowledged: true,
        submission_purchase_order_no:
          placement.submissionPurchaseOrderNo,
        completion_evidence: placement.completionEvidence,
        message: "完成",
      };
    }
    if (placement.verificationPending) {
      return {
        order_id: order.order_id,
        state: "verification_pending",
        purchase_order_no: purchaseOrderNo,
        online_1688_order_no: "",
        message: "已提交1688下单，等待整批复核",
      };
    }
    if (!/^\d{16,30}$/.test(onlineOrderNo)) {
      throw new Error("1688 online order verification failed");
    }
    return {
      order_id: order.order_id,
      state: "completed",
      purchase_order_no: purchaseOrderNo,
      online_1688_order_no: onlineOrderNo,
      message: "完成",
    };
  }
  if (preflight.state !== "ready") {
    return {
      order_id: order.order_id,
      state: "skipped",
      safe_to_continue: true,
      purchase_order_no: preflight.purchase_order_no || "",
      message:
        preflight.state === "already_processed"
          ? "已存在无法安全识别单号的采购记录，已阻止重复执行"
          : preflight.message || "二次校验未通过",
    };
  }
  let orderLocator = await searchOrder(orderFrame, order.order_id);
  report("address.detail.open.started", "正在打开订单详情修改收货地址", "started");
  let detailFrame = await openOrderDetail(
    orderFrame,
    orderLocator,
    order.order_id,
  );
  report("address.detail.open.completed", "收货地址编辑页面已打开", "completed");
  await fillAndSaveAddress(detailFrame, order, report);
  await closeOrderDetail(detailFrame);
  report("address.detail.closed", "收货地址编辑页面已关闭", "completed");
  await verifyPersistedOrderAddress(orderFrame, order, report);

  orderLocator = await searchOrder(orderFrame, order.order_id);
  await generatePurchaseOrder(orderFrame, orderLocator, report);

  report(
    "purchase.number.detail.started",
    "正在打开订单详情读取生成采购单号",
    "started",
  );
  let purchaseOrderNo = "";
  const maxPurchaseNumberAttempts = 5;
  for (
    let attempt = 1;
    attempt <= maxPurchaseNumberAttempts;
    attempt += 1
  ) {
    orderLocator = await searchOrder(orderFrame, order.order_id);
    detailFrame = await openOrderDetail(
      orderFrame,
      orderLocator,
      order.order_id,
    );
    const detail = await waitForOrderDetailPurchase(
      detailFrame,
      "",
      15000,
    );
    purchaseOrderNo = clean(detail.purchaseOrderNo, 40);
    if (purchaseOrderNo) break;
    await closeOrderDetail(detailFrame);
    detailFrame = null;
    if (attempt < maxPurchaseNumberAttempts) {
      report(
        "purchase.number.detail.retry",
        "采购单号尚未回写，正在重新打开订单详情读取",
        "started",
        {
          attempt: attempt + 1,
          max_attempts: maxPurchaseNumberAttempts,
        },
      );
      await orderFrame.waitForTimeout(1500);
    }
  }
  if (!purchaseOrderNo) throw new Error("Generated purchase number was not found");
  report(
    "purchase.number.read",
    "已从订单操作日志读取采购单号",
    "completed",
    { purchase_order_no: purchaseOrderNo },
  );
  report(
    "purchase.management.open.started",
    "正在进入采购单管理页面",
    "started",
    { purchase_order_no: purchaseOrderNo },
  );
  const purchaseFrame = await openPurchaseFromDetail(
    detailFrame,
    purchaseOrderNo,
  );
  report(
    "purchase.management.open.completed",
    "采购单管理页面已打开",
    "completed",
    { purchase_order_no: purchaseOrderNo },
  );
  await auditPurchase(purchaseFrame, purchaseOrderNo, report);
  const placement = await place1688Order(
    purchaseFrame,
    purchaseOrderNo,
    order,
    report,
  );
  const onlineOrderNo = placement.onlineOrderNo;
  if (placement.submissionAcknowledged) {
    return {
      order_id: order.order_id,
      state: "completed",
      purchase_order_no: purchaseOrderNo,
      online_1688_order_no: "",
      submission_acknowledged: true,
      submission_purchase_order_no:
        placement.submissionPurchaseOrderNo,
      completion_evidence: placement.completionEvidence,
      message: "完成",
    };
  }
  if (placement.verificationPending) {
    return {
      order_id: order.order_id,
      state: "verification_pending",
      purchase_order_no: purchaseOrderNo,
      online_1688_order_no: "",
      message: "已提交1688下单，等待整批复核",
    };
  }
  if (!/^\d{16,30}$/.test(onlineOrderNo)) {
    throw new Error("1688 online order verification failed");
  }
  return {
    order_id: order.order_id,
    state: "completed",
    purchase_order_no: purchaseOrderNo,
    online_1688_order_no: onlineOrderNo,
    message: "完成",
  };
}

async function read1688VerificationForOrder(result) {
  const orderId = clean(result.order_id, 40);
  const expectedPurchaseOrderNo = clean(result.purchase_order_no, 40);
  await resetToOrderList();
  const orderFrame = await openOrderList();
  const orderLocator = await searchOrder(orderFrame, orderId);
  if (!orderLocator) throw new Error("Verification order was not found");
  const detailFrame = await openOrderDetail(
    orderFrame,
    orderLocator,
    orderId,
  );
  const detail = await waitForOrderDetailPurchase(
    detailFrame,
    expectedPurchaseOrderNo,
    15000,
  );
  const actualPurchaseOrderNo = clean(detail.purchaseOrderNo, 40);
  if (actualPurchaseOrderNo !== expectedPurchaseOrderNo) {
    throw new Error("Verification purchase number mismatch");
  }
  const purchaseFrame = await openPurchaseFromDetail(
    detailFrame,
    expectedPurchaseOrderNo,
  );
  const rowBody = await readPurchaseRow(
    purchaseFrame,
    expectedPurchaseOrderNo,
  );
  return verified1688Order(rowBody);
}

async function reconcile1688Order(payload) {
  const orderId = clean(payload.order_id, 40);
  const purchaseOrderNo = clean(payload.purchase_order_no, 60);
  if (!/^\d{12,30}$/.test(orderId) || !purchaseOrderNo) {
    throw new Error("Reconciliation order identity is invalid");
  }
  writeProgress({
    phase: "reconcile",
    current_order_id: orderId,
    step_code: "supplier.1688.background_verify.started",
    step_state: "started",
    message: "正在后台补录1688线上单号",
    purchase_order_no: purchaseOrderNo,
    online_1688_order_no: "",
  });
  const auth = await ensureLoggedIn();
  if (auth.status !== "ok") {
    return {
      ...auth,
      order_id: orderId,
      purchase_order_no: purchaseOrderNo,
      verified: false,
      online_1688_order_no: "",
    };
  }
  const verification = await read1688VerificationForOrder({
    order_id: orderId,
    purchase_order_no: purchaseOrderNo,
  });
  writeProgress({
    phase: "reconcile",
    current_order_id: orderId,
    step_code: verification.verified
      ? "supplier.1688.background_verify.completed"
      : "supplier.1688.background_verify.waiting",
    step_state: verification.verified ? "completed" : "waiting",
    message: verification.verified
      ? "1688线上单号已补录"
      : "1688线上单号尚未回写，稍后继续复核",
    purchase_order_no: purchaseOrderNo,
    online_1688_order_no: verification.onlineOrderNo || "",
  });
  return {
    status: "ok",
    order_id: orderId,
    purchase_order_no: purchaseOrderNo,
    verified: verification.verified,
    online_1688_order_no: verification.onlineOrderNo || "",
  };
}

async function verifyPending1688Orders(
  results,
  progressOffset,
  progressTotal,
) {
  let pending = results.filter(
    (result) => result.state === "verification_pending",
  );
  if (!pending.length) return;
  writeProgress({
    phase: "apply",
    completed: progressOffset + results.length - pending.length,
    total: progressTotal,
    current_order_id: "",
    step_code: "supplier.1688.batch_verify.started",
    step_state: "started",
    message: `整批提交完成，开始复核 ${pending.length} 条1688线上单号`,
    purchase_order_no: "",
    online_1688_order_no: "",
  });
  const deadline = Date.now() + BATCH_VERIFY_TIMEOUT;
  let attempt = 0;
  while (
    pending.length &&
    Date.now() < deadline &&
    attempt < BATCH_VERIFY_MAX_ATTEMPTS
  ) {
    attempt += 1;
    for (const result of [...pending]) {
      if (Date.now() >= deadline) break;
      writeProgress({
        phase: "apply",
        completed: progressOffset + results.filter(
          (item) => item.state === "completed",
        ).length,
        total: progressTotal,
        current_order_id: clean(result.order_id, 40),
        step_code: "supplier.1688.batch_verify.order.started",
        step_state: "started",
        message: `正在进行第 ${attempt} 轮1688线上单号复核`,
        purchase_order_no: clean(result.purchase_order_no, 60),
        online_1688_order_no: "",
      });
      let verification = { onlineOrderNo: "", verified: false };
      try {
        verification = await read1688VerificationForOrder(result);
      } catch (error) {
        logInternalError(
          error,
          `batch-verify-${clean(result.order_id, 40)}`,
        );
      }
      if (verification.verified) {
        result.state = "completed";
        result.online_1688_order_no = verification.onlineOrderNo;
        result.message = "完成";
        writeProgress({
          phase: "apply",
          completed: progressOffset + results.filter(
            (item) => item.state === "completed",
          ).length,
          total: progressTotal,
          current_order_id: clean(result.order_id, 40),
          step_code: "supplier.1688.batch_verify.order.completed",
          step_state: "completed",
          message: "1688线上单号和下单状态复核通过",
          purchase_order_no: clean(result.purchase_order_no, 60),
          online_1688_order_no: verification.onlineOrderNo,
        });
      } else {
        writeProgress({
          phase: "apply",
          completed: progressOffset + results.filter(
            (item) => item.state === "completed",
          ).length,
          total: progressTotal,
          current_order_id: clean(result.order_id, 40),
          step_code: "supplier.1688.batch_verify.order.waiting",
          step_state: "waiting",
          message: "1688线上单号尚未回写，稍后继续自动复核",
          purchase_order_no: clean(result.purchase_order_no, 60),
          online_1688_order_no: "",
        });
      }
    }
    pending = results.filter(
      (result) => result.state === "verification_pending",
    );
    if (pending.length && Date.now() < deadline) {
      await new Promise((resolve) =>
        setTimeout(resolve, BATCH_VERIFY_POLL_INTERVAL),
      );
    }
  }
  for (const result of pending) {
    result.state = "stopped";
    result.message = "1688线上单号暂未确认，本单已停止并转后续核对";
    writeProgress({
      phase: "apply",
      completed: progressOffset + results.filter(
        (item) => item.state === "completed",
      ).length,
      total: progressTotal,
      current_order_id: clean(result.order_id, 40),
      step_code: "supplier.1688.batch_verify.order.failed",
      step_state: "failed",
      message: result.message,
      purchase_order_no: clean(result.purchase_order_no, 60),
      online_1688_order_no: "",
    });
  }
  writeProgress({
    phase: "apply",
    completed: progressOffset + results.filter(
      (item) => item.state === "completed",
    ).length,
    total: progressTotal,
    current_order_id: "",
    step_code: pending.length
      ? "supplier.1688.batch_verify.failed"
      : "supplier.1688.batch_verify.completed",
    step_state: pending.length ? "failed" : "completed",
    message: pending.length
      ? `整批复核结束，${pending.length} 条未通过`
      : "整批1688线上单号复核全部通过",
    purchase_order_no: "",
    online_1688_order_no: "",
  });
}

async function applyBatch(payload) {
  writeProgress({
    phase: "apply",
    step_code: "auth.check.started",
    step_state: "started",
    message: "正在检查 ERP 登录状态",
  });
  const auth = await ensureLoggedIn();
  if (auth.status !== "ok") {
    writeProgress({
      phase: "apply",
      step_code: "auth.check.waiting",
      step_state: "waiting",
      message: "ERP 登录等待短信验证码",
    });
    return auth;
  }
  writeProgress({
    phase: "apply",
    step_code: "auth.check.completed",
    step_state: "completed",
    message: "ERP 登录状态正常",
  });
  writeProgress({
    phase: "apply",
    step_code: "order.list.open.started",
    step_state: "started",
    message: "正在打开订单列表",
  });
  let orderFrame = await openOrderList();
  writeProgress({
    phase: "apply",
    step_code: "order.list.open.completed",
    step_state: "completed",
    message: "订单列表已就绪",
  });
  const results = [];
  const inputOrders = payload.orders || [];
  const progressOffset = Number(payload.progress_offset || 0);
  const progressTotal = Number(
    payload.progress_total || inputOrders.length,
  );
  for (let index = 0; index < inputOrders.length; index += 1) {
    const order = inputOrders[index];
    const orderContext = {
      purchase_order_no: "",
      online_1688_order_no: "",
    };
    const report = (
      stepCode,
      message,
      stepState = "started",
      extra = {},
    ) => {
      orderContext.last_step_code = stepCode;
      if (stepMayHaveChangedExternalState(stepCode)) {
        orderContext.external_state_may_have_changed = true;
      }
      if (SUBMISSION_RISK_STEPS.has(stepCode)) {
        orderContext.submission_may_have_started = true;
      }
      if (extra.purchase_order_no) {
        orderContext.purchase_order_no = clean(
          extra.purchase_order_no,
          60,
        );
      }
      if (extra.online_1688_order_no) {
        orderContext.online_1688_order_no = clean(
          extra.online_1688_order_no,
          80,
        );
      }
      writeProgress({
        phase: "apply",
        completed: progressOffset + index,
        total: progressTotal,
        order_index: progressOffset + index + 1,
        order_total: progressTotal,
        current_order_id: clean(order.order_id, 40),
        step_code: stepCode,
        step_state: stepState,
        message,
        purchase_order_no: orderContext.purchase_order_no,
        online_1688_order_no: orderContext.online_1688_order_no,
        ...extra,
      });
    };
    try {
      report("order.apply.started", "开始处理当前订单", "started");
      const result = await applySingle(orderFrame, order, report);
      results.push(result);
      writeProgress({
        phase: "apply",
        completed: progressOffset + index + 1,
        total: progressTotal,
        order_index: progressOffset + index + 1,
        order_total: progressTotal,
        current_order_id: clean(order.order_id, 40),
        step_code:
          result.state === "completed"
            ? "order.apply.completed"
            : result.state === "verification_pending"
              ? "order.apply.awaiting_verification"
            : "order.apply.skipped",
        step_state:
          result.state === "completed"
            ? "completed"
            : result.state === "verification_pending"
              ? "waiting"
              : "skipped",
        message:
          result.state === "verification_pending"
            ? "当前订单已提交，继续处理下一条并在整批结束后复核"
            : result.state === "skipped" && result.safe_to_continue
              ? "当前订单已安全跳过，继续处理后续订单"
              : "当前订单处理完成",
        purchase_order_no: clean(result.purchase_order_no, 60),
        online_1688_order_no: clean(
          result.online_1688_order_no,
          80,
        ),
      });
      if (
        !["completed", "verification_pending"].includes(result.state) &&
        !(result.state === "skipped" && result.safe_to_continue)
      ) {
        return { status: "stopped", orders: results };
      }
      if (index < inputOrders.length - 1) {
        report(
          "browser.recycle.started",
          "正在复位浏览器以处理下一条订单",
          "started",
          { completed: progressOffset + index + 1 },
        );
        await recycleBrowserToOrderList();
        report(
          "browser.recycle.completed",
          "浏览器已回到订单列表",
          "completed",
          { completed: progressOffset + index + 1 },
        );
        orderFrame = await openOrderList();
      }
    } catch (error) {
      logInternalError(error, `apply-${clean(order.order_id, 40)}`);
      const explicitlySafe = error?.safeToContinue === true;
      const verificationPending = Boolean(
        orderContext.submission_may_have_started &&
          orderContext.purchase_order_no,
      );
      const needsManualReview = Boolean(
        verificationPending ||
          orderContext.external_state_may_have_changed ||
          orderContext.purchase_order_no,
      );
      const failureMessage = publicFailure(
        error,
        explicitlySafe && !needsManualReview
          ? "当前订单保存前校验未通过，已跳过并继续后续订单"
          : verificationPending
            ? "当前订单的1688提交结果不明确，已转入待复核；后续订单继续处理"
            : needsManualReview
              ? "当前订单执行异常，已隔离待人工复核；后续订单继续处理"
              : "当前订单执行异常，已跳过并继续后续订单",
      );
      report(
        verificationPending
          ? "order.apply.awaiting_verification"
          : "order.apply.skipped",
        failureMessage,
        verificationPending ? "waiting" : "skipped",
      );
      results.push({
        order_id: clean(order.order_id, 40),
        state: verificationPending ? "verification_pending" : "skipped",
        safe_to_continue: true,
        needs_manual_review: needsManualReview,
        retry_automatically: false,
        purchase_order_no: orderContext.purchase_order_no,
        online_1688_order_no: orderContext.online_1688_order_no,
        message: failureMessage,
      });
      if (index < inputOrders.length - 1) {
        report(
          "browser.recycle.started",
          "正在复位浏览器以处理下一条订单",
          "started",
          { completed: progressOffset + index + 1 },
        );
        try {
          await recycleBrowserToOrderList();
          report(
            "browser.recycle.completed",
            "浏览器已回到订单列表",
            "completed",
            { completed: progressOffset + index + 1 },
          );
          orderFrame = await openOrderList();
        } catch (recycleError) {
          logInternalError(
            recycleError,
            `recycle-${clean(order.order_id, 40)}`,
          );
          report(
            "browser.recycle.failed",
            "浏览器复位失败，当前工作器无法继续后续订单",
            "failed",
            { completed: progressOffset + index + 1 },
          );
          return { status: "stopped", orders: results };
        }
      }
      continue;
    }
  }
  await verifyPending1688Orders(
    results,
    progressOffset,
    progressTotal,
  );
  return {
    status: results.every((result) => result.state === "completed")
      ? "ok"
      : results.every(
            (result) =>
              result.state === "completed" ||
              (result.state === "skipped" && result.safe_to_continue),
          )
        ? "partial"
        : "stopped",
    orders: results,
  };
}

async function handleRequest(request) {
  const action = clean(request.action, 40);
  const payload = request.payload || {};
  if (action === "warmup") {
    const result = await warmBrowserAtOrderList();
    result.browser_code = BROWSER_CODE;
    return result;
  }
  if (action === "debug_additional") {
    return debugAdditionalControls(payload);
  }
  if (action === "inspect_purchase") {
    return inspectPurchaseForOrder(payload);
  }
  if (action === "inspect_audit") {
    return inspectAuditForOrder(payload);
  }
  if (action === "inspect_purchase_no") {
    return inspectAuditForPurchase(payload);
  }
  if (action === "inspect_1688_nav") {
    return inspect1688Navigation(payload);
  }
  if (action === "inspect_row") {
    return inspectOrderRow(payload);
  }
  if (
    action === "inspect" ||
    action === "apply" ||
    action === "reconcile"
  ) {
    const result =
      action === "inspect"
        ? await inspectBatch(payload)
        : action === "apply"
          ? await applyBatch(payload)
          : await reconcile1688Order(payload);
    result.browser_code = BROWSER_CODE;
    if (result.status !== "needs_sms") {
      try {
        writeProgress({
          phase: action,
          current_order_id: "",
          order_index: 0,
          step_code: "browser.reset.started",
          step_state: "started",
          message: "正在关闭多余窗口并复位到订单页面",
        });
        const continuesToApply =
          action === "inspect" &&
          clean(result.status, 20) === "ok" &&
          (result.orders || []).some((row) =>
            ["ready", "resume_purchase"].includes(clean(row.state, 30)),
          );
        if (continuesToApply) {
          await resetToOrderList();
        } else {
          await recycleBrowserToOrderList();
        }
        result.browser_reset = "order_list";
        writeProgress({
          phase: action,
          current_order_id: "",
          order_index: 0,
          step_code: "browser.reset.completed",
          step_state: "completed",
          message: "浏览器已复位到订单页面并可接收下一任务",
        });
      } catch (error) {
        logInternalError(error, "reset");
        writeProgress({
          phase: action,
          current_order_id: "",
          order_index: 0,
          step_code: "browser.reset.failed",
          step_state: "failed",
          message: "浏览器复位失败，需要重新初始化该浏览器",
        });
        result.status = result.status === "ok" ? "stopped" : result.status;
        result.message =
          result.message ||
          "任务已停止，浏览器未能复位到订单页面，需人工检查后再接新任务。";
        result.browser_reset = "failed";
      }
    }
    return result;
  }
  if (action === "close") {
    await context?.close().catch(() => {});
    process.exit(0);
  }
  return { status: "error", message: "未知 ERP 操作" };
}

function writeResponse(response) {
  process.stdout.write(
    `${JSON.stringify({ type: "result", result: response })}\n`,
  );
}

function writeProgress(progress) {
  process.stdout.write(
    `${JSON.stringify({
      type: "progress",
      browser_code: BROWSER_CODE,
      ...progress,
    })}\n`,
  );
}

const input = readline.createInterface({
  input: process.stdin,
  crlfDelay: Infinity,
});

input.on("line", async (line) => {
  let request;
  try {
    request = JSON.parse(line);
  } catch {
    writeResponse({ status: "error", message: "请求格式错误" });
    return;
  }
  try {
    const result = await handleRequest(request);
    writeResponse(result);
  } catch (error) {
    logInternalError(error, clean(request?.action, 20) || "request");
    writeResponse({
      status: "error",
      message: publicFailure(error, "ERP 操作失败，未继续执行"),
    });
  }
});

process.on("SIGTERM", async () => {
  await context?.close().catch(() => {});
  process.exit(0);
});