#!/usr/bin/env node

import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
import { dirname, resolve } from 'node:path';

const DEFAULT_PORT = process.env.LWLT_CDP_PORT || '9223';

function parseArgs(argv) {
  const args = { _: [] };
  for (let i = 0; i < argv.length; i += 1) {
    const arg = argv[i];
    if (!arg.startsWith('--')) {
      args._.push(arg);
      continue;
    }
    const key = arg.slice(2);
    const next = argv[i + 1];
    if (!next || next.startsWith('--')) args[key] = true;
    else {
      args[key] = next;
      i += 1;
    }
  }
  return args;
}

function usage() {
  return [
    'Usage:',
    '  node tools/browser_order_add_raw_instruction_test.mjs --input samples/raw_instruction_team_order_20260811.json --open-form --intercept-submit --out reports/raw-instruction.json',
    '',
    'Options:',
    `  --port <number>          Chrome DevTools port. Default: ${DEFAULT_PORT}`,
    '  --input <path>           Parsed raw-instruction JSON.',
    '  --open-form              Navigate the LTJT main iframe to a fresh orders_add.asp form first.',
    '  --intercept-submit       Call SubmitInfoForm() with DoInfoJH AJAX intercepted before network.',
    '  --out <path>             Write redacted raw-instruction preflight report.',
    '  --approved-preflight-out <path>  Write a browser_preflight_passed-compatible redacted report.',
    '  --approved-intercept-out <path>  Write a submit_intercept_captured-compatible redacted report.',
    '  --help                   Show this help.',
    '',
    'This tool derives route/customer/trip/order-prefix from the chosen product template in the browser, validates linked choices, fills obvious test markers, and never lets DoInfoJH reach the network.'
  ].join('\n');
}

function readJson(path) {
  return JSON.parse(readFileSync(path, 'utf8'));
}

function writeJson(path, data) {
  mkdirSync(dirname(resolve(path)), { recursive: true });
  writeFileSync(path, `${JSON.stringify(data, null, 2)}\n`);
}

function isBlank(value) {
  return value == null || String(value).trim() === '';
}

function toNumber(value, fallback = 0) {
  const num = Number(value);
  return Number.isFinite(num) ? num : fallback;
}

function dateYyyyMD(value) {
  if (typeof value !== 'string') return value;
  const match = value.match(/^(\d{4})-(\d{1,2})-(\d{1,2})$/);
  if (!match) return value;
  return `${match[1]}-${Number(match[2])}-${Number(match[3])}`;
}

function passengerTotal(counts = {}) {
  return ['adult', 'child_bed', 'child_no_bed', 'infant', 'leader']
    .reduce((sum, key) => sum + Math.max(0, Math.trunc(toNumber(counts[key]))), 0);
}

function roomTotal(roomCounts = {}) {
  return ['SGL', 'TWN', 'TRP', 'DBL', 'HNM', 'TL']
    .reduce((sum, key) => sum + Math.max(0, Math.trunc(toNumber(roomCounts[key]))), 0);
}

function localValidate(operation) {
  const blockers = [];
  const warnings = [];
  const data = operation.data || {};
  const counts = data.passenger_counts || {};
  if (operation.action !== 'team_order_create') blockers.push(`Unsupported action ${operation.action || '<missing>'}; expected team_order_create.`);
  if (operation.submit_mode !== 'dry_run') blockers.push('submit_mode must be dry_run before the approved live-submit gate.');
  if (operation.order_nature !== 'test') blockers.push('order_nature must be test for this live ERP test workflow.');
  if (data.order_mode !== '团队-单个下单') warnings.push('data.order_mode is not 团队-单个下单; continuing because the target page is the independent group order form.');
  if (isBlank(data.product?.name)) blockers.push('data.product.name is required.');
  if (!Array.isArray(data.departure_dates) || data.departure_dates.length !== 1 || isBlank(data.departure_dates[0])) blockers.push('Exactly one data.departure_dates value is required.');
  if (passengerTotal(counts) <= 0) blockers.push('Passenger total must be greater than zero.');
  if (counts.expected_total != null && Math.trunc(toNumber(counts.expected_total)) !== passengerTotal(counts)) {
    blockers.push(`passenger_counts.expected_total (${counts.expected_total}) does not equal computed total (${passengerTotal(counts)}).`);
  }
  if (roomTotal(data.room_counts || {}) <= 0) warnings.push('Computed room total is zero.');
  if (isBlank(data.op_user?.name)) blockers.push('data.op_user.name is required.');
  if (isBlank(data.sales_user?.name)) blockers.push('data.sales_user.name is required.');
  if (isBlank(data.test_marker)) blockers.push('data.test_marker is required so ERP test data remains obvious.');
  return { blockers, warnings };
}

async function getJson(url) {
  const res = await fetch(url);
  if (!res.ok) throw new Error(`${res.status} ${res.statusText}: ${url}`);
  return res.json();
}

async function getTarget(port) {
  const targets = await getJson(`http://127.0.0.1:${port}/json`);
  const target = targets.find((item) => item.type === 'page' && item.url.includes('ltjt.yunzhi.run'));
  if (!target) throw new Error(`No ltjt.yunzhi.run page target on port ${port}`);
  return target;
}

class CDP {
  constructor(wsUrl) {
    this.wsUrl = wsUrl;
    this.id = 0;
    this.pending = new Map();
  }

