import {
  BUSINESS_ROUTES,
  businessRouteById,
  firstNonEmptyLine,
  normalizeDirectiveText,
  resolveBusinessRoute,
  resolveRouteFieldLabel,
  type BusinessRouteDefinition,
  type BusinessRouteId,
  type ProgramFieldDefinition
} from './business-routes.js';
import { validateParsedOperation } from './parser-contract.js';

export const PROGRAM_PARSER_FALLBACK_CODES = Object.freeze(new Set([
  'program_unsupported_syntax',
  'program_unknown_field',
  'program_internal_error',
  'program_timeout',
  'program_contract_invalid'
]));

const PASSENGER_HEADERS = Object.freeze([
  '序号', '姓名', 'NAME', '性别', '出生日期', '出生地', '证件类型', '证件号码',
  '签发地', '签发日', '有效期', '电话', '备注'
]);

export const ALL_EXPORT_TYPES = Object.freeze([
  'xingyou-confirm',
  'liantai-confirm',
  'job-order',
  'visitor-list',
  'guide-confirm',
  'hotel-preorder',
  'transport-preorder',
  'filing-current',
  'filing-history',
  'pickup-sign'
]);

const EXPORT_TYPE_ALIASES = new Map<string, string>([
  ['星游客户确认单', 'xingyou-confirm'],
  ['星游确认单', 'xingyou-confirm'],
  ['联泰客户确认单', 'liantai-confirm'],
  ['联泰确认单', 'liantai-confirm'],
  ['团队申请书', 'job-order'],
  ['游客名单', 'visitor-list'],
  ['游客信息', 'visitor-list'],
  ['导游通知书', 'guide-confirm'],
  ['导游确认单', 'guide-confirm'],
  ['酒店预订单', 'hotel-preorder'],
  ['团体票申请书', 'transport-preorder'],
  ['大交通预订单', 'transport-preorder'],
  ['备案确认书', 'filing-current'],
  ['历史备案确认书', 'filing-history'],
  ['接机牌', 'pickup-sign']
]);

const SHARED_PLAN_VISITOR_EXPORT_ALIASES = new Set([
  '整团游客信息'
]);

const NEXT_OCCURRENCE_DATE_ROUTES = new Set<BusinessRouteId>([
  'team_order_create',
  'team_order_batch_create',
  'shared_plan_create',
  'shared_child_order_create',
  'order_update_shared_plan',
  'order_update_shared_child',
  'order_update_independent',
  'arrangement_hotel_update',
  'order_cancel',
  'order_restore'
]);

type JsonRecord = Record<string, unknown>;

export interface ProgramHistoryTurn {
  text: string;
  receivedAt?: string | Date;
}

export interface ProgramParseInput {
  rawText: string;
  receivedAt?: string | Date;
  routeId?: BusinessRouteId | null;
  history?: readonly ProgramHistoryTurn[];
  timeoutMs?: number;
}

export type ProgramParseResult = JsonRecord & {
  status: 'agent_parse_passed' | 'agent_parse_needs_input' | 'agent_parse_blocked';
  blockers: string[];
  operation: JsonRecord | null;
  business_route_id: BusinessRouteId | null;
  program_parser_version: string;
};

interface DateContext {
  year: number;
  month: number;
  day: number;
}

interface FieldParseSuccess {
  ok: true;
  value: unknown;
}

interface FieldParseFailure {
  ok: false;
  message: string;
}

type FieldParseResult = FieldParseSuccess | FieldParseFailure;

interface ExtractedFields {
  values: Map<string, string>;
  conflicts: Map<string, string[]>;
  unknownFields: string[];
  ambiguousFields: string[];
  unsupportedLines: string[];
  multipleRoute: BusinessRouteId | null;
}

interface BuildSuccess {
  ok: true;
  operation: JsonRecord;
}

interface BuildFailure {
  ok: false;
  code: string;
  message: string;
  field?: string;
}

type BuildResult = BuildSuccess | BuildFailure;

function isRecord(value: unknown): value is JsonRecord {
  return Boolean(value && typeof value === 'object' && !Array.isArray(value));
}

function compactText(value: unknown): string {
  return String(value || '').normalize('NFKC').trim();
}

function isPlaceholder(value: string): boolean {
  const normalized = compactText(value);
  return !normalized || (/^<[^>]+>$/u.test(normalized)) || (/^请(?:填写|输入|补充)/u.test(normalized));
}

function dateContext(value: string | Date | undefined): DateContext {
  const parsed = value instanceof Date ? value : value ? new Date(value) : new Date();
  const safe = Number.isNaN(parsed.getTime()) ? new Date() : parsed;
  const parts = new Intl.DateTimeFormat('en-CA', {
    timeZone: 'Asia/Shanghai', year: 'numeric', month: '2-digit', day: '2-digit'
  }).formatToParts(safe);
  const part = (type: string) => Number(parts.find((item) => item.type === type)?.value || 0);
  return { year: part('year'), month: part('month'), day: part('day') };
}

function pad2(value: number): string {
  return String(value).padStart(2, '0');
}

function validDate(year: number, month: number, day: number): boolean {
  if (year < 2000 || year > 2100 || month < 1 || month > 12 || day < 1 || day > 31) return false;
  const date = new Date(Date.UTC(year, month - 1, day));
  return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
}

function formatDate(year: number, month: number, day: number): string {
  return `${year}-${pad2(month)}-${pad2(day)}`;
}

function parseDateParts(rawValue: string): { year: number | null; month: number; day: number } | null {
  const value = compactText(rawValue)
    .replace(/[年月]/gu, '-')
    .replace(/日/gu, '')
    .replace(/[/.]/gu, '-')
    .replace(/\s+/gu, '');
  const full = value.match(/^(\d{4})-(\d{1,2})-(\d{1,2})$/u);
  if (full) return { year: Number(full[1]), month: Number(full[2]), day: Number(full[3]) };
  const short = value.match(/^(\d{1,2})-(\d{1,2})$/u);
  if (short) return { year: null, month: Number(short[1]), day: Number(short[2]) };
  return null;
}

function parseDate(rawValue: string, context: DateContext, {
  nextOccurrence = false,
  referenceYear
}: { nextOccurrence?: boolean; referenceYear?: number } = {}): FieldParseResult {
  const parts = parseDateParts(rawValue);
  if (!parts) return { ok: false, message: '请使用 YYYY-MM-DD 或 MM-DD 日期格式。' };
  let year = parts.year ?? referenceYear ?? context.year;
  if (parts.year === null && referenceYear === undefined && nextOccurrence) {
    if (parts.month < context.month || (parts.month === context.month && parts.day < context.day)) year += 1;
  }
  if (!validDate(year, parts.month, parts.day)) return { ok: false, message: '日期不存在或超出支持范围。' };
  return { ok: true, value: formatDate(year, parts.month, parts.day) };
}

