const fs = require('node:fs');

const POLICY_LABELS = [
  '商业险保单号',
  '保险单号',
  '保险单号码',
  '电子保单号',
  '保单号',
  '保险合同号',
  '合同号',
];

const VIN_LABELS = ['车辆识别代号', '车辆识别代码', '车架号', 'VIN码', 'VIN', '识别代码'];
const USAGE_NATURE_LABELS = ['使用性质', '车辆使用性质', '使用方式', '使用用途', '车辆用途'];
const USAGE_NATURE_VALUES = [
  '家庭自用汽车',
  '家庭自用',
  '非营业个人',
  '非营业',
  '非营运',
  '企业非营业',
  '党政机关事业团体非营业',
  '预约出租客运',
  '网约车',
  '出租',
  '租赁',
  '客运',
  '货运',
  '营业',
  '营运',
];
const INSURANCE_PERIOD_LABELS = [
  '保险期间',
  '保险期限',
  '保险有效期',
  '保险起期',
  '保险止期',
  '起保日期',
  '终止日期',
  '起止日期',
  '承保期间',
];
const NAME_LABELS = [
  { label: '被保险人', terms: ['被保险人名称', '被保险人姓名', '被保险人'] },
  { label: '车主', terms: ['车主姓名', '车主名称', '车主'] },
  { label: '投保人', terms: ['投保人名称', '投保人姓名', '投保人'] },
];
const COVERAGE_TERMS = ['机动车损失保险', '车辆损失保险', '车损险'];

function toHalfWidth(text) {
  return String(text || '')
    .normalize('NFKC')
    .replace(/\u3000/g, ' ')
    .replace(/[：﹕]/g, ':')
    .replace(/[，、；;]/g, ' ')
    .replace(/[（(].*?[）)]/g, match => match);
}

function normalizeToken(value) {
  return String(value || '')
    .normalize('NFKC')
    .replace(/[^A-Za-z0-9-]/g, '')
    .toUpperCase();
}

function compactText(value) {
  return String(value || '').normalize('NFKC').replace(/\s+/g, '').toUpperCase();
}

function normalizeName(value) {
  return String(value || '').normalize('NFKC').replace(/\s+/g, '').trim();
}

function normalizeDate(year, month, day) {
  return [
    String(year).padStart(4, '0'),
    String(month).padStart(2, '0'),
    String(day).padStart(2, '0'),
  ].join('-');
}

function readInputText(input) {
  if (typeof input.rawText === 'string' && input.rawText.trim()) return input.rawText;
  if (Array.isArray(input.lines)) return input.lines.filter(Boolean).join('\n');
  return '';
}

function linesFromText(text) {
  return toHalfWidth(text)
    .split(/\r?\n+/)
    .map(line => line.trim())
    .filter(Boolean);
}

function hasAnyLabel(line, labels) {
  return labels.some(label => line.includes(label));
}

function extractCandidates(text) {
  const result = [];
  const re = /[A-Z0-9][A-Z0-9-]{7,49}/gi;
  let match;
  while ((match = re.exec(toHalfWidth(text).toUpperCase())) !== null) {
    result.push(normalizeToken(match[0]));
  }
  return [...new Set(result)];
}

function isVin(value) {
  const token = normalizeToken(value).replace(/-/g, '');
  return /^[A-HJ-NPR-Z0-9]{17}$/.test(token);
}

function isIdCard(value) {
  return /^\d{17}[\dX]$/i.test(String(value || '').trim());
}

function isDateLike(value) {
  return /^\d{4}[-/.]\d{1,2}[-/.]\d{1,2}$/.test(String(value || ''));
}

function isValidPolicyNo(value, options = {}) {
  const token = normalizeToken(value);
  if (token.length < 8 || token.length > 50) return false;
  if (!/^[A-Z0-9-]+$/.test(token)) return false;
  const expectedVin = normalizeToken(options.expectedVin).replace(/-/g, '');
  if (isVin(token.replace(/-/g, ''))) {
    if (!options.allowVinShape || token.replace(/-/g, '') === expectedVin) return false;
  }
  if (isIdCard(token) || isDateLike(token)) return false;
  const digits = (token.match(/\d/g) || []).length;
  const letters = (token.match(/[A-Z]/g) || []).length;
  if (digits < 4) return false;
  if (letters === 0 && token.length === 11) return false;
  return letters > 0 || token.length >= 12;
}

