X-Financial/web/src/views/scripts/travelRequestDetailInsights.js

import {
  isActionableRiskFlag,
  isRiskSummaryWithRisk,
  normalizeRiskFlagTone
} from '../../utils/riskFlags.js'
import {
  resolveRiskActionability,
  resolveRiskDomain,
  resolveRiskVisibilityScope
} from '../../utils/riskVisibility.js'

const DOCUMENT_TYPE_LABELS = {
  flight_itinerary: '机票/航班行程单',
  train_ticket: '火车/高铁票',
  ship_ticket: '轮船票',
  hotel_invoice: '酒店住宿票据',
  taxi_receipt: '出租车/网约车票据',
  parking_toll_receipt: '停车/通行费票据',
  meal_receipt: '餐饮票据',
  office_invoice: '办公用品票据',
  meeting_invoice: '会议/会务票据',
  training_invoice: '培训票据',
  vat_invoice: '增值税发票',
  receipt: '一般收据/凭证',
  other: '其他单据'
}

function normalizeText(value) {
  return String(value || '').trim()
}

function uniqueTexts(values) {
  return [...new Set(values.map((item) => normalizeText(item)).filter(Boolean))]
}

function normalizeBusinessStage(value) {
  const stage = normalizeText(value).toLowerCase()
  if ([
    'expense_application',
    'application',
    'apply',
    'pre_apply',
    'pre_application',
    'budget_application'
  ].includes(stage)) {
    return 'expense_application'
  }
  if ([
    'reimbursement',
    'expense_reimbursement',
    'claim',
    'expense_claim',
    'expense_report'
  ].includes(stage)) {
    return 'reimbursement'
  }
  return ''
}

function resolveFlagBusinessStage(flag, fallback = 'reimbursement') {
  if (!flag || typeof flag !== 'object') {
    return resolveRiskTextBusinessStage(flag, fallback)
  }

  const explicitStage = normalizeBusinessStage(
    flag.businessStage
    || flag.business_stage
    || flag.controlStage
    || flag.control_stage
  )
  if (explicitStage) {
    return explicitStage
  }

  const source = normalizeText(flag.source).toLowerCase()
  const eventType = normalizeText(flag.event_type || flag.eventType).toLowerCase()
  if (source === 'attachment_analysis' || /expense_claim|reimbursement|payment/.test(eventType)) {
    return 'reimbursement'
  }
  if (/application/.test(source) || /expense_application/.test(eventType)) {
    return 'expense_application'
  }

  return resolveRiskTextBusinessStage(cardLikeText(flag), fallback)
}

function resolveRiskTextBusinessStage(value, fallback = 'reimbursement') {
  const text = normalizeText(value)
  if (/报销|附件|单据|票据|发票|OCR|识别|付款|支付|酒店|住宿票|交通票/.test(text)) {
    return 'reimbursement'
  }
  if (/申请|预算|额度|事前|预估|申请金额|申请事由/.test(text)) {
    return 'expense_application'
  }
  return fallback
}

function cardLikeText(card = {}) {
  return [
    card.label,
    card.title,
    card.risk,
    card.message,
    card.summary,
    card.suggestion,
    card.description,
    card.detail
  ].map((item) => normalizeText(item)).join(' ')
}

function resolveRequestBusinessStage(request = {}) {
  const explicitStage = normalizeBusinessStage(
    request?.businessStage
    || request?.business_stage
    || request?.controlStage
    || request?.control_stage
  )
  if (explicitStage) {
    return explicitStage
  }

  const documentType = normalizeText(
    request?.documentTypeCode
    || request?.document_type_code
    || request?.documentType
    || request?.document_type
  ).toLowerCase()
  if (['application', 'expense_application'].includes(documentType)) {
    return 'expense_application'
  }

  const claimNo = normalizeText(
    request?.claimNo
    || request?.claim_no
    || request?.documentNo
    || request?.document_no
    || request?.id
  ).toUpperCase()
  if (claimNo.startsWith('AP-') || claimNo.startsWith('APP-')) {
    return 'expense_application'
  }

  const typeCode = normalizeText(request?.typeCode || request?.expense_type).toLowerCase()
  if (typeCode === 'application' || typeCode.endsWith('_application')) {
    return 'expense_application'
  }

  return 'reimbursement'
}