function parseDateRange(rawValue: string, context: DateContext, nextOccurrence: boolean): FieldParseResult {
  const pieces = compactText(rawValue).split(/\s*(?:到|至|~|～|—|–)\s*/u).filter(Boolean);
  if (pieces.length !== 2) return { ok: false, message: '日期范围必须包含明确的开始日期和结束日期。' };
  const startResult = parseDate(pieces[0], context, { nextOccurrence });
  if (!startResult.ok) return startResult;
  const start = String(startResult.value);
  const startYear = Number(start.slice(0, 4));
  const endParts = parseDateParts(pieces[1]);
  if (!endParts) return { ok: false, message: '结束日期格式无效。' };
  let endYear = endParts.year ?? startYear;
  let endResult = parseDate(pieces[1], context, { referenceYear: endYear });
  if (!endResult.ok) return endResult;
  if (String(endResult.value) < start && endParts.year === null) {
    endYear += 1;
    endResult = parseDate(pieces[1], context, { referenceYear: endYear });
    if (!endResult.ok) return endResult;
  }
  if (String(endResult.value) < start) return { ok: false, message: '结束日期不能早于开始日期。' };
  return { ok: true, value: { start_date: start, end_date: String(endResult.value) } };
}

function parseDateOrRange(rawValue: string, context: DateContext, nextOccurrence: boolean): FieldParseResult {
  if (/(?:到|至|~|～|—|–)/u.test(rawValue)) return parseDateRange(rawValue, context, nextOccurrence);
  const single = parseDate(rawValue, context, { nextOccurrence });
  return single.ok ? { ok: true, value: [single.value] } : single;
}

function parseDateList(rawValue: string, context: DateContext, nextOccurrence: boolean, range?: JsonRecord): FieldParseResult {
  const pieces = compactText(rawValue).split(/[\/、,，;；\s]+/u).filter(Boolean);
  if (!pieces.length) return { ok: false, message: '请至少填写一个日期。' };
  const values: string[] = [];
  const rangeStart = typeof range?.start_date === 'string' ? range.start_date : '';
  const rangeEnd = typeof range?.end_date === 'string' ? range.end_date : '';
  for (const piece of pieces) {
    const parts = parseDateParts(piece);
    let result = parseDate(piece, context, {
      nextOccurrence: !rangeStart && nextOccurrence,
      referenceYear: rangeStart && parts?.year === null ? Number(rangeStart.slice(0, 4)) : undefined
    });
    if (result.ok && rangeStart && rangeEnd && String(result.value) < rangeStart && parts?.year === null) {
      result = parseDate(piece, context, { referenceYear: Number(rangeStart.slice(0, 4)) + 1 });
    }
    if (!result.ok) return result;
    const date = String(result.value);
    if (rangeStart && (date < rangeStart || date > rangeEnd)) {
      return { ok: false, message: `日期 ${date} 不在填写的发团范围内。` };
    }
    if (values.includes(date)) return { ok: false, message: `日期 ${date} 重复。` };
    values.push(date);
  }
  values.sort();
  return { ok: true, value: values };
}

function namedRef(rawValue: string): JsonRecord {
  const keyword = compactText(rawValue);
  return { name: keyword.replace(/人名币/gu, '人民币'), keyword };
}

function positiveInteger(rawValue: string): FieldParseResult {
  const normalized = compactText(rawValue).replace(/(?:人|位|个|间|辆|份|张)$/u, '');
  if (!/^\d+$/u.test(normalized) || Number(normalized) < 1) return { ok: false, message: '必须填写正整数。' };
  return { ok: true, value: Number(normalized) };
}

function booleanValue(rawValue: string): FieldParseResult {
  const value = compactText(rawValue).toLowerCase();
  if (['是', '确认', '已确认', 'true', 'yes', 'y', '1'].includes(value)) return { ok: true, value: true };
  if (['否', '不', '不覆盖', 'false', 'no', 'n', '0'].includes(value)) return { ok: true, value: false };
  return { ok: false, message: '请明确填写“是”或“否”。' };
}

function parsePassengerCounts(rawValue: string): FieldParseResult {
  const value = compactText(rawValue)
    .replace(/[（(]\s*占床?\s*[）)]/gu, '占')
    .replace(/[（(]\s*不占床?\s*[）)]/gu, '不占')
    .replace(/\s+/gu, '');
  const explicit: JsonRecord = {};
  const explicitPattern = /(不占床儿童|儿童不占床|小孩不占床|占床儿童|儿童占床|小孩占床|成人|大人|婴儿|领队)[：:]?(\d+)(?:人|位)?/gu;
  const explicitKeys = new Map<string, string>([
    ['成人', 'adult'], ['大人', 'adult'],
    ['占床儿童', 'child_bed'], ['儿童占床', 'child_bed'], ['小孩占床', 'child_bed'],
    ['不占床儿童', 'child_no_bed'], ['儿童不占床', 'child_no_bed'], ['小孩不占床', 'child_no_bed'],
    ['婴儿', 'infant'], ['领队', 'leader']
  ]);
  const explicitMatches = [...value.matchAll(explicitPattern)];
  for (const match of explicitMatches) {
    const key = explicitKeys.get(match[1])!;
    if (explicit[key] !== undefined) return { ok: false, message: `人数分类 ${match[1]} 重复。` };
    const count = Number(match[2]);
    if (!Number.isSafeInteger(count)) return { ok: false, message: `人数分类 ${match[1]} 必须是安全范围内的非负整数。` };
    explicit[key] = count;
  }
  if (Object.keys(explicit).length) {
    const residue = value.replace(explicitPattern, '').replace(/[+＋、,，;；]/gu, '');
    if (residue) return { ok: false, message: `包含无法识别的人数内容：${residue}。` };
    const total = Object.values(explicit).reduce<number>((sum, item) => sum + Number(item), 0);
    return total > 0 && Number.isSafeInteger(total)
      ? { ok: true, value: explicit }
      : { ok: false, message: '人数合计必须大于 0 且在安全整数范围内。' };
  }

  const pieces = value.split(/[+＋]/u);
  if (!pieces.length || pieces.length > 5 || pieces.some((piece) => !piece)) {
    return { ok: false, message: '无法识别人数分类格式。' };
  }
  if (pieces.some((piece) => !/^\d+(?:占|不占)?$/u.test(piece))) {
    return { ok: false, message: '人数只能使用数字及“占/不占”分类。' };
  }
  const childKind = (piece: string): 'child_bed' | 'child_no_bed' | null => {
    if (/不占$/u.test(piece)) return 'child_no_bed';
    if (/占$/u.test(piece)) return 'child_bed';
    return null;
  };
  const taggedChildPair = pieces.length >= 4
    && childKind(pieces[1]) !== null
    && childKind(pieces[2]) !== null
    && childKind(pieces[1]) !== childKind(pieces[2]);
  const validLongDistribution = pieces.length >= 4
    && (/^\d+$/u.test(pieces[0]))
    && (pieces.every((piece) => /^\d+$/u.test(piece))
      || (taggedChildPair && pieces.slice(3).every((piece) => /^\d+$/u.test(piece))));
  if (!/^\d+$/u.test(pieces[0])
    || (pieces.length === 3 && (!/^\d+(?:占|不占)$/u.test(pieces[1]) || !/^\d+$/u.test(pieces[2])))
    || (pieces.length >= 4 && !validLongDistribution)) {
    return { ok: false, message: '人数分类位置无效，请按成人+占/不占儿童+领队，或成人+占床儿童+不占床儿童+领队填写。' };
  }
  const numbers = pieces.map((piece) => Number(piece.match(/^\d+/u)?.[0]));
  if (numbers.some((number) => !Number.isSafeInteger(number) || number < 0)) return { ok: false, message: '人数必须是安全范围内的非负整数。' };
  const result: JsonRecord = { adult: numbers[0] };
  if (pieces.length === 2) {
    if (/不占/u.test(pieces[1])) result.child_no_bed = numbers[1];
    else if (/占/u.test(pieces[1])) result.child_bed = numbers[1];
    else result.leader = numbers[1];
  } else if (pieces.length === 3) {
    if (/不占/u.test(pieces[1])) result.child_no_bed = numbers[1];
    else if (/占/u.test(pieces[1])) result.child_bed = numbers[1];
    else return { ok: false, message: '三段人数的第二段必须注明“占”或“不占”。' };
    result.leader = numbers[2];
  } else if (pieces.length === 4) {
    if (taggedChildPair) {
      result[childKind(pieces[1])!] = numbers[1];
      result[childKind(pieces[2])!] = numbers[2];
    } else {
      result.child_bed = numbers[1];
      result.child_no_bed = numbers[2];
    }
    result.leader = numbers[3];
  } else if (pieces.length === 5) {
    if (taggedChildPair) {
      result[childKind(pieces[1])!] = numbers[1];
      result[childKind(pieces[2])!] = numbers[2];
    } else {
      result.child_bed = numbers[1];
      result.child_no_bed = numbers[2];
    }
    result.infant = numbers[3];
    result.leader = numbers[4];
  }
  const total = Object.values(result).reduce<number>((sum, item) => sum + Number(item), 0);
  return total > 0 && Number.isSafeInteger(total)
    ? { ok: true, value: result }
    : { ok: false, message: '人数合计必须大于 0 且在安全整数范围内。' };
}