function scorePolicyNo(value) {
  const token = normalizeToken(value);
  let score = token.length;
  if (/[A-Z]/.test(token)) score += 8;
  if (/\d/.test(token)) score += 4;
  if (token.includes('-')) score -= 2;
  if (/^P[A-Z0-9]/.test(token)) score += 3;
  return score;
}

function bestPolicyCandidate(candidates, expectedPolicyNo, options = {}) {
  const expected = normalizeToken(expectedPolicyNo);
  if (expected) {
    const exact = candidates.map(normalizeToken).find(item => item === expected);
    if (exact) return exact;
  }
  const valid = candidates
    .map(normalizeToken)
    .filter(item => isValidPolicyNo(item, options));
  if (!valid.length) return '';
  return valid.sort((a, b) => scorePolicyNo(b) - scorePolicyNo(a))[0] || '';
}

function extractPolicyNo(lines, fullText, expectedPolicyNo, expectedVin) {
  for (let i = 0; i < lines.length; i += 1) {
    if (!hasAnyLabel(lines[i], POLICY_LABELS)) continue;
    const windowText = [lines[i], lines[i + 1] || '', lines[i + 2] || ''].join(' ');
    const candidate = bestPolicyCandidate(extractCandidates(windowText), expectedPolicyNo, {
      allowVinShape: true,
      expectedVin,
    });
    if (candidate) return candidate;
  }
  return bestPolicyCandidate(extractCandidates(fullText), expectedPolicyNo, { expectedVin });
}

function extractVin(lines, fullText, expectedVin) {
  const expected = normalizeToken(expectedVin).replace(/-/g, '');
  if (expected && isVin(expected) && compactText(fullText).includes(expected)) return expected;

  for (let i = 0; i < lines.length; i += 1) {
    if (!hasAnyLabel(lines[i], VIN_LABELS)) continue;
    const windowText = [lines[i], lines[i + 1] || ''].join(' ');
    const candidate = extractCandidates(windowText)
      .map(item => item.replace(/-/g, ''))
      .find(isVin);
    if (candidate) return candidate;
  }

  return extractCandidates(fullText)
    .map(item => item.replace(/-/g, ''))
    .find(isVin) || '';
}

function cleanNameText(text) {
  return String(text || '')
    .replace(/^(名称|姓名|客户名称|客户姓名)[:：]?/, '')
    .split(/(?:证件|身份证|统一社会信用|地址|电话|手机|车架|车辆|号牌|保单|保险|发动机|VIN|使用性质|车辆使用性质|使用方式|使用用途|保险期间|保险期限|保险有效期|起保|终止|承保)/)[0]
    .replace(/[0-9A-Za-z_*xX:：/\\-]/g, ' ')
    .trim();
}

function findNamesInText(text) {
  const cleaned = cleanNameText(text);
  const blacklist = new Set([
    '被保险人',
    '投保人',
    '车主姓名',
    '车主名称',
    '车主',
    '姓名',
    '名称',
    '机动车',
    '商业险',
    '保险单',
    '保险人',
    '使用性质',
    '家庭自用汽车',
    '有限公司',
  ]);
  const names = [];
  const re = /[\u4e00-\u9fa5·]{2,12}/g;
  let match;
  while ((match = re.exec(cleaned)) !== null) {
    const name = normalizeName(match[0]);
    if (!blacklist.has(name) && !name.includes('保险') && !name.includes('地址')) {
      names.push(name);
    }
  }
  return names;
}

function addNameCandidate(candidates, label, name) {
  const normalized = normalizeName(name);
  if (!normalized) return;
  if (candidates.some(item => item.label === label && item.name === normalized)) return;
  if (candidates.some(item => item.name === normalized)) {
    const existing = candidates.find(item => item.name === normalized);
    if (existing && !existing.label.includes(label)) existing.label = `${existing.label}/${label}`;
    return;
  }
  candidates.push({ label, name: normalized });
}