function normalizeTone(value) {
  const tone = normalizeText(value).toLowerCase()
  if (tone === 'pass') return 'pass'
  if (tone === 'high') return 'high'
  if (tone === 'medium') return 'medium'
  if (tone === 'low') return 'low'
  return 'medium'
}

function resolveRiskLevelLabel(tone) {
  const normalizedTone = normalizeTone(tone)
  if (normalizedTone === 'high') return '高风险'
  if (normalizedTone === 'medium') return '中风险'
  if (normalizedTone === 'low') return '低风险'
  return '风险提示'
}

export function normalizeRiskTone(value) {
  return normalizeTone(value)
}

function resolveFlagTone(flag) {
  return normalizeRiskFlagTone(flag)
}

function isRiskTone(tone) {
  return ['medium', 'high'].includes(normalizeText(tone).toLowerCase())
}

function normalizeId(value) {
  return normalizeText(value)
}

function resolveItemRiskFlag(item, claimRiskFlags) {
  const itemId = normalizeId(item?.id)
  if (!itemId || !Array.isArray(claimRiskFlags)) {
    return null
  }

  return claimRiskFlags.find((flag) => {
    if (!flag || typeof flag !== 'object') {
      return false
    }

    if (!isActionableRiskFlag(flag)) {
      return false
    }

    const flagItemId = normalizeId(flag.item_id || flag.itemId)
    const tone = resolveFlagTone(flag)
    return flagItemId === itemId && isRiskTone(tone)
  }) || null
}

export function buildItemClaimRiskState(item, claimRiskFlags = []) {
  const flag = resolveItemRiskFlag(item, claimRiskFlags)
  if (!flag) {
    return null
  }

  const tone = resolveFlagTone(flag)
  const label = normalizeText(flag.label) || (tone === 'high' ? '高风险' : '中风险')
  const points = Array.isArray(flag.points)
    ? flag.points.map((point) => normalizeText(point)).filter(Boolean)
    : []
  const summary = normalizeText(flag.summary || flag.message || flag.reason)

  return {
    label,
    tone,
    headline: normalizeText(flag.headline || flag.title) || label,
    summary,
    points,
    suggestion: normalizeText(flag.suggestion) || '如业务确需提交，请在附加说明中补充特殊情况原因后继续提交。'
  }
}

export function resolveRiskTagTone(tag) {
  const normalized = normalizeText(tag).toLowerCase()
  if (normalized === '#high_risk') return 'high'
  if (normalized === '#middle_risk') return 'medium'
  if (normalized === '#low_risk') return 'low'
  if (normalized === '#hotel') return 'hotel'
  if (normalized === '#traffic') return 'traffic'
  return 'neutral'
}