const ROOM_CODES = new Map<string, string>([
  ['SGL', 'SGL'], ['单', 'SGL'], ['单间', 'SGL'], ['单人间', 'SGL'],
  ['TWN', 'TWN'], ['标', 'TWN'], ['标间', 'TWN'], ['双标间', 'TWN'],
  ['TRP', 'TRP'], ['三', 'TRP'], ['三人间', 'TRP'],
  ['DBL', 'DBL'], ['双', 'DBL'], ['双人间', 'DBL'], ['大床', 'DBL'], ['大床房', 'DBL']
]);

function parseRoomCounts(rawValue: string): FieldParseResult {
  const value = compactText(rawValue).replace(/\s+/gu, '');
  const result: JsonRecord = {};
  const consumed: string[] = [];
  const pattern = /(\d+)\s*(SGL|TWN|TRP|DBL|单人间|单间|单|双标间|标间|标|三人间|三|双人间|大床房|大床|双)/giu;
  for (const match of value.matchAll(pattern)) {
    const code = ROOM_CODES.get(match[2].toUpperCase()) || ROOM_CODES.get(match[2]);
    if (!code) continue;
    const count = Number(match[1]);
    if (count < 1 || result[code] !== undefined) return { ok: false, message: '房型数量必须是正整数且同一房型不能重复。' };
    result[code] = count;
    consumed.push(match[0]);
  }
  if (!Object.keys(result).length) return { ok: false, message: '无法识别房型，请使用“8标1单”或“3SGL+2TWN”。' };
  let residue = value;
  for (const item of consumed) residue = residue.replace(item, '');
  residue = residue.replace(/[+＋、,，;；间房]/gu, '');
  if (residue) return { ok: false, message: `包含无法识别的房型内容：${residue}。` };
  return { ok: true, value: result };
}

function parsePassengerTsv(rawValue: string): FieldParseResult {
  const text = String(rawValue || '').replace(/\r\n?/gu, '\n').replace(/^\n+|\n+$/gu, '');
  const lines = text.split('\n').filter((line) => line.length > 0);
  if (lines.length < 2) return { ok: false, message: '名单必须包含规定表头和至少一行游客。' };
  const headers = lines[0].split('\t').map((cell) => cell.trim());
  if (headers.length !== PASSENGER_HEADERS.length || headers.some((header, index) => header !== PASSENGER_HEADERS[index])) {
    return { ok: false, message: '名单必须使用规定的 13 列 TSV 表头和顺序。' };
  }
  const sequence = new Set<number>();
  let leaderContact: JsonRecord | undefined;
  for (let index = 1; index < lines.length; index += 1) {
    const cells = lines[index].split('\t');
    if (cells.length !== PASSENGER_HEADERS.length) return { ok: false, message: `名单第 ${index} 行不是完整 13 列。` };
    const rowNo = Number(cells[0].trim());
    if (!Number.isInteger(rowNo) || rowNo < 1) return { ok: false, message: `名单第 ${index} 行序号必须是正整数。` };
    if (sequence.has(rowNo)) return { ok: false, message: `名单序号 ${rowNo} 重复。` };
    sequence.add(rowNo);
    if (compactText(cells[12]) === '领队') {
      if (leaderContact) return { ok: false, message: '名单备注列只能标记一位领队。' };
      const name = String(cells[1] || '').trim();
      const phone = String(cells[11] || '').trim();
      if (!name || !phone) return { ok: false, message: `名单第 ${index} 行标记为领队时，姓名和电话都必须填写。` };
      if (name.length > 200 || phone.length > 200) return { ok: false, message: `名单第 ${index} 行领队姓名或电话超过长度限制。` };
      leaderContact = { sequence: rowNo, name, phone };
    }
  }
  return {
    ok: true,
    value: {
      text,
      row_count: lines.length - 1,
      ...(leaderContact ? { leader_contact: leaderContact } : {})
    }
  };
}

function parseExportType(rawValue: string): FieldParseResult {
  const pieces = compactText(rawValue).split(/[\/、,，;；+＋]/u).map((item) => item.trim()).filter(Boolean);
  if (pieces.some((piece) => SHARED_PLAN_VISITOR_EXPORT_ALIASES.has(piece))) {
    if (pieces.length !== 1) return { ok: false, message: '整团游客信息必须单独导出，不能与游客名单或其他文件类型混用。' };
    return { ok: true, value: { types: ['visitor-list'], target_kind: 'shared_plan' } };
  }
  if (pieces.length === 1 && pieces[0] === '全部') return { ok: true, value: { types: [...ALL_EXPORT_TYPES] } };
  const values: string[] = [];
  for (const piece of pieces) {
    const mapped = EXPORT_TYPE_ALIASES.get(piece) || (ALL_EXPORT_TYPES.includes(piece) ? piece : '');
    if (!mapped) return { ok: false, message: `无法识别文件类型“${piece}”。` };
    if (!values.includes(mapped)) values.push(mapped);
  }
  return values.length ? { ok: true, value: { types: values } } : { ok: false, message: '请填写文件类型。' };
}