  connect() {
    return new Promise((resolve, reject) => {
      this.ws = new WebSocket(this.wsUrl);
      this.ws.onopen = resolve;
      this.ws.onerror = (event) => reject(new Error(event.message || event.type || 'WebSocket error'));
      this.ws.onmessage = (event) => {
        const msg = JSON.parse(event.data);
        if (!msg.id || !this.pending.has(msg.id)) return;
        const { resolve: ok, reject: fail, timer } = this.pending.get(msg.id);
        clearTimeout(timer);
        this.pending.delete(msg.id);
        msg.error ? fail(new Error(msg.error.message)) : ok(msg.result);
      };
    });
  }

  send(method, params = {}, timeoutMs = 30000) {
    const id = ++this.id;
    this.ws.send(JSON.stringify({ id, method, params }));
    return new Promise((resolve, reject) => {
      const timer = setTimeout(() => {
        this.pending.delete(id);
        reject(new Error(`Timeout: ${method}`));
      }, timeoutMs);
      this.pending.set(id, { resolve, reject, timer });
    });
  }

  close() {
    this.ws?.close();
  }
}

async function evaluate(cdp, expression, timeoutMs = 30000) {
  const result = await cdp.send('Runtime.evaluate', {
    expression,
    returnByValue: true,
    awaitPromise: true
  }, timeoutMs);
  if (result.exceptionDetails) {
    const detail = result.exceptionDetails.exception?.description
      || result.exceptionDetails.exception?.value
      || result.exceptionDetails.text
      || 'Runtime.evaluate failed';
    throw new Error(detail);
  }
  return result.result.value;
}

function buildCompatiblePreflightReport(output) {
  const submitPayloadSha256 = output.submit_intercept?.intercepted_submits?.[0]?.payload_sha256 || '';
  return {
    generated_at: new Date().toISOString(),
    status: output.status === 'raw_instruction_test_passed' ? 'browser_preflight_passed' : 'browser_preflight_blocked',
    source: 'browser_order_add_raw_instruction_test',
    source_input: output.source_input,
    page: output.page,
    parsed_instruction: output.parsed_instruction,
    lookup_checks: output.lookup_checks,
    product_side_effect: output.product_side_effect,
    consistency_checks: output.consistency_checks,
    logical_checks: output.logical_checks,
    final_form: {
      ...output.final_form,
      submit_payload_sha256: submitPayloadSha256 || undefined,
      submit_function_mutates_payload: Boolean(submitPayloadSha256 && submitPayloadSha256 !== output.final_form?.serialized_form_sha256)
    },
    blockers: output.blockers || [],
    warnings: output.warnings || [],
    submit_safety: {
      live_submit_attempted: false,
      live_submit_supported_by_this_tool: false,
      note: 'Derived from raw-instruction redacted preflight. The live DoInfoJH request was not sent.'
    },
    test_markers: output.test_markers
  };
}

function buildCompatibleInterceptReport(output) {
  const submitIntercept = output.submit_intercept || {};
  return {
    generated_at: new Date().toISOString(),
    status: submitIntercept.status || 'submit_intercept_blocked',
    source: 'browser_order_add_raw_instruction_test',
    source_input: output.source_input,
    page: output.page,
    intercepted_submit_count: submitIntercept.intercepted_submit_count || 0,
    intercepted_submits: submitIntercept.intercepted_submits || [],
    passthrough_ajax_count: 0,
    alerts: submitIntercept.alerts || [],
    blockers: submitIntercept.status === 'submit_intercept_captured' ? [] : ['raw-instruction submit intercept did not pass'],
    submit_safety: {
      live_submit_attempted: false,
      DoInfoJH_network_prevented: submitIntercept.DoInfoJH_network_prevented === true,
      note: 'Derived from raw-instruction preflight. jQuery.ajax intercepted DoInfoJH before network.'
    },
    test_markers: output.test_markers
  };
}