function extractNameCandidates(lines, fullText, expectedOwnerName) {
  const candidates = [];
  const compact = compactText(fullText);
  const expected = normalizeName(expectedOwnerName);
  if (expected && compact.includes(compactText(expected))) {
    addNameCandidate(candidates, '全文匹配', expected);
  }

  for (let i = 0; i < lines.length; i += 1) {
    for (const group of NAME_LABELS) {
      const term = group.terms.find(item => lines[i].includes(item));
      if (!term) continue;
      const sameLineTail = lines[i].slice(lines[i].indexOf(term) + term.length).replace(/^[:：\s]+/, '');
      const windowTexts = [sameLineTail, lines[i + 1] || ''];
      for (const text of windowTexts) {
        for (const name of findNamesInText(text)) {
          addNameCandidate(candidates, group.label, name);
        }
      }
    }
  }
  return candidates.slice(0, 8);
}

function extractCertificate(fullText) {
  const normalized = toHalfWidth(fullText).replace(/\s+/g, '');
  const full = normalized.match(/\d{17}[\dXx]/);
  if (full) return { certificateNo: full[0].toUpperCase(), certificateNoMasked: false };

  const masked = normalized.match(/(?:\d{2,8})[*Xx]{4,14}(?:\d{2,6})|[*Xx]{6,16}(?:\d{2,6})/);
  if (masked) return { certificateNo: masked[0].toUpperCase(), certificateNoMasked: true };
  return { certificateNo: '', certificateNoMasked: false };
}

function extractPlateNo(lines, fullText) {
  const plateRe = /[\u4e00-\u9fa5][A-Z][A-Z0-9]{5,7}/g;
  for (const line of lines) {
    if (!/(车牌|号牌|牌照|牌号)/.test(line)) continue;
    const match = toHalfWidth(line).toUpperCase().match(plateRe);
    if (match) return match[0];
  }
  const match = toHalfWidth(fullText).toUpperCase().match(plateRe);
  return match ? match[0] : '';
}

function extractEngineNo(lines) {
  for (let i = 0; i < lines.length; i += 1) {
    if (!/(发动机号|发动机号码|发动机编号)/.test(lines[i])) continue;
    const windowText = [lines[i], lines[i + 1] || ''].join(' ');
    const candidates = extractCandidates(windowText).filter(item => !isVin(item) && !isValidPolicyNo(item));
    const candidate = candidates.find(item => item.length >= 5 && item.length <= 24);
    if (candidate) return candidate;
  }
  return '';
}

function extractDateCandidatesFromText(text) {
  const dates = [];
  const re = /(\d{4})[年\-/.](\d{1,2})[月\-/.](\d{1,2})日?/g;
  let match;
  while ((match = re.exec(toHalfWidth(text))) !== null) {
    const date = normalizeDate(match[1], match[2], match[3]);
    if (!dates.includes(date)) dates.push(date);
  }
  return dates;
}

function extractLabelTail(line, labels) {
  const matchedLabel = labels.find(label => line.includes(label));
  if (!matchedLabel) return '';
  return line.slice(line.indexOf(matchedLabel) + matchedLabel.length).replace(/^[:：\s]+/, '').trim();
}

function extractUsageNatureFromText(text) {
  const normalized = toHalfWidth(text).replace(/\s+/g, '');
  for (const value of USAGE_NATURE_VALUES) {
    if (normalized.includes(value)) return value;
  }
  return '';
}

function extractUsageNature(lines, fullText) {
  for (let i = 0; i < lines.length; i += 1) {
    if (!hasAnyLabel(lines[i], USAGE_NATURE_LABELS)) continue;
    const windowText = [extractLabelTail(lines[i], USAGE_NATURE_LABELS), lines[i + 1] || ''].join(' ');
    const value = extractUsageNatureFromText(windowText);
    if (value) return value;
  }
  return extractUsageNatureFromText(fullText);
}

function extractDates(lines, fullText) {
  for (let i = 0; i < lines.length; i += 1) {
    if (!hasAnyLabel(lines[i], INSURANCE_PERIOD_LABELS)) continue;
    const windowText = [extractLabelTail(lines[i], INSURANCE_PERIOD_LABELS), lines[i + 1] || ''].join(' ');
    const dates = extractDateCandidatesFromText(windowText);
    if (dates.length >= 2) return { startDate: dates[0], endDate: dates[1] };
    if (dates.length === 1) {
      const nextDates = extractDateCandidatesFromText(lines[i + 1] || '');
      if (nextDates.length) return { startDate: dates[0], endDate: nextDates[0] };
    }
  }

  const dates = extractDateCandidatesFromText(fullText);
  return { startDate: dates[0] || '', endDate: dates[1] || '' };
}