function splitControlledClauses(rawValue: string): string[] {
  const primary = compactText(rawValue).split(/[;；\n]+/u).map((item) => item.trim()).filter(Boolean);
  const output: string[] = [];
  for (const item of primary) {
    const commaPieces = item.split(/[，,]/u).map((piece) => piece.trim()).filter(Boolean);
    if (commaPieces.length > 1 && commaPieces.every((piece) => /(?:改为|设为|调整为|=|：|:)/u.test(piece))) output.push(...commaPieces);
    else output.push(item);
  }
  return output;
}

function controlledAssignment(clause: string): { target: string; value: string } | null {
  const match = clause.match(/^(.+?)(?:调整为|变更为|修改为|改为|设为|=|：|:)\s*(.+)$/u);
  const target = compactText(match?.[1] || '').replace(/\s+/gu, '');
  const value = compactText(match?.[2] || '');
  return target && value ? { target, value } : null;
}

function parseIndependentUpdates(rawValue: string, context: DateContext, nextOccurrence = false): BuildResult {
  const actions: JsonRecord[] = [];
  const push = (target: string, operation: string, value: unknown): BuildFailure | null => {
    if (actions.some((item) => item.target === target)) return { ok: false, code: 'program_field_conflict', message: `修改目标 ${target} 重复。`, field: 'update_targets' };
    actions.push({ target, operation, value });
    return null;
  };

  for (const clauseValue of splitControlledClauses(rawValue)) {
    const clause = clauseValue.replace(/^将/u, '').trim();
    const assignment = controlledAssignment(clause);
    if (!assignment) return { ok: false, code: 'program_unsupported_syntax', message: `无法识别修改表达“${clause}”。`, field: 'update_targets' };
    const { target, value } = assignment;

    if (/^(?:人数|预估人数|游客人数)$/u.test(target)) {
      const counts = parsePassengerCounts(value);
      if (!counts.ok) return { ok: false, code: 'program_invalid_value', message: counts.message, field: 'update_targets' };
      for (const [key, count] of Object.entries(counts.value as JsonRecord)) {
        const conflict = push(`pax.${key}`, 'set', count);
        if (conflict) return conflict;
      }
      continue;
    }
    if (/^(?:用房数量|房型数量|用房|房间)$/u.test(target)) {
      const rooms = parseRoomCounts(value);
      if (!rooms.ok) return { ok: false, code: 'program_invalid_value', message: rooms.message, field: 'update_targets' };
      for (const [key, count] of Object.entries(rooms.value as JsonRecord)) {
        const conflict = push(`rooms.${key}`, 'set', count);
        if (conflict) return conflict;
      }
      continue;
    }

    const numberTargets: Array<[RegExp, string, number]> = [
      [/^(?:标间数|双标间数|twin_room_count)$/iu, 'twin_room_count', 1],
      [/^(?:行程天数|天数|trip_days)$/iu, 'trip_days', 1],
      [/^(?:成人数|成人|pax\.adult)$/iu, 'pax.adult', 0],
      [/^(?:占床儿童数|占床儿童|pax\.child_bed)$/iu, 'pax.child_bed', 0],
      [/^(?:不占床儿童数|不占床儿童|pax\.child_no_bed)$/iu, 'pax.child_no_bed', 0],
      [/^(?:婴儿数|婴儿|pax\.infant)$/iu, 'pax.infant', 0],
      [/^(?:领队人数|pax\.leader)$/iu, 'pax.leader', 0],
      [/^(?:预计总人数|pax\.expected_total)$/iu, 'pax.expected_total', 0],
      [/^(?:单人间数|SGL|rooms\.SGL)$/iu, 'rooms.SGL', 0],
      [/^(?:双标间数|TWN|rooms\.TWN)$/iu, 'rooms.TWN', 0],
      [/^(?:三人间数|TRP|rooms\.TRP)$/iu, 'rooms.TRP', 0],
      [/^(?:大床房数|DBL|rooms\.DBL)$/iu, 'rooms.DBL', 0],
      [/^(?:不占床房数|HNM|rooms\.HNM)$/iu, 'rooms.HNM', 0],
      [/^(?:领队房数|TL|rooms\.TL)$/iu, 'rooms.TL', 0]
    ];
    const numberTarget = numberTargets.find(([pattern]) => pattern.test(target));
    if (numberTarget) {
      const normalized = compactText(value).replace(/(?:人|位|个|间|天)$/u, '');
      if (!/^\d+$/u.test(normalized) || Number(normalized) < numberTarget[2]) {
        return { ok: false, code: 'program_invalid_value', message: `修改目标必须是大于等于 ${numberTarget[2]} 的整数。`, field: 'update_targets' };
      }
      const conflict = push(numberTarget[1], 'set', Number(normalized));
      if (conflict) return conflict;
      continue;
    }

    if (/^(?:出发日期|发团日期|departure_date)$/iu.test(target)) {
      const parsed = parseDate(value, context, { nextOccurrence });
      if (!parsed.ok) return { ok: false, code: 'program_invalid_value', message: parsed.message, field: 'update_targets' };
      const conflict = push('departure_date', 'set', parsed.value);
      if (conflict) return conflict;
      continue;
    }

    const namedTargets: Array<[RegExp, string]> = [
      [/^(?:预订客户|预定客户|客户|customer)$/iu, 'customer'],
      [/^(?:产品名称|产品|product)$/iu, 'product'],
      [/^(?:领队|leader)$/iu, 'leader'],
      [/^(?:线路|行程线路|route)$/iu, 'route']
    ];
    const namedTarget = namedTargets.find(([pattern]) => pattern.test(target));
    if (namedTarget) {
      const conflict = push(namedTarget[1], 'set', namedRef(value));
      if (conflict) return conflict;
      continue;
    }

    const textTargets: Array<[RegExp, string]> = [
      [/^(?:状态|status)(?:追加|补充)?$/iu, 'status'],
      [/^(?:备注|remark)(?:追加|补充)?$/iu, 'remark'],
      [/^(?:下单备注|xiadanbeizhu)(?:追加|补充)?$/iu, 'xiadanbeizhu'],
      [/^(?:订房说明|booking_note)(?:追加|补充)?$/iu, 'booking_note']
    ];
    const textTarget = textTargets.find(([pattern]) => pattern.test(target));
    if (textTarget) {
      const operation = /(?:追加|补充)/u.test(target) ? 'append' : 'set';
      const conflict = push(textTarget[1], operation, value);
      if (conflict) return conflict;
      continue;
    }
    return { ok: false, code: 'program_unsupported_syntax', message: `未登记的独立团修改目标：“${clause}”。`, field: 'update_targets' };
  }
  return actions.length
    ? actions.length <= 32
      ? { ok: true, operation: { actions } }
      : { ok: false, code: 'program_invalid_value', message: '一次最多允许 32 个修改目标。', field: 'update_targets' }
    : { ok: false, code: 'program_unsupported_syntax', message: '目标修改中没有可执行字段。', field: 'update_targets' };
}