function browserExpression({ operation, openForm, interceptSubmit }) {
  return `(async () => {
    const operation = ${JSON.stringify(operation)};
    const openForm = ${JSON.stringify(Boolean(openForm))};
    const interceptSubmit = ${JSON.stringify(Boolean(interceptSubmit))};
    const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
    const fabu = operation.data?.system_defaults?.fabudanwei || '老挝联泰';
    const marker = String(operation.data?.test_marker || 'RAWTEST-ERP').trim();
    const markerSuffix = marker + '-' + Date.now();
    const entryUrl = 'https://ltjt.yunzhi.run/System/Business/orders_add.asp?fabudanwei=' + encodeURIComponent(fabu) + '&copy=0&ddid=0&_=' + Date.now();
    const entryStamp = new URL(entryUrl).searchParams.get('_');

    function topState() {
      return { url: location.href, title: document.title };
    }

    function findOrderWindow() {
      const queue = [window];
      while (queue.length) {
        const win = queue.shift();
        let doc;
        try { doc = win.document; } catch (err) { continue; }
        if (doc.querySelector('#ListForm') && doc.location.href.includes('/orders_add.asp')) return win;
        Array.from(win.frames).forEach((frame) => queue.push(frame));
      }
      return null;
    }

    if (/login/i.test(location.href) || /云智办公i-5.1/.test(document.title || '')) {
      return { ok: false, status: 'login_required', blockers: ['login_required'], top: topState() };
    }

    if (openForm) {
      const frame = document.getElementById('Iframe_Home') || document.querySelector('iframe[name="MainIframe"], iframe');
      if (!frame) return { ok: false, status: 'main_iframe_not_found', blockers: ['main_iframe_not_found'], top: topState() };
      frame.src = entryUrl;
    }

    const started = Date.now();
    let orderWin = findOrderWindow();
    while ((!orderWin || !orderWin.document.querySelector('#ListForm') || orderWin.document.querySelector('#ListForm').elements.length < 800 || (openForm && !orderWin.document.location.href.includes('_=' + entryStamp))) && Date.now() - started < 25000) {
      await sleep(500);
      orderWin = findOrderWindow();
    }
    if (!orderWin) return { ok: false, status: 'orders_add_form_not_found', blockers: ['orders_add_form_not_found'], top: topState() };

    const doc = orderWin.document;
    const form = doc.querySelector('#ListForm');
    const blockers = [];
    const warnings = [];
    const setResults = [];
    const ajaxRecords = [];
    const fabudanwei = form.elements.fabudanwei?.value || fabu;

    function toNumber(value, fallback = 0) {
      const num = Number(value);
      return Number.isFinite(num) ? num : fallback;
    }

    function integerString(value) {
      return String(Math.max(0, Math.trunc(toNumber(value))));
    }

    function compactNumber(value) {
      const num = toNumber(value);
      if (Number.isInteger(num)) return String(num);
      return String(Math.round((num + Number.EPSILON) * 100) / 100);
    }

    function dateYyyyMD(value) {
      if (typeof value !== 'string') return value;
      const match = value.match(/^(\\d{4})-(\\d{1,2})-(\\d{1,2})$/);
      if (!match) return value;
      return match[1] + '-' + Number(match[2]) + '-' + Number(match[3]);
    }

    function passengerTotal(counts = {}) {
      return ['adult', 'child_bed', 'child_no_bed', 'infant', 'leader']
        .reduce((sum, key) => sum + Math.max(0, Math.trunc(toNumber(counts[key]))), 0);
    }

    function roomTotal(roomCounts = {}) {
      return ['SGL', 'TWN', 'TRP', 'DBL', 'HNM', 'TL']
        .reduce((sum, key) => sum + Math.max(0, Math.trunc(toNumber(roomCounts[key]))), 0);
    }

    function splitRows(text) {
      const str = String(text || '');
      if (!str) return [];
      if (str.includes('◇')) return str.split('◇').map((row) => row.trim()).filter(Boolean);
      if (/\\r?\\n/.test(str)) return str.split(/\\r?\\n/).map((row) => row.trim()).filter(Boolean);
      return [str.trim()].filter(Boolean);
    }

    function splitColumns(row) {
      return String(row || '').split('◆').map((part) => part.trim());
    }

    function rows(text) {
      return splitRows(text).map((row, rowIndex) => ({ rowIndex, columns: splitColumns(row) }));
    }

    function summarizeText(text) {
      const parsedRows = splitRows(text);
      const histogram = {};
      parsedRows.slice(0, 200).forEach((row) => {
        const count = splitColumns(row).length;
        histogram[count] = (histogram[count] || 0) + 1;
      });
      return { byte_length: new Blob([String(text || '')]).size, row_count: parsedRows.length, column_count_histogram_first_200_rows: histogram, value_redacted: true };
    }

    async function sha256(text) {
      const buffer = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(text));
      return Array.from(new Uint8Array(buffer)).map((byte) => byte.toString(16).padStart(2, '0')).join('');
    }

    async function fetchText(path) {
      const url = new URL(path, doc.location.href).href;
      const res = await orderWin.fetch(url, {
        method: 'POST',
        credentials: 'same-origin',
        headers: { 'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8' }
      });
      const text = await res.text();
      return { ok: res.ok, status: res.status, text };
    }

    function exactMatches(text, expected, column) {
      const expectedText = String(expected || '').trim();
      if (!expectedText) return [];
      return rows(text)
        .filter((row) => String(row.columns[column] || '').trim() === expectedText);
    }

    function containsMatches(text, expected, column) {
      const expectedText = String(expected || '').trim();
      if (!expectedText) return [];
      return rows(text)
        .filter((row) => String(row.columns[column] || '').trim().includes(expectedText));
    }

    function selectUniqueExistingOption(text, expected, column, name) {
      const normalizedColumn = Number(column);
      const exactByColumn = exactMatches(text, expected, normalizedColumn);
      if (exactByColumn.length === 1) {
        return {
          match: exactByColumn[0],
          rule: 'exact',
          exact_count: exactByColumn.length,
          contains_count: containsMatches(text, expected, normalizedColumn).length,
          blocker: ''
        };
      }
      const contains = containsMatches(text, expected, normalizedColumn);
      if (exactByColumn.length === 0 && contains.length === 1) return { match: contains[0], rule: 'unique_contains', exact_count: 0, contains_count: contains.length, blocker: '' };
      return {
        match: null,
        rule: exactByColumn.length > 1 ? 'ambiguous_exact' : 'blocked',
        exact_count: exactByColumn.length,
        contains_count: contains.length,
        blocker: exactByColumn.length > 1
          ? name + ': expected exactly one existing LTJT option, found multiple exact matches'
          : name + ': no exact match and unique contains fallback did not produce exactly one option'
      };
    }

    function getValue(name) {
      const el = form.elements[name];
      if (!el) return '';
      if (el.length && !el.tagName) return Array.from(el).find((item) => item.checked)?.value || el[0]?.value || '';
      return el.value ?? '';
    }

    function setValue(name, value, source) {
      const elements = Array.from(form.elements).filter((el) => el.name === name);
      if (!elements.length) {
        blockers.push('Cannot set missing form field ' + name + ' from ' + source);
        return;
      }
      const textValue = String(value ?? '');
      const type = String(elements[0].type || '').toLowerCase();
      if (type === 'radio') {
        const matched = elements.find((el) => String(el.value) === textValue) || elements[0];
        elements.forEach((el) => { el.checked = el === matched; });
      } else if (type === 'checkbox') {
        elements[0].checked = Boolean(value);
        if (textValue) elements[0].value = textValue;
      } else {
        elements[0].value = textValue;
      }
      setResults.push({ name, source, type, value_length: textValue.length, value_redacted: true });
    }

    function summarizeValues(values) {
      const normalized = values.map((value) => String(value ?? ''));
      return {
        value_count: normalized.length,
        nonempty_count: normalized.filter((value) => value !== '').length,
        total_value_length: normalized.reduce((sum, value) => sum + value.length, 0),
        value_redacted: true
      };
    }

    function snapshotForm() {
      const snapshot = {};
      Array.from(form.elements).forEach((el, index) => {
        const name = el.name || el.id || '__element_' + index;
        const type = String(el.type || '').toLowerCase();
        const value = (type === 'checkbox' || type === 'radio') ? (el.checked ? el.value : '') : (el.value ?? '');
        if (!snapshot[name]) snapshot[name] = [];
        snapshot[name].push(String(value));
      });
      return snapshot;
    }

    function compareSnapshots(before, after) {
      const names = Array.from(new Set([...Object.keys(before), ...Object.keys(after)])).sort();
      return names
        .filter((name) => JSON.stringify(before[name] || []) !== JSON.stringify(after[name] || []))
        .map((name) => ({ name, before: summarizeValues(before[name] || []), after: summarizeValues(after[name] || []) }));
    }

    function groupChangedFields(changes) {
      const groups = {};
      for (const change of changes) {
        let group = 'other';
        if (/^(Text|shuoming|oldxingcheng|xingcheng)/.test(change.name)) group = 'itinerary_text';
        else if (/^(zao|zhong|wan|zhusu|jingdian)/.test(change.name)) group = 'resources';
        else if (/^(ys_|youyingshou|baojia|yingfu)/.test(change.name)) group = 'pricing_receivable';
        else if (/^(TianShu|chanpinming|tuanxuhao|zhuanxianming|zutuanshe|bizhong|lianxiren)/.test(change.name)) group = 'core';
        groups[group] = (groups[group] || 0) + 1;
      }
      return groups;
    }

    function pushCheck(checks, check) {
      checks.push(check);
      if (check.required && !check.passed) blockers.push(check.name + ': ' + check.blocker);
    }

    const endpoints = {
      product: '../dat/AjaxPublicFun.asp?Act=ProGetProductname&fls=1&fabudanwei=' + encodeURIComponent(fabudanwei),
      route: '../dat/AjaxPublicFun.asp?Act=GetInformation&fl=3&fls=1&fabudanwei=' + encodeURIComponent(fabudanwei),
      customer: '../dat/AjaxPublicFun.asp?Act=ProTravel&fabudanwei=' + encodeURIComponent(fabudanwei),
      staff: '../dat/AjaxPublicFun.asp?Act=ProDanwei_Yuangong&fabudanwei=' + encodeURIComponent(fabudanwei)
    };
    const fetched = {};
    for (const [key, path] of Object.entries(endpoints)) fetched[key] = await fetchText(path);

    const productSelection = selectUniqueExistingOption(fetched.product.text, operation.data?.product?.name, 1, 'product');
    if (!productSelection.match) blockers.push(productSelection.blocker);
    const productInitialCheck = {
      name: 'product_initial_selection',
      endpoint_key: 'product',
      match_rule: productSelection.rule,
      exact_match_count: productSelection.exact_count,
      contains_match_count: productSelection.contains_count,
      match_shape: productSelection.match ? { row_index: productSelection.match.rowIndex, column_count: productSelection.match.columns.length, set_value_targets: ['chanpinming'] } : null,
      summary: summarizeText(fetched.product.text)
    };

    const $ = orderWin.jQuery || orderWin.$;
    const originalAjax = $?.ajax;
    if (!$ || typeof originalAjax !== 'function') blockers.push('jQuery.ajax is not available in order form');
    if (typeof orderWin.Find_product !== 'function') blockers.push('Find_product() is not available');

    if (!blockers.length) {
      $.ajax = function ajaxWrapper(options, ...rest) {
        const config = typeof options === 'string' ? { url: options } : { ...(options || {}) };
        const isProductEffect = String(config.url || '').includes('Act=GetProduct');
        if (!isProductEffect) return originalAjax.call(this, options, ...rest);
        const record = {
          url_path_redacted: '../dat/AjaxPublicFun.asp?Act=GetProduct&cpm=[redacted]',
          method: config.type || config.method || 'GET',
          dataType: config.dataType || '',
          completed: false,
          ok: false,
          text_status: '',
          response_byte_length: 0,
          contains_login_timeout_text: false
        };
        ajaxRecords.push(record);
        const originalSuccess = config.success;
        const originalError = config.error;
        const originalComplete = config.complete;
        config.success = function successWrapper(data, textStatus) {
          const text = String(data || '');
          record.ok = true;
          record.text_status = textStatus || '';
          record.response_byte_length = new Blob([text]).size;
          record.contains_login_timeout_text = /登陆|登录|login/i.test(text);
          return originalSuccess ? originalSuccess.apply(this, arguments) : undefined;
        };
        config.error = function errorWrapper(jqXHR, textStatus, errorThrown) {
          record.ok = false;
          record.text_status = textStatus || '';
          record.error_text_redacted = errorThrown ? String(errorThrown).slice(0, 80) : '';
          return originalError ? originalError.apply(this, arguments) : undefined;
        };
        config.complete = function completeWrapper() {
          record.completed = true;
          return originalComplete ? originalComplete.apply(this, arguments) : undefined;
        };
        return originalAjax.call(this, config, ...rest);
      };
    }

    const beforeProduct = snapshotForm();
    if (!blockers.length) {
      setValue('chanpinming', productSelection.match.columns[1], 'product_lookup_selection');
      try {
        orderWin.Find_product();
      } catch (err) {
        blockers.push('Find_product() threw: ' + (err.message || String(err)).slice(0, 160));
      }
    }
    const effectStarted = Date.now();
    while (Date.now() - effectStarted < 15000) {
      if (ajaxRecords.some((record) => record.completed)) break;
      await sleep(250);
    }
    await sleep(1000);
    if ($ && originalAjax) $.ajax = originalAjax;

    const afterProduct = snapshotForm();
    const productChanges = compareSnapshots(beforeProduct, afterProduct);
    const productAjax = ajaxRecords.find((record) => record.url_path_redacted.includes('GetProduct')) || null;
    if (!productAjax) blockers.push('GetProduct ajax request was not observed');
    else if (!productAjax.ok) blockers.push('GetProduct ajax request did not complete successfully');
    else if (productAjax.contains_login_timeout_text) blockers.push('GetProduct response looked like a login-timeout script');
    if (!productChanges.length) blockers.push('Find_product/GetProduct completed without changing any serialized form fields');

    const core = {
      product: getValue('chanpinming'),
      trip: getValue('TianShu'),
      route: getValue('zhuanxianming'),
      routePrefix: getValue('tuanxuhao1'),
      customer: getValue('zutuanshe'),
      customerId: getValue('zutuansheid'),
      currency: getValue('bizhong')
    };

    const staticTrip = '1D◇2D1N◇3D2N◇4D3N◇5D4N◇6D5N◇7D6N◇8D7N◇9D8N◇10D9N';
    const productAfterMatches = exactMatches(fetched.product.text, core.product, 1);
    const tripMatches = exactMatches(staticTrip, core.trip, 0);
    const routeMatches = exactMatches(fetched.route.text, core.route, 1);
    const customerMatches = exactMatches(fetched.customer.text, core.customer, 2);
    const opSelection = selectUniqueExistingOption(fetched.staff.text, operation.data?.op_user?.name, 0, 'op_user');
    const salesSelection = selectUniqueExistingOption(fetched.staff.text, operation.data?.sales_user?.name, 0, 'sales_user');
    if (!opSelection.match) blockers.push(opSelection.blocker);
    if (!salesSelection.match) blockers.push(salesSelection.blocker);
    const lookupChecks = [
      productInitialCheck,
      { name: 'product_after_effect', endpoint_key: 'product', exact_match_count: productAfterMatches.length, match_shape: productAfterMatches.length === 1 ? { row_index: productAfterMatches[0].rowIndex, column_count: productAfterMatches[0].columns.length } : null, summary: summarizeText(fetched.product.text) },
      { name: 'trip_after_effect', endpoint_key: '', exact_match_count: tripMatches.length, match_shape: tripMatches.length === 1 ? { row_index: tripMatches[0].rowIndex, column_count: tripMatches[0].columns.length } : null, summary: summarizeText(staticTrip) },
      { name: 'route_after_effect', endpoint_key: 'route', exact_match_count: routeMatches.length, match_shape: routeMatches.length === 1 ? { row_index: routeMatches[0].rowIndex, column_count: routeMatches[0].columns.length } : null, summary: summarizeText(fetched.route.text) },
      { name: 'customer_after_effect', endpoint_key: 'customer', exact_match_count: customerMatches.length, match_shape: customerMatches.length === 1 ? { row_index: customerMatches[0].rowIndex, column_count: customerMatches[0].columns.length } : null, summary: summarizeText(fetched.customer.text) },
      { name: 'op_user', endpoint_key: 'staff', exact_match_count: opSelection.exact_count, contains_match_count: opSelection.contains_count, match_rule: opSelection.rule, match_shape: opSelection.match ? { row_index: opSelection.match.rowIndex, column_count: opSelection.match.columns.length, set_value_targets: ['gendanren'] } : null, summary: summarizeText(fetched.staff.text) },
      { name: 'sales_user', endpoint_key: 'staff', exact_match_count: salesSelection.exact_count, contains_match_count: salesSelection.contains_count, match_rule: salesSelection.rule, match_shape: salesSelection.match ? { row_index: salesSelection.match.rowIndex, column_count: salesSelection.match.columns.length, set_value_targets: ['xiaoshouren'] } : null, summary: summarizeText(fetched.staff.text) }
    ];
    for (const check of lookupChecks.slice(1, 5)) {
      if (check.exact_match_count !== 1) blockers.push(check.name + ': expected exactly one existing LTJT option, found ' + check.exact_match_count);
    }

    const consistencyChecks = [];
    pushCheck(consistencyChecks, {
      name: 'product_template_product_nonempty',
      field: 'chanpinming',
      passed: Boolean(String(core.product || '').trim()),
      required: true,
      blocker: 'product template did not populate product',
      actual_redacted: true,
      actual_length: String(core.product || '').length
    });
    pushCheck(consistencyChecks, {
      name: 'product_template_trip_nonempty',
      field: 'TianShu',
      passed: Boolean(String(core.trip || '').trim()),
      required: true,
      blocker: 'product template did not populate trip',
      actual_redacted: true,
      actual_length: String(core.trip || '').length
    });
    pushCheck(consistencyChecks, {
      name: 'product_template_route_nonempty',
      field: 'zhuanxianming',
      passed: Boolean(String(core.route || '').trim()),
      required: true,
      blocker: 'product template did not populate route',
      actual_redacted: true,
      actual_length: String(core.route || '').length
    });
    pushCheck(consistencyChecks, {
      name: 'product_template_route_prefix_nonempty',
      field: 'tuanxuhao1',
      passed: Boolean(String(core.routePrefix || '').trim()),
      required: true,
      blocker: 'product template did not populate route prefix',
      actual_redacted: true,
      actual_length: String(core.routePrefix || '').length
    });
    pushCheck(consistencyChecks, {
      name: 'product_template_customer_nonempty',
      field: 'zutuanshe',
      passed: Boolean(String(core.customer || '').trim()),
      required: true,
      blocker: 'product template did not populate customer',
      actual_redacted: true,
      actual_length: String(core.customer || '').length
    });
    pushCheck(consistencyChecks, {
      name: 'product_template_customer_id_nonempty',
      field: 'zutuansheid',
      passed: Boolean(String(core.customerId || '').trim()),
      required: true,
      blocker: 'product template did not populate customer id',
      actual_redacted: true,
      actual_length: String(core.customerId || '').length
    });
    if (customerMatches.length === 1 && String(customerMatches[0].columns[1] || '').trim() !== String(core.customerId || '').trim()) {
      blockers.push('customer_after_effect: product template customer id does not match the existing customer option id');
    }
    if (routeMatches.length === 1 && String(routeMatches[0].columns[3] || '').trim() !== String(core.routePrefix || '').trim()) {
      blockers.push('route_after_effect: product template route prefix does not match the existing route option prefix');
    }

    const counts = operation.data?.passenger_counts || {};
    const rooms = operation.data?.room_counts || {};
    const prices = operation.data?.prices || {};
    const passengerSum = passengerTotal(counts);
    const expectedPassengerTotal = counts.expected_total == null ? passengerSum : Math.trunc(toNumber(counts.expected_total));
    const computedRoomTotal = roomTotal(rooms);
    const logicalChecks = [
      { name: 'passenger_total', passed: passengerSum > 0 && passengerSum === expectedPassengerTotal, expected: expectedPassengerTotal, actual: passengerSum },
      { name: 'room_total', passed: computedRoomTotal >= 0, actual: computedRoomTotal },
      { name: 'departure_date_count', passed: Array.isArray(operation.data?.departure_dates) && operation.data.departure_dates.length === 1, actual: Array.isArray(operation.data?.departure_dates) ? operation.data.departure_dates.length : 0 }
    ];
    logicalChecks.forEach((check) => {
      if (!check.passed) blockers.push(check.name + ': raw instruction logical validation failed');
    });

    const receivableCategories = [
      ['adult', '成人团费'],
      ['child_bed', '小童占床'],
      ['child_no_bed', '小童不占床'],
      ['infant', '婴儿'],
      ['leader', '领队']
    ];
    const receivableRows = [];
    for (const [key, label] of receivableCategories) {
      const quantity = toNumber(counts[key]);
      const unitPrice = toNumber(prices[key]);
      if (quantity > 0 && unitPrice > 0) {
        receivableRows.push({
          key,
          label,
          quantity,
          unit_price: unitPrice,
          amount: quantity * unitPrice
        });
      } else if (quantity > 0 && unitPrice <= 0) {
        blockers.push('price for ' + key + ' must be greater than zero when quantity is greater than zero');
      }
    }
    if (!receivableRows.length) blockers.push('No receivable rows were generated from passenger counts and prices');
    if (receivableRows.length > 10) blockers.push('receivable row count exceeds LTJT max 10');

    if (!blockers.length) {
      const note = marker + '｜测试订单｜' + String(operation.data?.special_requests || '');
      const currency = core.currency || prices.currency || operation.data?.system_defaults?.currency || 'USD';
      setValue('chufa_ri', dateYyyyMD(operation.data.departure_dates[0]), 'raw_instruction_departure_date');
      setValue('tuanxuhao2', markerSuffix, 'raw_instruction_obvious_test_suffix');
      setValue('gendanren', opSelection.match.columns[0], 'raw_instruction_existing_op_user');
      setValue('xiaoshouren', salesSelection.match.columns[0], 'raw_instruction_existing_sales_user');
      setValue('darenshu', integerString(counts.adult), 'raw_instruction_passenger_counts');
      setValue('xiaorenshu', integerString(counts.child_bed), 'raw_instruction_passenger_counts');
      setValue('ertrenshu', integerString(counts.child_no_bed), 'raw_instruction_passenger_counts');
      setValue('yingrenshu', integerString(counts.infant), 'raw_instruction_passenger_counts');
      setValue('quanrenshu', integerString(counts.leader), 'raw_instruction_passenger_counts');
      setValue('frenshu0', integerString(rooms.SGL), 'raw_instruction_room_counts');
      setValue('frenshu1', integerString(rooms.TWN), 'raw_instruction_room_counts');
      setValue('frenshu2', integerString(rooms.TRP), 'raw_instruction_room_counts');
      setValue('frenshu3', integerString(rooms.DBL), 'raw_instruction_room_counts');
      setValue('frenshu4', integerString(rooms.HNM), 'raw_instruction_room_counts');
      setValue('frenshu5', integerString(rooms.TL), 'raw_instruction_room_counts');
      setValue('frenshu6', integerString(computedRoomTotal), 'raw_instruction_room_counts');
      setValue('danzhuangtai', operation.data?.system_defaults?.business_status || '预订', 'raw_instruction_status');
      setValue('yaobeian', operation.data?.system_defaults?.filing_required === false ? '' : '要备案', 'raw_instruction_checkbox');
      setValue('xiadanbeizhu', note, 'raw_instruction_obvious_test_note');

      const receivableTargets = ['ys_danwei','ys_danweiid','ys_shuoming','ys_zhanwei','ys_xiangmu','ys_fangshi','ys_bizhong','ys_shuliang','ys_danjia','ys_jine','ys_yishoufu','ys_beizhu','ys_id','ys_shoufulei','ys_caozuoren','ys_shenheren'];
      for (let index = 0; index < 10; index += 1) {
        receivableTargets.forEach((prefix) => setValue(prefix + index, '', 'raw_instruction_clear_receivables'));
      }
      receivableRows.forEach((row, index) => {
        setValue('ys_danwei' + index, core.customer, 'raw_instruction_receivable_customer');
        setValue('ys_danweiid' + index, core.customerId, 'raw_instruction_receivable_customer_id');
        setValue('ys_xiangmu' + index, marker + ' ' + row.label, 'raw_instruction_receivable_item');
        setValue('ys_shuoming' + index, '人', 'raw_instruction_receivable_unit');
        setValue('ys_bizhong' + index, currency, 'raw_instruction_receivable_currency');
        setValue('ys_shuliang' + index, compactNumber(row.quantity), 'raw_instruction_receivable_quantity');
        setValue('ys_danjia' + index, compactNumber(row.unit_price), 'raw_instruction_receivable_unit_price');
        setValue('ys_jine' + index, compactNumber(row.amount), 'raw_instruction_receivable_amount');
        setValue('ys_yishoufu' + index, '0', 'raw_instruction_receivable_paid');
        setValue('ys_beizhu' + index, note, 'raw_instruction_receivable_remark');
        setValue('ys_shoufulei' + index, '0', 'raw_instruction_receivable_payment_type');
        setValue('ys_caozuoren' + index, opSelection.match.columns[0], 'raw_instruction_receivable_operator');
      });
    }

    const requiredTargets = ['chufa_ri','zhuanxianming','TianShu','zutuanshe','chanpinming','gendanren','tuanxuhao1','tuanxuhao2','darenshu','xiaorenshu','ertrenshu','yingrenshu','quanrenshu','xiaoshouren'];
    const requiredMissing = requiredTargets.filter((name) => String(getValue(name) || '').trim() === '');
    if (requiredMissing.length) blockers.push('Required fields still blank: ' + requiredMissing.join(', '));

    const serializedForm = orderWin.jQuery
      ? orderWin.jQuery(form).serialize()
      : Array.from(new FormData(form).entries()).map(([key, value]) => encodeURIComponent(key) + '=' + encodeURIComponent(value)).join('&');
    const serializedParams = new URLSearchParams(serializedForm);

    let submitIntercept = null;
    if (interceptSubmit && !blockers.length) {
      const originalAjaxForSubmit = $.ajax;
      const originalAlert = orderWin.alert;
      const originalDialogAlert = $.dialog?.alert;
      const intercepted = [];
      const alerts = [];
      orderWin.alert = function interceptedAlert(message) {
        alerts.push({ type: 'alert', message_length: String(message || '').length, message_redacted: true });
        return undefined;
      };
      if ($.dialog && typeof $.dialog.alert === 'function') {
        $.dialog.alert = function interceptedDialogAlert(message) {
          alerts.push({ type: 'dialog.alert', message_length: String(message || '').length, message_redacted: true });
          return undefined;
        };
      }
      $.ajax = function ajaxIntercept(options, ...rest) {
        const config = typeof options === 'string' ? { url: options } : { ...(options || {}) };
        const url = String(config.url || '');
        const data = String(config.data || '');
        const isSubmit = /\\/System\\/DAT\\/orders\\.asp/i.test(url) && data.startsWith('Act=DoInfoJH&');
        if (!isSubmit) return originalAjaxForSubmit.call(this, options, ...rest);
        const params = new URLSearchParams(data.slice('Act=DoInfoJH&'.length));
        intercepted.push({
          url_redacted: '/System/DAT/orders.asp',
          method: config.type || config.method || 'GET',
          dataType: config.dataType || '',
          prevented_from_network: true,
          payload: data,
          payload_summary: {
            starts_with_DoInfoJH: true,
            byte_length: new Blob([data]).size,
            field_count: Array.from(params.keys()).length,
            field_names: Array.from(new Set(Array.from(params.keys()))).sort(),
            value_redacted: true
          }
        });
        return { readyState: 4, status: 0, statusText: 'intercepted_by_raw_instruction_test', abort() {} };
      };
      let thrown = '';
      try {
        orderWin.SubmitInfoForm();
      } catch (err) {
        thrown = err.message || String(err);
      }
      await sleep(1000);
      $.ajax = originalAjaxForSubmit;
      orderWin.alert = originalAlert;
      if ($.dialog && typeof originalDialogAlert === 'function') $.dialog.alert = originalDialogAlert;
      for (const item of intercepted) {
        item.payload_sha256 = await sha256(item.payload || '');
        item.payload_redacted = true;
        delete item.payload;
      }
      submitIntercept = {
        status: intercepted.length === 1 && !alerts.length && !thrown ? 'submit_intercept_captured' : 'submit_intercept_blocked',
        intercepted_submit_count: intercepted.length,
        intercepted_submits: intercepted,
        alerts,
        thrown_redacted: Boolean(thrown),
        thrown_length: String(thrown || '').length,
        DoInfoJH_network_prevented: true
      };
      if (submitIntercept.status !== 'submit_intercept_captured') blockers.push('submit intercept did not capture exactly one clean DoInfoJH branch');
    }

    const receivableAmountTotal = receivableRows.reduce((sum, row) => sum + row.amount, 0);
    return {
      ok: true,
      status: blockers.length ? 'raw_instruction_test_blocked' : 'raw_instruction_test_passed',
      page: { url: doc.location.href, title: doc.title, form_element_count: form.elements.length },
      parsed_instruction: {
        action: operation.action,
        order_nature: operation.order_nature,
        order_mode: operation.data?.order_mode || '',
        departure_date: dateYyyyMD(operation.data?.departure_dates?.[0] || ''),
        passenger_total: passengerSum,
        room_total: computedRoomTotal,
        receivable_row_count: receivableRows.length,
        receivable_amount_total: receivableAmountTotal,
        values_are_test_only: true
      },
      lookup_checks: lookupChecks,
      product_side_effect: {
        ajax_records: ajaxRecords,
        changed_field_count: productChanges.length,
        changed_field_groups: groupChangedFields(productChanges),
        changed_field_names: productChanges.map((change) => change.name)
      },
      consistency_checks: consistencyChecks,
      core_after_product: Object.fromEntries(Object.entries(core).map(([key, value]) => [key, { nonempty: Boolean(String(value || '').trim()), value_length: String(value || '').length, value_redacted: true }])),
      logical_checks: logicalChecks,
      test_markers: {
        suffix_marker: marker,
        note_marker: marker,
        full_suffix_marker: markerSuffix,
        values_are_test_only: true
      },
      set_summary: {
        set_field_count: setResults.length,
        set_field_names: Array.from(new Set(setResults.map((item) => item.name))).sort(),
        set_results: setResults
      },
      final_form: {
        serialized_field_count: Array.from(serializedParams.keys()).length,
        serialized_form_sha256: await sha256('Act=DoInfoJH&' + serializedForm),
        serialized_form_redacted: true,
        required_missing: requiredMissing
      },
      submit_intercept: submitIntercept,
      blockers,
      warnings,
      submit_safety: {
        live_submit_attempted: false,
        DoInfoJH_network_prevented: Boolean(submitIntercept?.DoInfoJH_network_prevented),
        note: 'This raw-instruction test uses existing LTJT options and product template side effects in browser memory. It never lets DoInfoJH reach the network.'
      }
    };
  })()`;
}