export function extractRiskTagsFromText(text) {
  const matches = normalizeText(text).match(/#[A-Za-z_]+/g) || []
  return [...new Set(matches.map((tag) => tag.toLowerCase()))]
}

export function resolveRiskTags(card = {}) {
  const tags = []
  const tone = normalizeTone(card.tone || card.severity)
  if (tone === 'high') {
    tags.push('#high_risk')
  } else if (tone === 'medium') {
    tags.push('#middle_risk')
  } else if (tone === 'low') {
    tags.push('#low_risk')
  }

  const text = [
    card.label,
    card.title,
    card.risk,
    card.summary,
    card.suggestion,
    card.itemType,
    card.documentType
  ].map((item) => normalizeText(item).toLowerCase()).join(' ')
  if (/住宿|酒店|宾馆|hotel/.test(text)) {
    tags.push('#hotel')
  }
  if (/交通|火车|高铁|机票|航班|出租车|网约车|乘车|车票|train|flight|taxi|traffic|transport/.test(text)) {
    tags.push('#traffic')
  }

  return [...new Set(tags)]
}

function withRiskTags(card) {
  const businessStage = normalizeBusinessStage(
    card.businessStage
    || card.business_stage
    || card.controlStage
    || card.control_stage
  )
  const riskDomain = resolveRiskDomain(card)
  const actionability = resolveRiskActionability(card, { businessStage, riskDomain })
  const visibilityScope = resolveRiskVisibilityScope(card, { businessStage, riskDomain, actionability })
  return {
    ...card,
    ...(businessStage ? { businessStage } : {}),
    riskDomain,
    risk_domain: riskDomain,
    actionability,
    visibilityScope,
    visibility_scope: visibilityScope,
    tags: resolveRiskTags(card)
  }
}

export function filterRiskCardsByBusinessStage(cards = [], businessStage = 'reimbursement') {
  const targetStage = normalizeBusinessStage(businessStage) || 'reimbursement'
  return (Array.isArray(cards) ? cards : []).filter(
    (card) => resolveFlagBusinessStage(card, targetStage) === targetStage
  )
}

function resolveDocumentTypeLabel(value) {
  return DOCUMENT_TYPE_LABELS[normalizeText(value)] || DOCUMENT_TYPE_LABELS.other
}

function normalizeRuleBasis(value) {
  if (Array.isArray(value)) {
    return value.map((item) => normalizeText(item)).filter(Boolean)
  }

  const text = normalizeText(value)
  return text ? [text] : []
}

function resolveClaimRiskRuleBasis(flag = {}, { risk = '', summary = '', tone = 'medium' } = {}) {
  const explicitBasis = normalizeRuleBasis(flag.rule_basis || flag.ruleBasis)
  if (explicitBasis.length) {
    return explicitBasis
  }

  const source = normalizeText(flag.source)
  const label = normalizeText(flag.label || flag.title || flag.name)
  const corpus = [risk, summary, label].map((item) => normalizeText(item)).join(' ')
  const basis = []

  if (/高风险|中风险/.test(corpus)) {
    basis.push(`风险文本已明确标记为${tone === 'high' ? '高风险' : '中风险'}。`)
  }
  if (source === 'attachment_analysis' || /附件|票据|OCR|识别|发票/.test(corpus)) {
    basis.push('附件识别或票据核验未完全通过，系统将该项同步为单据风险。')
  }
  if (/直属领导|审批链|审批人缺失|审批人信息|补充分配|分配/.test(corpus)) {
    basis.push('审批链校验未匹配到完整审批人信息，因此按中风险提醒。')
  }
  if (/金额|超标|阈值|住宿标准|报销标准|标准/.test(corpus)) {
    basis.push('金额或标准核算命中制度阈值，需要补充说明或人工复核。')
  }
  if (/历史|近\s*\d+\s*天|重复|多次/.test(corpus)) {
    basis.push('历史报销风险次数达到预警条件，系统提示审批人重点关注。')
  }
  if (/缺失|缺少|未识别|待补充|不一致|不匹配/.test(corpus)) {
    basis.push('单据、附件或审批信息存在缺失、不一致或待补充项。')
  }
  if (summary) {
    basis.push(`风险汇总：${summary}`)
  }

  return uniqueTexts(basis.length ? basis : [`系统预审根据“${label || '单据风险'}”将该项列为${tone === 'high' ? '高风险' : '中风险'}。`])
}

function resolveClaimRiskSuggestion(flag = {}, { risk = '', summary = '' } = {}) {
  const explicitSuggestion = normalizeText(flag.suggestion)
  if (explicitSuggestion) {
    return explicitSuggestion
  }

  const corpus = [risk, summary, flag.label, flag.title].map((item) => normalizeText(item)).join(' ')
  if (/直属领导|审批链|审批人缺失|审批人信息|补充分配|分配/.test(corpus)) {
    return '请先核对员工档案中的直属领导和审批链配置；如果信息无误，可由审批环节人工补充分配说明。'
  }
  if (/金额|超标|阈值|住宿标准|报销标准|标准/.test(corpus)) {
    return '请核对金额、天数、地点和职级标准；如确需超标，请在附加说明中写清楚业务原因和佐证材料。'
  }
  if (/附件|票据|OCR|识别|发票/.test(corpus)) {
    return '请打开对应费用明细的附件预览，核对票据类型、金额、日期和说明；识别有误时先修正明细或重新上传附件。'
  }
  if (/历史|近\s*\d+\s*天|重复|多次/.test(corpus)) {
    return '请核对近期同类报销记录，必要时补充本次费用与历史单据不同的业务背景。'
  }
  if (/缺失|缺少|未识别|待补充|不一致|不匹配/.test(corpus)) {
    return '请按风险点补齐缺失信息，并核对费用明细与附件内容是否一致。'
  }

  return '请先核对上方触发原因；如属于真实业务例外，在附加说明中写清楚原因和佐证后再继续流转。'
}

export function buildAttachmentInsightViewModel(metadata, item = {}) {
  if (!metadata) {
    return null
  }

  const documentInfo = metadata.document_info || {}
  const requirementCheck = metadata.requirement_check || null
  const analysis = metadata.analysis || null
  const documentTypeLabel =
    normalizeText(documentInfo.document_type_label) || resolveDocumentTypeLabel(documentInfo.document_type)
  const fields = Array.isArray(documentInfo.fields)
    ? documentInfo.fields
      .map((field) => ({
        label: normalizeText(field?.label),
        value: normalizeText(field?.value)
      }))
      .filter((field) => field.label && field.value)
      .map((field) => `${field.label}：${field.value}`)
    : []
  const ruleBasis = uniqueTexts([
    ...normalizeRuleBasis(analysis?.rule_basis || analysis?.ruleBasis),
    ...normalizeRuleBasis(requirementCheck?.rule_basis || requirementCheck?.ruleBasis),
    normalizeText(requirementCheck?.message),
    documentTypeLabel ? `票据识别依据：系统将附件识别为${documentTypeLabel}。` : '',
    normalizeText(item?.name) ? `费用项目依据：当前明细为${normalizeText(item.name)}。` : ''
  ])

  return {
    fileName: normalizeText(metadata.file_name || item.attachmentHint || item.invoiceId),
    mediaType: normalizeText(metadata.media_type),
    previewable: metadata.previewable !== false,
    documentTypeLabel,
    requirementLabel: requirementCheck
      ? (requirementCheck.matches ? '符合当前费用类型' : '不符合当前费用类型')
      : '待校验附件类型',
    requirementTone: requirementCheck
      ? (requirementCheck.matches ? 'pass' : 'high')
      : 'medium',
    message: normalizeText(requirementCheck?.message),
    fields: fields.slice(0, 8),
    ruleBasis,
    analysis: analysis
      ? {
        label: normalizeText(analysis.label) || 'AI提示',
        tone: normalizeTone(analysis.severity),
        headline: normalizeText(analysis.headline) || normalizeText(analysis.label) || 'AI提示',
        summary: normalizeText(analysis.summary),
        points: Array.isArray(analysis.points) ? analysis.points.map((point) => normalizeText(point)).filter(Boolean) : [],
        suggestion: normalizeText(analysis.suggestion)
      }
      : null
  }
}

function buildCardSuggestion(analysis, insight) {
  return (
    normalizeText(analysis?.suggestion)
    || normalizeText(insight?.message)
    || '请根据规则依据核对附件和费用明细，必要时补充说明、更换附件或调整费用项目。'
  )
}

function buildRiskCardFromPoint({ item, index, point, pointIndex, insight, analysis, businessStage = 'reimbursement' }) {
  const tone = normalizeTone(analysis?.severity)
  const title = normalizeText(analysis?.headline) || normalizeText(analysis?.label) || normalizeText(item?.name) || '附件风险'

  return withRiskTags({
    id: `${normalizeText(item?.id) || `expense-${index}`}-${pointIndex}`,
    businessStage: normalizeBusinessStage(businessStage) || 'reimbursement',
    tone,
    label: resolveRiskLevelLabel(tone),
    title: `第 ${index + 1} 条：${title}`,
    risk: normalizeText(point) || normalizeText(analysis?.summary) || '附件存在待核对风险。',
    summary: normalizeText(analysis?.summary),
    ruleBasis: insight?.ruleBasis?.length ? insight.ruleBasis : ['系统根据附件识别结果与费用项目规则进行比对。'],
    suggestion: buildCardSuggestion(analysis, insight),
    itemType: normalizeText(item?.itemType),
    documentType: normalizeText(insight?.documentTypeLabel),
    visibility_scope: 'submitter',
    actionability: 'fixable_by_submitter'
  })
}

function parseReturnCount(flag) {
  const count = Number(flag?.return_count ?? flag?.returnCount ?? 0)
  return Number.isFinite(count) && count > 0 ? Math.floor(count) : 0
}

function resolveLatestManualReturnFlag(flags) {
  const manualReturnFlags = flags.filter(
    (flag) => flag && typeof flag === 'object' && normalizeText(flag.source) === 'manual_return'
  )
  if (!manualReturnFlags.length) {
    return null
  }

  return manualReturnFlags.reduce((latest, flag) => {
    const latestCount = parseReturnCount(latest)
    const nextCount = parseReturnCount(flag)
    if (nextCount !== latestCount) {
      return nextCount > latestCount ? flag : latest
    }

    const latestTime = Date.parse(normalizeText(latest?.created_at || latest?.createdAt))
    const nextTime = Date.parse(normalizeText(flag?.created_at || flag?.createdAt))
    if (Number.isFinite(nextTime) && (!Number.isFinite(latestTime) || nextTime >= latestTime)) {
      return flag
    }

    return latest
  }, manualReturnFlags[0])
}

function buildManualReturnRiskCard(flag, businessStage = 'reimbursement') {
  if (!flag) {
    return null
  }

  const returnCount = parseReturnCount(flag)
  const stageReturnCount = Number(flag.stage_return_count ?? flag.stageReturnCount ?? 0)
  const returnStage = normalizeText(flag.return_stage || flag.returnStage || flag.previous_approval_stage)
  const riskPoints = Array.isArray(flag.risk_points || flag.riskPoints)
    ? (flag.risk_points || flag.riskPoints).map((item) => normalizeText(item)).filter(Boolean)
    : []
  const risk = normalizeText(flag.message || flag.reason || flag.summary) || '审批人退回该单据，请补充后重新提交。'
  const ruleBasis = uniqueTexts([
    returnCount ? `累计退回 ${returnCount} 次。` : '',
    returnStage ? `本次退回环节：${returnStage}。` : '',
    stageReturnCount > 0 ? `该环节累计退回 ${Math.floor(stageReturnCount)} 次。` : '',
    ...riskPoints.map((item) => `退回风险点：${item}。`)
  ])

  return withRiskTags({
    id: `manual-return-${returnCount || 'latest'}`,
    businessStage: resolveFlagBusinessStage(flag, normalizeBusinessStage(businessStage) || 'reimbursement'),
    tone: 'medium',
    label: '退回原因',
    title: returnCount ? `第 ${returnCount} 次退回` : '审批退回',
    risk,
    summary: normalizeText(flag.reason),
    ruleBasis: ruleBasis.length ? ruleBasis : ['审批人已退回该单据。'],
    suggestion: '请按退回原因补充材料、修正明细或完善说明后重新提交。',
    risk_domain: flag.risk_domain || flag.riskDomain || 'workflow',
    visibility_scope: flag.visibility_scope || flag.visibilityScope || 'submitter',
    actionability: flag.actionability || 'fixable_by_submitter'
  })
}

export function buildAttachmentRiskCards({
  expenseItems = [],
  attachmentMetaByItemId = {},
  claimRiskFlags = [],
  businessStage = 'reimbursement'
} = {}) {
  const normalizedBusinessStage = normalizeBusinessStage(businessStage) || 'reimbursement'
  const attachmentRiskItemIds = new Set()
  const attachmentCards = expenseItems.flatMap((item, index) => {
    if (!item?.invoiceId) {
      return []
    }

    const metadata = attachmentMetaByItemId[item.id]
    const insight = buildAttachmentInsightViewModel(metadata, item)
    const analysis = metadata?.analysis
    const tone = normalizeTone(analysis?.severity)
    if (!analysis || !['medium', 'high'].includes(tone)) {
      return []
    }
    const itemId = normalizeId(item.id)
    if (itemId) {
      attachmentRiskItemIds.add(itemId)
    }

    const points = Array.isArray(analysis.points) && analysis.points.length
      ? analysis.points
      : [analysis.summary || analysis.headline || analysis.label]

    return points
      .map((point, pointIndex) => buildRiskCardFromPoint({
        item,
        index,
        point,
        pointIndex,
        insight,
        analysis,
        businessStage: normalizedBusinessStage
      }))
      .filter((card) => card.risk)
  })

  const normalizedClaimRiskFlags = Array.isArray(claimRiskFlags) ? claimRiskFlags : []
  const latestManualReturnCard = buildManualReturnRiskCard(
    resolveLatestManualReturnFlag(normalizedClaimRiskFlags),
    normalizedBusinessStage
  )
  const claimCards = normalizedClaimRiskFlags
      .flatMap((flag, index) => {
        if (flag && typeof flag === 'object' && normalizeText(flag.source) === 'manual_return') {
          return []
        }
        if (flag && typeof flag === 'object' && normalizeText(flag.source) === 'ai_pre_review') {
          return []
        }

        if (!flag || typeof flag !== 'object') {
          if (!isActionableRiskFlag(flag)) {
            return []
          }

          const risk = normalizeText(flag)
          return risk
            ? [withRiskTags({
              id: `claim-risk-${index}`,
              businessStage: resolveRiskTextBusinessStage(risk, normalizedBusinessStage),
              tone: 'medium',
              label: '单据风险',
              title: '单据风险提示',
              risk,
              summary: '',
              ruleBasis: resolveClaimRiskRuleBasis({}, { risk, tone: 'medium' }),
              suggestion: resolveClaimRiskSuggestion({}, { risk })
            })]
            : []
        }

        if (!isActionableRiskFlag(flag)) {
          return []
        }

        const source = normalizeText(flag.source)
        const flagItemId = normalizeId(flag.item_id || flag.itemId)
        if (source === 'attachment_analysis' && flagItemId && attachmentRiskItemIds.has(flagItemId)) {
          return []
        }

        const tone = resolveFlagTone(flag)
        if (!isRiskTone(tone)) {
          return []
        }

        const flagPoints = Array.isArray(flag.points)
          ? flag.points.map((point) => normalizeText(point)).filter(Boolean)
          : []
        const primaryRisk = normalizeText(flag.message || flag.reason || flag.summary)
        const fallbackRisk = normalizeText(flag.description || flag.detail || flag.title || flag.label || flag.name)
        const risks = flagPoints.length
          ? flagPoints
          : [primaryRisk || fallbackRisk].filter(Boolean)
        const summary = normalizeText(flag.summary || flag.message || flag.reason)
        const ruleBasis = resolveClaimRiskRuleBasis(flag, {
          risk: risks[0] || primaryRisk || fallbackRisk,
          summary,
          tone
        })

        return risks.map((risk, pointIndex) => withRiskTags({
          id: `claim-risk-${index}-${pointIndex}`,
          businessStage: resolveFlagBusinessStage(flag, normalizedBusinessStage),
          tone,
          label: resolveRiskLevelLabel(tone),
          title: normalizeText(flag.title || flag.label || flag.name || flag.rule_name || flag.ruleCode || flag.rule_code) || '单据风险提示',
          risk,
          summary,
          ruleBasis,
          suggestion: resolveClaimRiskSuggestion(flag, { risk, summary }),
          risk_domain: flag.risk_domain || flag.riskDomain,
          visibility_scope: flag.visibility_scope || flag.visibilityScope,
          actionability: flag.actionability
        }))
      })
      .filter(Boolean)
  if (latestManualReturnCard) {
    claimCards.unshift(latestManualReturnCard)
  }

  return [...attachmentCards, ...claimCards]
}

function isNoRiskSummary(value) {
  return !isRiskSummaryWithRisk(value)
}

function resolveClaimSummaryTone(request) {
  const explicitTone = normalizeText(request?.riskTone || request?.risk_tone || request?.severity)
  if (explicitTone) {
    return normalizeTone(explicitTone)
  }

  const summary = normalizeText(request?.riskSummary || request?.risk || request?.riskText)
  if (/高风险|重大风险|严重|超标|违规/.test(summary)) {
    return 'high'
  }
  if (/中风险|待关注|待复核|提醒|异常|风险/.test(summary)) {
    return 'medium'
  }
  return 'medium'
}

export function buildClaimSummaryRiskCards(request = {}) {
  const summary = normalizeText(request?.riskSummary || request?.risk || request?.riskText)
  if (isNoRiskSummary(summary)) {
    return []
  }

  const tone = resolveClaimSummaryTone(request)
  if (!isRiskTone(tone)) {
    return []
  }
  const businessStage = resolveRiskTextBusinessStage(summary, resolveRequestBusinessStage(request))

  return [withRiskTags({
    id: 'claim-risk-summary',
    businessStage,
    tone,
    label: resolveRiskLevelLabel(tone),
    title: '单据风险提示',
    risk: summary,
    summary,
    ruleBasis: resolveClaimRiskRuleBasis(
      { source: 'risk_summary', message: summary, severity: tone },
      { risk: summary, summary, tone }
    ),
    suggestion: resolveClaimRiskSuggestion({ source: 'risk_summary' }, { risk: summary, summary })
  })]
}

export function buildAiAdviceViewModel({
  completionItems = [],
  materialPrompts = [],
  profileAdviceItems = [],
  riskCards = []
} = {}) {
  const normalizedCompletionItems = completionItems.map((item) => normalizeText(item)).filter(Boolean)
  const normalizedMaterialPrompts = materialPrompts.map((item) => normalizeText(item)).filter(Boolean)
  const normalizedProfileAdviceItems = profileAdviceItems.map((item) => normalizeText(item)).filter(Boolean)
  const normalizedRiskCards = riskCards.filter(Boolean)
  const hasHighRisk = normalizedRiskCards.some((card) => card.tone === 'high')
  const sortedRiskCards = sortRiskCardsByTone(normalizedRiskCards)

  if (
    !normalizedCompletionItems.length
    && !normalizedMaterialPrompts.length
    && !normalizedProfileAdviceItems.length
    && !normalizedRiskCards.length
  ) {
    return {
      tone: 'ready',
      badge: '可以提交',
      summary: '自动检测未发现票据、金额、行程或历史画像异常，可以提交审批。',
      items: [],
      riskCards: [],
      sections: []
    }
  }

  const sections = []
  if (normalizedCompletionItems.length) {
    sections.push({
      kind: 'completion',
      title: '建议补充字段',
      items: normalizedCompletionItems
    })
  }
  if (normalizedMaterialPrompts.length) {
    sections.push({
      kind: 'material',
      title: '材料补充提示',
      items: normalizedMaterialPrompts
    })
  }
  if (normalizedProfileAdviceItems.length) {
    sections.push({
      kind: 'profile',
      title: '历史操作建议',
      items: normalizedProfileAdviceItems
    })
  }
  if (normalizedRiskCards.length) {
    sections.push({
      kind: 'risk',
      title: `已知存在风险（${normalizedRiskCards.length}项）`,
      items: sortedRiskCards,
      totalCount: normalizedRiskCards.length
    })
  }

  return {
    tone: hasHighRisk ? 'warning' : 'pending',
    badge: hasHighRisk ? '优先整改' : normalizedRiskCards.length ? '待核对' : '建议关注',
    summary: normalizedRiskCards.length
      ? `自动检测发现 ${normalizedRiskCards.length} 个风险点，已按风险等级排序全部展示。`
      : normalizedMaterialPrompts.length
        ? `自动检测发现 ${normalizedMaterialPrompts.length} 条材料补充提示，不作为风险计数。`
        : '结合历史操作记录生成提交建议，请按提示核对后提交审批。',
    items: normalizedCompletionItems,
    riskCards: normalizedRiskCards,
    sections
  }
}

function sortRiskCardsByTone(cards) {
  const toneWeight = {
    high: 0,
    medium: 1,
    low: 2,
    normal: 3,
    pass: 4
  }
  return [...cards].sort((left, right) => {
    const leftWeight = toneWeight[normalizeText(left?.tone).toLowerCase()] ?? 9
    const rightWeight = toneWeight[normalizeText(right?.tone).toLowerCase()] ?? 9
    return leftWeight - rightWeight
  })
}