function parseHotelChanges(rawValue: string, context: DateContext, nextOccurrence = false): BuildResult {
  const changes: JsonRecord = {};
  for (const clause of splitControlledClauses(rawValue)) {
    const assignment = controlledAssignment(clause);
    if (!assignment) return { ok: false, code: 'program_unsupported_syntax', message: `无法识别变更表达“${clause}”。`, field: 'hotel_changes' };
    const { target, value } = assignment;
    if (/^(?:离店日期|退房日期)$/u.test(target)) {
      if (changes.end_date !== undefined) return { ok: false, code: 'program_field_conflict', message: '离店日期重复。', field: 'hotel_changes' };
      const parsed = parseDate(value, context, { nextOccurrence });
      if (!parsed.ok) return { ok: false, code: 'program_invalid_value', message: parsed.message, field: 'hotel_changes' };
      changes.end_date = parsed.value;
    } else if (/^(?:房间数|房间总数|间数)$/u.test(target)) {
      if (changes.room_count !== undefined) return { ok: false, code: 'program_field_conflict', message: '房间数重复。', field: 'hotel_changes' };
      const parsed = positiveInteger(value);
      if (!parsed.ok) return { ok: false, code: 'program_invalid_value', message: parsed.message, field: 'hotel_changes' };
      changes.room_count = parsed.value;
    } else {
      return { ok: false, code: 'program_business_rule_blocked', message: '安排变更当前只支持酒店离店日期和房间数。', field: 'hotel_changes' };
    }
  }
  return Object.keys(changes).length
    ? { ok: true, operation: changes }
    : { ok: false, code: 'program_invalid_value', message: '请填写离店日期和/或目标房间数。', field: 'hotel_changes' };
}

function normalizedComparableValue(value: string): string {
  return compactText(value).replace(/\r\n?/gu, '\n');
}

function simpleRequiredKeys(route: BusinessRouteDefinition, values: Map<string, string>): string[] {
  const missing = route.fields.filter((field) => field.required && isPlaceholder(values.get(field.key) || '')).map((field) => field.key);
  if (['passenger_list_import_independent', 'passenger_list_import_shared_child', 'order_update_shared_child',
    'order_update_independent', 'order_cancel', 'order_restore', 'confirmation_export'].includes(route.routeId)
    && !isPlaceholder(values.get('order_no') || '')) {
    return missing.filter((key) => !['customer', 'departure_date'].includes(key));
  }
  if (route.routeId === 'order_update_shared_plan' && !isPlaceholder(values.get('order_no') || '')) {
    return missing.filter((key) => key !== 'departure_date');
  }
  return missing;
}

function extractFields(route: BusinessRouteDefinition, turns: readonly ProgramHistoryTurn[]): ExtractedFields {
  const values = new Map<string, string>();
  const conflicts = new Map<string, string[]>();
  const unknownFields: string[] = [];
  const ambiguousFields: string[] = [];
  const unsupportedLines: string[] = [];
  let multipleRoute: BusinessRouteId | null = null;

  for (const turn of turns) {
    const lines = String(turn.text || '').replace(/^\uFEFF/u, '').replace(/\r\n?/gu, '\n').split('\n');
    const nonEmptyIndex = lines.findIndex((line) => line.trim());
    if (nonEmptyIndex >= 0) {
      const resolution = resolveBusinessRoute(lines[nonEmptyIndex]);
      if (resolution.routeId) {
        if (resolution.routeId !== route.routeId) multipleRoute = resolution.routeId;
        lines.splice(nonEmptyIndex, 1);
      } else if (normalizeDirectiveText(lines[nonEmptyIndex]) === normalizeDirectiveText(route.directive)) {
        lines.splice(nonEmptyIndex, 1);
      }
    }

    const turnValues = new Map<string, string>();
    const turnConflicts = new Map<string, string[]>();
    const unlabeled: string[] = [];
    for (let index = 0; index < lines.length; index += 1) {
      const line = lines[index];
      if (!line.trim()) continue;
      const delimiter = line.search(/[：:]/u);
      if (delimiter < 0) {
        const embeddedRoute = resolveBusinessRoute(line);
        if (embeddedRoute.routeId) {
          if (embeddedRoute.routeId !== route.routeId) multipleRoute = embeddedRoute.routeId;
          continue;
        }
        unlabeled.push(line);
        continue;
      }
      const label = line.slice(0, delimiter);
      const resolution = resolveRouteFieldLabel(route, label);
      if (!resolution.field) {
        const embeddedRoute = resolveBusinessRoute(label);
        if (embeddedRoute.routeId && embeddedRoute.routeId !== route.routeId) {
          multipleRoute = embeddedRoute.routeId;
          continue;
        }
        if (resolution.match === 'ambiguous') ambiguousFields.push(label.trim());
        else unknownFields.push(label.trim());
        continue;
      }
      let rawValue = line.slice(delimiter + 1).trim();
      if (resolution.field.kind === 'passenger_tsv') {
        const rows: string[] = rawValue ? [rawValue] : [];
        let nextIndex = index + 1;
        for (; nextIndex < lines.length; nextIndex += 1) {
          const nextLine = lines[nextIndex];
          const nextDelimiter = nextLine.search(/[：:]/u);
          if (nextDelimiter >= 0) {
            const nextResolution = resolveRouteFieldLabel(route, nextLine.slice(0, nextDelimiter));
            if (nextResolution.field) break;
          }
          if (nextLine.length) rows.push(nextLine);
        }
        rawValue = rows.join('\n').replace(/^\n+|\n+$/gu, '');
        index = nextIndex - 1;
      }
      const previous = turnValues.get(resolution.field.key);
      if (previous !== undefined && normalizedComparableValue(previous) !== normalizedComparableValue(rawValue)) {
        turnConflicts.set(resolution.field.key, [previous, rawValue]);
      } else {
        turnValues.set(resolution.field.key, rawValue);
      }
    }

    const meaningfulUnlabeled = unlabeled.map((line) => line.trim()).filter(Boolean);
    if (meaningfulUnlabeled.length) {
      const merged = new Map(values);
      for (const [key, value] of turnValues) merged.set(key, value);
      const missing = simpleRequiredKeys(route, merged);
      if (meaningfulUnlabeled.length === 1 && missing.length === 1 && !turnValues.has(missing[0])) {
        turnValues.set(missing[0], meaningfulUnlabeled[0]);
      } else {
        unsupportedLines.push(...meaningfulUnlabeled);
      }
    }
    for (const [key, value] of turnValues) {
      values.set(key, value);
      // A later explicit value resolves a conflict from an earlier turn. A
      // conflict created inside this same turn is restored immediately below.
      conflicts.delete(key);
    }
    for (const [key, conflictValues] of turnConflicts) conflicts.set(key, conflictValues);
  }
  return { values, conflicts, unknownFields, ambiguousFields, unsupportedLines, multipleRoute };
}