async function main() {
  const args = parseArgs(process.argv.slice(2));
  if (args.help) {
    console.log(usage());
    return;
  }

  const inputPath = args.input || args._[0];
  if (!inputPath) {
    console.error(usage());
    process.exit(1);
  }

  const operation = readJson(inputPath);
  const local = localValidate(operation);
  if (local.blockers.length) {
    const output = {
      generated_at: new Date().toISOString(),
      status: 'raw_instruction_test_blocked',
      source_input: inputPath,
      blockers: local.blockers,
      warnings: local.warnings,
      submit_safety: {
        live_submit_attempted: false
      }
    };
    if (args.out) writeJson(args.out, output);
    console.log(JSON.stringify({ status: output.status, blockers: output.blockers.length, warnings: output.warnings.length, out: args.out || '' }, null, 2));
    process.exit(2);
  }

  const target = await getTarget(args.port || DEFAULT_PORT);
  const cdp = new CDP(target.webSocketDebuggerUrl);
  await cdp.connect();
  try {
    await cdp.send('Runtime.enable');
    const output = await evaluate(cdp, browserExpression({
      operation,
      openForm: args['open-form'],
      interceptSubmit: args['intercept-submit']
    }), 120000);
    output.generated_at = new Date().toISOString();
    output.source_input = inputPath;
    output.warnings = [...(output.warnings || []), ...local.warnings];
    if (args.out) writeJson(args.out, output);
    if (args['approved-preflight-out']) writeJson(args['approved-preflight-out'], buildCompatiblePreflightReport(output));
    if (args['approved-intercept-out']) writeJson(args['approved-intercept-out'], buildCompatibleInterceptReport(output));
    console.log(JSON.stringify({
      status: output.status,
      blockers: output.blockers?.length || 0,
      warnings: output.warnings?.length || 0,
      lookup_checks: output.lookup_checks?.map((check) => ({
        name: check.name,
        exact_match_count: check.exact_match_count,
        contains_match_count: check.contains_match_count,
        match_rule: check.match_rule
      })) || [],
      product_changed_fields: output.product_side_effect?.changed_field_count || 0,
      product_changed_groups: output.product_side_effect?.changed_field_groups || {},
      passenger_total: output.parsed_instruction?.passenger_total,
      room_total: output.parsed_instruction?.room_total,
      receivable_amount_total: output.parsed_instruction?.receivable_amount_total,
      serialized_field_count: output.final_form?.serialized_field_count || 0,
      submit_intercept_status: output.submit_intercept?.status || '',
      intercepted_submit_count: output.submit_intercept?.intercepted_submit_count || 0,
      approved_preflight_out: args['approved-preflight-out'] || '',
      approved_intercept_out: args['approved-intercept-out'] || '',
      out: args.out || ''
    }, null, 2));
    if (output.blockers?.length) process.exit(2);
  } finally {
    cdp.close();
  }
}

main().catch((error) => {
  console.error(error.stack || error.message);
  process.exit(1);
});