function extractCoverage(fullText) {
  const compact = String(fullText || '').replace(/\s+/g, '');
  const evidence = COVERAGE_TERMS.filter(term => compact.includes(term));
  return {
    hasVehicleDamageCoverage: evidence.length > 0,
    coverageEvidence: evidence,
  };
}

function buildWarnings({ input, output }) {
  const warnings = [];
  if (!output.policyNo) warnings.push('未识别到商业险保单号');
  if (!output.vin) warnings.push('未识别到车架号VIN');
  if (!output.nameCandidates.length) warnings.push('未识别到被保险人/车主/投保人姓名');
  if (!output.usageNature) warnings.push('未识别到使用性质');
  if (!output.startDate || !output.endDate) warnings.push('未识别到保险期间');
  if (!output.hasVehicleDamageCoverage) warnings.push('未识别到车损险险种证据');

  const expectedPolicyNo = normalizeToken(input.expectedPolicyNo);
  if (expectedPolicyNo && output.policyNo && expectedPolicyNo !== output.policyNo) {
    warnings.push('OCR保单号与订单已填商业险保单号不一致');
  }
  const expectedVin = normalizeToken(input.expectedVin).replace(/-/g, '');
  if (expectedVin && output.vin && expectedVin !== output.vin) {
    warnings.push('OCR车架号VIN与订单VIN不一致');
  }
  const expectedOwnerName = normalizeName(input.expectedOwnerName);
  if (expectedOwnerName && output.nameCandidates.length) {
    const matched = output.nameCandidates.some(item => normalizeName(item.name) === expectedOwnerName);
    if (!matched) warnings.push('OCR姓名候选与订单车主姓名不一致');
  }
  return warnings;
}

function computeConfidence(output) {
  let score = 0.2;
  if (output.policyNo) score += 0.25;
  if (output.vin) score += 0.25;
  if (output.nameCandidates.length) score += 0.15;
  if (output.usageNature) score += 0.05;
  if (output.startDate && output.endDate) score += 0.05;
  if (output.hasVehicleDamageCoverage) score += 0.1;
  if (output.certificateNo) score += 0.03;
  if (output.plateNo || output.engineNo) score += 0.02;
  return Math.max(0, Math.min(0.99, Number(score.toFixed(2))));
}

function parsePolicy(input) {
  const rawText = readInputText(input);
  if (!rawText.trim()) {
    return {
      success: false,
      policyNo: '',
      vin: '',
      nameCandidates: [],
      certificateNo: '',
      certificateNoMasked: false,
      plateNo: '',
      engineNo: '',
      usageNature: '',
      startDate: '',
      endDate: '',
      hasVehicleDamageCoverage: false,
      coverageEvidence: [],
      confidence: 0,
      warnings: [input.imageUrl ? '当前脚本不直接OCR图片，请先传入rawText' : '缺少rawText或lines'],
      rawText: '',
    };
  }

  const fullText = toHalfWidth(rawText);
  const lines = linesFromText(fullText);
  const certificate = extractCertificate(fullText);
  const usageNature = extractUsageNature(lines, fullText);
  const dates = extractDates(lines, fullText);
  const coverage = extractCoverage(fullText);
  const output = {
    success: true,
    policyNo: extractPolicyNo(lines, fullText, input.expectedPolicyNo, input.expectedVin),
    vin: extractVin(lines, fullText, input.expectedVin),
    nameCandidates: extractNameCandidates(lines, fullText, input.expectedOwnerName),
    ...certificate,
    plateNo: extractPlateNo(lines, fullText),
    engineNo: extractEngineNo(lines),
    usageNature,
    ...dates,
    ...coverage,
    confidence: 0,
    warnings: [],
    rawText: fullText,
  };
  output.warnings = buildWarnings({ input, output });
  output.confidence = computeConfidence(output);
  return output;
}

async function main() {
  try {
    const stdin = fs.readFileSync(0, 'utf8');
    const input = JSON.parse(stdin || '{}');
    process.stdout.write(JSON.stringify(parsePolicy(input)));
  } catch (error) {
    process.stdout.write(JSON.stringify({ success: false, error: error.message }));
    process.exitCode = 0;
  }
}

if (require.main === module) {
  main();
}

module.exports = {
  parsePolicy,
  extractPolicyNo,
  extractVin,
  extractNameCandidates,
};