function commonLookupData(values: Map<string, unknown>, kind?: string): JsonRecord {
  const data: JsonRecord = {};
  const identifier = compactText(values.get('order_no'));
  if (identifier || kind) data.existing_refs = { ...(kind ? { kind } : {}), ...(identifier ? { identifier } : {}) };
  if (values.get('customer')) data.customer = values.get('customer');
  if (values.get('product')) data.product = values.get('product');
  if (values.get('leader')) data.leader = values.get('leader');
  if (values.get('departure_date')) data.departure_dates = [values.get('departure_date')];
  return data;
}

function specialRequests(values: Map<string, unknown>): string | undefined {
  const pieces: string[] = [];
  if (values.get('special_requests')) pieces.push(String(values.get('special_requests')));
  if (values.get('business_reason')) pieces.push(`业务原因：${String(values.get('business_reason'))}`);
  if (values.get('expected_time')) pieces.push(`期望完成时间：${String(values.get('expected_time'))}`);
  return pieces.length ? pieces.join('；') : undefined;
}

function operation(action: string, data: JsonRecord): JsonRecord {
  return { action, order_nature: 'formal', submit_mode: 'dry_run', data };
}

function buildOperation(route: BusinessRouteDefinition, values: Map<string, unknown>, context: DateContext): BuildResult {
  const special = specialRequests(values);
  switch (route.routeId) {
    case 'team_order_create':
      return { ok: true, operation: operation(route.action, {
        customer: values.get('customer'), product: values.get('product'),
        departure_dates: [values.get('departure_date')], passenger_counts: values.get('passenger_counts'),
        room_counts: values.get('room_counts'), ...(special ? { special_requests: special } : {})
      }) };
    case 'team_order_batch_create':
      if (!Array.isArray(values.get('departure_dates')) || (values.get('departure_dates') as unknown[]).length < 2) {
        return { ok: false, code: 'program_invalid_value', message: '独立团批量下单至少需要两个发团周期日期。', field: 'departure_dates' };
      }
      return { ok: true, operation: operation(route.action, {
        customer: values.get('customer'), product: values.get('product'), departure_dates: values.get('departure_dates'),
        recurrence: { ...(values.get('departure_range') as JsonRecord), pattern: 'specified_dates' },
        passenger_counts: values.get('passenger_counts'), room_counts: values.get('room_counts'),
        ...(special ? { special_requests: special } : {})
      }) };
    case 'shared_plan_create': {
      const source = values.get('departure_source');
      const sourceIsRange = isRecord(source);
      const dates = values.get('departure_dates') || (Array.isArray(source) ? source : undefined);
      if (sourceIsRange && !dates) return { ok: false, code: 'program_missing_required', message: '日期范围下必须填写发团周期。', field: 'departure_dates' };
      const splitOrder = values.get('split_customer') || values.get('split_passenger_counts') ? {
        ...(values.get('split_customer') ? { customer: values.get('split_customer') } : {}),
        ...(values.get('split_passenger_counts') ? { passenger_counts: values.get('split_passenger_counts') } : {})
      } : undefined;
      return { ok: true, operation: operation(route.action, {
        product: values.get('product'), ...(dates ? { departure_dates: dates } : {}),
        ...(sourceIsRange ? { recurrence: { ...(source as JsonRecord), pattern: 'specified_dates' } } : {}),
        planned_capacity: values.get('planned_capacity'), room_counts: values.get('room_counts'),
        ...(splitOrder ? { split_order: splitOrder } : {})
      }) };
    }
    case 'shared_child_order_create': {
      const data: JsonRecord = {
        ...commonLookupData(new Map([
          ['customer', values.get('customer')], ['product', values.get('product')], ['leader', values.get('leader')],
          ['departure_date', values.get('departure_date')]
        ].filter((entry) => entry[1] !== undefined) as Array<[string, unknown]>)),
        passenger_counts: values.get('passenger_counts'), ...(special ? { special_requests: special } : {})
      };
      const parent = compactText(values.get('parent_group_no'));
      if (parent) data.existing_refs = { kind: 'shared_plan', identifier: parent, parent_group_no: parent };
      return { ok: true, operation: operation(route.action, data) };
    }
    case 'passenger_list_import_independent':
    case 'passenger_list_import_shared_child': {
      const parsedList = values.get('passenger_tsv') as JsonRecord;
      const overwrite = values.get('overwrite_confirmed') === true;
      return { ok: true, operation: operation(route.action, {
        ...commonLookupData(values, route.routeId === 'passenger_list_import_independent' ? 'independent_order' : 'shared_child_order'),
        passenger_list: {
          operation: overwrite ? 'full_replace' : 'import', ...(overwrite ? { confirmed: true } : {}),
          row_count: parsedList.row_count, text: parsedList.text,
          ...(parsedList.leader_contact ? { leader_contact: parsedList.leader_contact } : {})
        }
      }) };
    }
    case 'arrangement_guide_create':
      return { ok: true, operation: operation(route.action, {
        existing_refs: { identifier: values.get('group_no') },
        arrangement: { mode: 'create', resource: values.get('resource'), ...(values.get('remark') ? { remark: values.get('remark') } : {}) }
      }) };
    case 'arrangement_vehicle_create': {
      const range = values.get('vehicle_range') as JsonRecord;
      return { ok: true, operation: operation(route.action, {
        existing_refs: { identifier: values.get('group_no') },
        arrangement: {
          mode: 'create', supplier: values.get('supplier'), start_date: range.start_date, end_date: range.end_date,
          quantity: values.get('quantity'), ...(values.get('remark') ? { remark: values.get('remark') } : {})
        }
      }) };
    }
    case 'arrangement_hotel_create':
      if (String(values.get('end_date')) <= String(values.get('start_date'))) {
        return { ok: false, code: 'program_invalid_value', message: '酒店离店日期必须晚于入住日期。', field: 'end_date' };
      }
      return { ok: true, operation: operation(route.action, {
        existing_refs: { identifier: values.get('group_no') },
        arrangement: {
          mode: 'create', resource: values.get('resource'), start_date: values.get('start_date'), end_date: values.get('end_date'),
          room_count: values.get('room_count'), ...(values.get('remark') ? { remark: values.get('remark') } : {})
        }
      }) };
    case 'arrangement_transport_create':
      return { ok: true, operation: operation(route.action, {
        existing_refs: { identifier: values.get('group_no') }, arrangement: {
          mode: 'create', supplier: values.get('supplier'), quantity: values.get('quantity'), date: values.get('date'),
          ...(values.get('item') ? { item: values.get('item') } : {}), ...(values.get('remark') ? { remark: values.get('remark') } : {})
        }
      }) };
    case 'arrangement_other_create': {
      const filing = {
        ...(values.get('filing_number') ? { number: values.get('filing_number') } : {}),
        ...(values.get('filing_date') ? { date: values.get('filing_date') } : {}),
        ...(values.get('entry_port') ? { entry_port: values.get('entry_port') } : {}),
        ...(values.get('exit_port') ? { exit_port: values.get('exit_port') } : {})
      };
      return { ok: true, operation: operation(route.action, {
        existing_refs: { identifier: values.get('group_no') }, arrangement: {
          mode: 'create', supplier: values.get('supplier'), date: values.get('date'),
          ...(values.get('item') ? { item: values.get('item') } : {}),
          ...(values.get('quantity') ? { quantity: values.get('quantity') } : {}),
          ...(values.get('remark') ? { remark: values.get('remark') } : {}),
          ...(Object.keys(filing).length ? { filing } : {})
        }
      }) };
    }
    case 'order_update_shared_plan':
      return { ok: true, operation: operation(route.action, {
        ...commonLookupData(values, 'shared_plan'),
        updates: { actions: [{ target: 'planned_capacity', operation: 'set', value: values.get('planned_capacity') }] }
      }) };
    case 'order_update_shared_child':
      if (String(values.get('lodging_note') || '').length > 50) {
        return { ok: false, code: 'program_invalid_value', message: '单次追加订房说明不得超过 50 个字符。', field: 'lodging_note' };
      }
      return { ok: true, operation: operation(route.action, {
        ...commonLookupData(values, 'shared_child_order'),
        updates: { actions: [{ target: 'lodging_note', operation: 'append', value: values.get('lodging_note') }] }
      }) };
    case 'order_update_independent': {
      const updates = parseIndependentUpdates(String(values.get('update_targets') || ''), context, true);
      if (!updates.ok) return updates;
      return { ok: true, operation: operation(route.action, {
        ...commonLookupData(values, 'independent_order'), updates: updates.operation,
        ...(special ? { special_requests: special } : {})
      }) };
    }
    case 'arrangement_hotel_update': {
      const type = compactText(values.get('arrangement_type'));
      if (type && !['酒店', '安排酒店'].includes(type)) {
        return { ok: false, code: 'program_business_rule_blocked', message: '安排变更程序模式当前只支持酒店。', field: 'arrangement_type' };
      }
      const changes = parseHotelChanges(String(values.get('hotel_changes') || ''), context, true);
      if (!changes.ok) return changes;
      return { ok: true, operation: operation(route.action, {
        existing_refs: { identifier: values.get('group_no') }, arrangement: { mode: 'update', changes: changes.operation },
        ...(special ? { special_requests: special } : {})
      }) };
    }
    case 'order_cancel':
      return { ok: true, operation: operation(route.action, commonLookupData(values)) };
    case 'order_restore': {
      const status = compactText(values.get('restore_status'));
      if (status && !['预订', '已确认', '收客中'].includes(status)) {
        return { ok: false, code: 'program_invalid_value', message: '恢复状态只允许预订、已确认或收客中。', field: 'restore_status' };
      }
      return { ok: true, operation: operation(route.action, {
        ...commonLookupData(values), ...(status ? { transition: { to_status: status } } : {})
      }) };
    }
    case 'confirmation_export': {
      const selection = values.get('export_type') as JsonRecord;
      const types = selection.types as string[];
      const targetKind = selection.target_kind === 'shared_plan' ? 'shared_plan' : undefined;
      const data: JsonRecord = { ...commonLookupData(values, targetKind) };
      if (types.length === 1) data.confirmation = { type: types[0] };
      else data.export_types = types;
      if (types.includes('pickup-sign')) {
        const visitor = compactText(values.get('visitor_name'));
        if (!visitor) return { ok: false, code: 'program_missing_required', message: '接机牌需要填写游客姓名。', field: 'visitor_name' };
        data.visitor_name = visitor;
      } else if (values.get('visitor_name')) data.visitor_name = values.get('visitor_name');
      return { ok: true, operation: operation(route.action, data) };
    }
  }
}

function parseField(field: ProgramFieldDefinition, rawValue: string, route: BusinessRouteDefinition, context: DateContext, parsed: Map<string, unknown>): FieldParseResult {
  if (isPlaceholder(rawValue)) return { ok: false, message: '该字段尚未填写。' };
  const nextOccurrence = NEXT_OCCURRENCE_DATE_ROUTES.has(route.routeId);
  switch (field.kind) {
    case 'text': return { ok: true, value: compactText(rawValue) };
    case 'named_ref': return { ok: true, value: namedRef(rawValue) };
    case 'date': return parseDate(rawValue, context, { nextOccurrence });
    case 'date_range': return parseDateRange(rawValue, context, nextOccurrence);
    case 'date_or_range': return parseDateOrRange(rawValue, context, nextOccurrence);
    case 'date_list': return parseDateList(rawValue, context, nextOccurrence,
      isRecord(parsed.get('departure_range')) ? parsed.get('departure_range') as JsonRecord
        : isRecord(parsed.get('departure_source')) ? parsed.get('departure_source') as JsonRecord : undefined);
    case 'passenger_counts': return parsePassengerCounts(rawValue);
    case 'room_counts': return parseRoomCounts(rawValue);
    case 'positive_integer': return positiveInteger(rawValue);
    case 'boolean': return booleanValue(rawValue);
    case 'passenger_tsv': return parsePassengerTsv(rawValue);
    case 'export_type': return parseExportType(rawValue);
    case 'update_targets':
    case 'hotel_changes': return { ok: true, value: rawValue };
  }
}

function baseEnvelope(route: BusinessRouteDefinition | null): {
  parse_mode: 'program';
  business_route_id: BusinessRouteId | null;
  program_parser_version: string;
  input_contract_version: string | null;
  external_request: JsonRecord;
} {
  return {
    parse_mode: 'program',
    business_route_id: route?.routeId || null,
    program_parser_version: route?.programVersion || BUSINESS_ROUTES[0].programVersion,
    input_contract_version: route?.inputContractVersion || null,
    external_request: { provider: 'program', external_call_made: false, attempt_count: 1 }
  };
}

function blocked(route: BusinessRouteDefinition | null, code: string, message: string, extra: JsonRecord = {}): ProgramParseResult {
  return {
    ...baseEnvelope(route),
    status: 'agent_parse_blocked', blockers: [message], operation: null, reply: message, error_code: code,
    failure_stage: 'program_parse', failure_source: 'program_parser', failure_message: message,
    agent_returned: true, plugin_dispatch_started: false, erp_write_started: false,
    no_plugin_dispatch: true, no_erp_write: true, ...extra
  } as ProgramParseResult;
}

function needsInput(route: BusinessRouteDefinition, code: string, fields: string[], messages: Map<string, string>, captured: JsonRecord): ProgramParseResult {
  const unique = [...new Set(fields)];
  const questions = unique.map((key) => {
    const field = route.fields.find((candidate) => candidate.key === key);
    return { field: key, prompt: messages.get(key) || `请补充${field?.label || key}。` };
  });
  const reply = questions.map((question) => question.prompt).join('；');
  return {
    ...baseEnvelope(route),
    status: 'agent_parse_needs_input', blockers: [], operation: null,
    missing_fields: unique, questions, captured_facts: captured, reply, error_code: code,
    no_plugin_dispatch: true, no_erp_write: true
  } as ProgramParseResult;
}

async function parseProgramInputInner(input: ProgramParseInput): Promise<ProgramParseResult> {
  const suppliedRoute = input.routeId ? businessRouteById(input.routeId) : null;
  const routeMessage = input.rawText || input.history?.[0]?.text || '';
  const routeResolution = suppliedRoute ? null : resolveBusinessRoute(routeMessage);
  // If the complete message contains two explicit actions, retain the first
  // directive as the primary route so extractFields() can return the stronger
  // program_multiple_actions blocker. Signature ambiguity remains unresolved.
  const firstLineRoute = routeResolution?.match === 'ambiguous'
    ? resolveBusinessRoute(firstNonEmptyLine(routeMessage)).route
    : null;
  const route = suppliedRoute || routeResolution?.route || firstLineRoute || null;
  if (!route) {
    const code = routeResolution?.match === 'ambiguous' ? 'program_ambiguous_input' : 'program_unsupported_syntax';
    return blocked(null, code, '无法唯一识别业务路由，已阻止程序解析。');
  }
  const turns: ProgramHistoryTurn[] = [
    ...(input.history || []).map((turn) => ({ text: String(turn.text || ''), receivedAt: turn.receivedAt })),
    { text: String(input.rawText || ''), receivedAt: input.receivedAt }
  ].filter((turn, index, all) => turn.text.trim() && !(index === all.length - 1 && index > 0 && turn.text === all[index - 1].text));
  const extracted = extractFields(route, turns);
  if (extracted.multipleRoute) return blocked(route, 'program_multiple_actions', '同一任务补充中出现了另一个业务动作，不能合并解析。');
  if (extracted.unknownFields.length) {
    return blocked(route, 'program_unknown_field', `当前业务不认识字段：${[...new Set(extracted.unknownFields)].join('、')}。`, {
      unknown_field_count: new Set(extracted.unknownFields).size
    });
  }
  if (extracted.ambiguousFields.length) {
    return blocked(route, 'program_ambiguous_input', `字段标签无法唯一纠错：${[...new Set(extracted.ambiguousFields)].join('、')}。`);
  }
  if (extracted.unsupportedLines.length) {
    return blocked(route, 'program_unsupported_syntax', '存在无法安全归入唯一缺失字段的无标签内容。', {
      unsupported_line_count: extracted.unsupportedLines.length
    });
  }
  if (extracted.conflicts.size) {
    const messages = new Map<string, string>();
    for (const key of extracted.conflicts.keys()) messages.set(key, `同一轮中${route.fields.find((field) => field.key === key)?.label || key}出现冲突值，请明确一个值。`);
    return needsInput(route, 'program_field_conflict', [...extracted.conflicts.keys()], messages, {});
  }

  const missing = simpleRequiredKeys(route, extracted.values);
  if (missing.length) {
    const messages = new Map(missing.map((key) => [key, `请补充${route.fields.find((field) => field.key === key)?.label || key}。`]));
    return needsInput(route, 'program_missing_required', missing, messages, Object.fromEntries(extracted.values));
  }

  const context = dateContext(input.receivedAt || turns.at(-1)?.receivedAt);
  const parsed = new Map<string, unknown>();
  const invalid: string[] = [];
  const messages = new Map<string, string>();
  for (const field of route.fields) {
    const rawValue = extracted.values.get(field.key);
    if (isPlaceholder(rawValue || '')) continue;
    const result = parseField(field, rawValue!, route, context, parsed);
    if (!result.ok) {
      invalid.push(field.key);
      messages.set(field.key, `${field.label}无效：${result.message}`);
    } else parsed.set(field.key, result.value);
  }
  if (invalid.length) return needsInput(route, 'program_invalid_value', invalid, messages, Object.fromEntries(parsed));

  const built = buildOperation(route, parsed, context);
  if (!built.ok) {
    if (built.code === 'program_invalid_value' || built.code === 'program_missing_required' || built.code === 'program_field_conflict') {
      const field = built.field || 'business_input';
      return needsInput(route, built.code, [field], new Map([[field, built.message]]), Object.fromEntries(parsed));
    }
    return blocked(route, built.code, built.message);
  }
  const validationErrors = await validateParsedOperation(built.operation);
  if (validationErrors.length) {
    return blocked(route, 'program_contract_invalid', '程序解析结果未通过统一 operation 契约。', {
      validation_errors: validationErrors,
      contract_error_count: validationErrors.length
    });
  }
  return {
    ...baseEnvelope(route), status: 'agent_parse_passed', blockers: [], operation: built.operation,
    reply: '系统已完成确定性解析。', no_plugin_dispatch: true, no_erp_write: true
  } as ProgramParseResult;
}

export async function parseProgramInput(input: ProgramParseInput): Promise<ProgramParseResult> {
  const timeoutMs = Math.max(10, Math.min(Number(input.timeoutMs || 2_000), 30_000));
  let timer: NodeJS.Timeout | undefined;
  try {
    return await Promise.race([
      parseProgramInputInner(input),
      new Promise<ProgramParseResult>((resolve) => {
        timer = setTimeout(() => {
          const route = input.routeId ? businessRouteById(input.routeId) : null;
          resolve(blocked(route, 'program_timeout', '程序解析超过时间限制。'));
        }, timeoutMs);
      })
    ]);
  } catch (error) {
    const route = input.routeId ? businessRouteById(input.routeId) : null;
    return blocked(route, 'program_internal_error', '程序解析发生内部错误。', {
      internal_error_name: error instanceof Error ? error.name : 'UnknownError'
    });
  } finally {
    if (timer) clearTimeout(timer);
  }
}

export function programFallbackAllowed(result: unknown): boolean {
  return isRecord(result) && PROGRAM_PARSER_FALLBACK_CODES.has(String(result.error_code || ''));
}

export function programParserVersion(routeId: unknown): string | null {
  return businessRouteById(routeId)?.programVersion || null;
}

export function programRouteForMessage(message: unknown): BusinessRouteId | null {
  return resolveBusinessRoute(message).routeId;
}