海外客服工作流：邮件、工单、时区与知识库

// ❌ 坏做法：单关键词匹配，误分类率高
function classifyTicket(subject: string): string {
  if (subject.includes('error') || subject.includes('bug')) {
    return 'bug'
  }
  if (subject.includes('refund') || subject.includes('billing')) {
    return 'billing'
  }
  return 'general' // 所有不确定的都丢到「一般」
}

// ✅ 好做法：多级关键词 + 置信度 + 不确定时转交
interface ClassificationResult {
  category: 'bug' | 'billing' | 'feature' | 'usage' | 'refund'
  confidence: 'high' | 'low'
  requiresHumanReview: boolean
}
 
const KEYWORD_GROUPS = {
  bug: {
    high: ['crash', 'broken', 'not working', 'error message'],
    low: ['error', 'issue', 'problem', 'glitch']
  },
  billing: {
    high: ['charged twice', 'double charge', 'wrong amount', 'overcharged'],
    low: ['billing', 'charge', 'invoice', 'payment']
  },
  refund: {
    high: ['refund', 'money back', 'cancel subscription', 'chargeback'],
    low: ['not working for me', 'want to cancel', 'dissatisfied']
  },
  feature: {
    high: ['feature request', 'would be great if', 'suggestion'],
    low: ['can you add', 'wish it had', 'how about']
  },
  usage: {
    high: ['how to', 'how do i', 'where can i find'],
    low: ['help with', 'question about', 'guide']
  }
}
 
function classifyTicket(
  subject: string,
  body: string
): ClassificationResult {
  const text = `${subject} ${body}`.toLowerCase()
 
  // 同时扫描所有类别，找匹配度最高的
  const scores = Object.entries(KEYWORD_GROUPS).map(([category, groups]) => {
    const highMatches = groups.high.filter(kw => text.includes(kw)).length
    const lowMatches = groups.low.filter(kw => text.includes(kw)).length
    return { category, score: highMatches * 2 + lowMatches }
  })
 
  const best = scores.sort((a, b) => b.score - a.score)[0]
 
  // 高置信度：有强匹配词
  if (best.score >= 2) {
    return {
      category: best.category as ClassificationResult['category'],
      confidence: 'high',
      requiresHumanReview: false
    }
  }
 
  // 低置信度或无匹配：标记人工审核
  return {
    category: best.score > 0
      ? (best.category as ClassificationResult['category'])
      : 'usage',
    confidence: 'low',
    requiresHumanReview: true
  }
}

// ❌ 坏做法：硬编码 UTC，忽视用户时区
function checkSLA(createdAt: Date, now: Date): boolean {
  const hoursElapsed = (now.getTime() - createdAt.getTime()) / (1000 * 60 * 60)
  // 一刀切 24 小时
  return hoursElapsed <= 24
}

// ✅ 好做法：根据用户时区计算有效工作时间
interface SLAConfig {
  responseHours: number        // 承诺响应时间（工作小时内）
  workingHours: { start: number; end: number }  // 我方工作时间（24h 制）
  supportTimezone: string      // 我方时区
  weekendsOff: boolean
}
 
const DEFAULT_CONFIG: SLAConfig = {
  responseHours: 12,
  workingHours: { start: 9, end: 18 },
  supportTimezone: 'Asia/Tokyo',  // 我的工作时区
  weekendsOff: true
}
 
function calculateDeadline(
  receivedAt: Date,
  config: SLAConfig = DEFAULT_CONFIG
): Date {
  let remaining = config.responseHours
  let cursor = new Date(receivedAt)
 
  while (remaining > 0) {
    // 转成我方时区判断是否是工作时间
    const timeInSupportZone = new Date(
      cursor.toLocaleString('en-US', { timeZone: config.supportTimezone })
    )
    const hour = timeInSupportZone.getHours()
    const dayOfWeek = timeInSupportZone.getDay() // 0=周日
 
    // 非工作时间跳过
    if (hour >= config.workingHours.end || hour < config.workingHours.start) {
      // 快进到下一个工作日开始
      const nextStart = new Date(cursor)
      nextStart.setHours(
        config.workingHours.start,
        0, 0, 0
      )
      if (hour >= config.workingHours.end) {
        nextStart.setDate(nextStart.getDate() + 1)
      }
      cursor = nextStart
      continue
    }
 
    // 周末跳过
    if (config.weekendsOff && (dayOfWeek === 0 || dayOfWeek === 6)) {
      cursor.setDate(cursor.getDate() + (dayOfWeek === 6 ? 2 : 1))
      cursor.setHours(config.workingHours.start, 0, 0, 0)
      continue
    }
 
    // 工作时间内，逐小时消耗
    remaining -= 1
    cursor = new Date(cursor.getTime() + 60 * 60 * 1000)
  }
 
  return cursor
}
 
// 用法示例：
// 周五 UTC+9 晚上 10 点收到的邮件
// → 跳过周末
// → 周一 9:00 开始计算 12 个工作小时
// → 截止时间为周二 13:00（我方时区）

// ❌ 坏做法：假设所有用户都写英文
function routeTicket(email: { subject: string; body: string; from: string }) {
  const category = classifyTicket(email.subject, email.body)
  // 所有人都在同一个处理池
  return { queue: 'general', category }
}

// ✅ 好做法：先检测语言，再结合分类做路由
type SupportedLanguage = 'en' | 'ja' | 'zh' | 'es' | 'fr' | 'de' | 'unknown'
 
function detectLanguage(text: string): SupportedLanguage {
  const hasJapanese = /[぀-ゟ゠-ヿ一-龯]/.test(text)
  const hasChinese = /[一-龯]/.test(text) && !hasJapanese
  const hasKorean = /[가-힯ᄀ-ᇿ]/.test(text)
  const hasCyrillic = /[Ѐ-ӿ]/.test(text)
  const isMostlyAscii = /^[\x00-\x7F\s\d\p{P}]+$/u.test(text.slice(0, 200))
 
  if (hasJapanese) return 'ja'
  if (hasKorean) return 'unknown'  // 暂不支持，标记为需人工处理
  if (hasChinese) return 'zh'
  if (hasCyrillic) return 'unknown'
  if (isMostlyAscii) {
    // 英语为主，但也可能是法语、德语、西班牙语
    // 生产环境应该用 fasttext 或 Google Cloud Translation API 的语言检测
    return 'en'
  }
  return 'unknown'
}
 
interface RoutingResult {
  queue: string
  category: string
  language: SupportedLanguage
  needsTranslation: boolean
  priority: 'normal' | 'urgent'
}
 
function routeTicket(email: {
  subject: string
  body: string
  from: string
}): RoutingResult {
  const fullText = `${email.subject} ${email.body}`
  const language = detectLanguage(fullText)
  const category = classifyTicket(email.subject, email.body)
 
  // 敏感操作（退款、账号问题）无论语言都提高优先级
  const isSensitive = ['refund', 'billing'].includes(category)
  const needsTranslation = language !== 'en' && language !== 'unknown'
 
  return {
    queue: language === 'unknown' ? 'manual-review' : `support-${language}`,
    category: category.category,
    language,
    needsTranslation,
    priority: isSensitive || category.requiresHumanReview ? 'urgent' : 'normal'
  }
}

// ✅ 好做法：参数化模板，组合使用
interface TicketTemplate {
  id: string
  category: string
  language: SupportedLanguage
  subject: string
  body: (params: Record<string, string>) => string
}
 
const REFUND_TEMPLATES: TicketTemplate[] = [
  {
    id: 'refund-approved',
    category: 'refund',
    language: 'en',
    subject: 'Your refund has been processed',
    body: (params) => `Hi ${params.customerName},
 
We've processed your refund of ${params.amount} for ${params.productName}.
The refund should appear in your account within ${params.processingDays} business days.
 
Your reference number: ${params.referenceId}
 
If you don't see the refund after ${params.processingDays} business days,
please reply to this email and we'll follow up.
 
Best,
${params.agentName}`
  },
  {
    id: 'refund-approved',
    category: 'refund',
    language: 'ja',
    subject: '返金処理が完了しました',
    body: (params) => `${params.customerName} 様
 
${params.productName} の返金 ${params.amount} を処理いたしました。
${params.processingDays} 営業日以内にお口座に反映されます。
 
参照番号: ${params.referenceId}
 
${params.processingDays} 営業日を過ぎても反映されない場合は、
このメールに返信してください。
 
${params.agentName}`
  }
]
 
function renderTemplate(
  templateId: string,
  language: SupportedLanguage,
  params: Record<string, string>
): { subject: string; body: string } | null {
  const template = REFUND_TEMPLATES.find(
    t => t.id === templateId && t.language === language
  )
  if (!template) return null
  return {
    subject: template.subject,
    body: template.body(params)
  }
}

// ❌ 坏做法：硬编码回复文本
function sendRefundReply(customerName: string) {
  return `Hi ${customerName}, your refund has been processed.
  It will appear in 5-10 business days.
  Thanks.`
  // 问题：
  // 1. 只有英文版本
  // 2. 缺少金额、产品名等具体信息
  // 3. 缺少参考号
  // 4. 没有说明超期后的处理方式
  // 5. 没有客服署名
}

// ✅ 好做法：AI 草稿 + 人工审核 + 质量检查
interface DraftReviewResult {
  approved: boolean
  editedContent?: string
  riskFlags: string[]  // 如：语气问题、信息不完整、敏感操作
}
 
async function generateAndReviewReply(
  ticket: Ticket
): Promise<DraftReviewResult> {
  // 第一步：AI 生成草稿
  const draft = await aiGenerateReply(ticket)
 
  // 第二步：自动质量检查
  const riskFlags: string[] = []
 
  // 检查是否涉及敏感操作
  if (ticket.category === 'refund' || ticket.category === 'billing') {
    riskFlags.push('sensitive_operation')
  }
 
  // 检查是否包含承诺性语言
  const promisePatterns = ['guarantee', 'promise', 'will definitely', 'absolutely']
  if (promisePatterns.some(p => draft.toLowerCase().includes(p))) {
    riskFlags.push('contains_promise')
  }
 
  // 检查回复语言是否与用户语言匹配
  const detectedLang = detectLanguage(draft)
  if (detectedLang !== ticket.language) {
    riskFlags.push('language_mismatch')
  }
 
  // 有风险标记的必须人工审核
  return {
    approved: riskFlags.length === 0,
    editedContent: draft,
    riskFlags
  }
}

// ❌ 坏做法：AI 直接发送，无人工环节
async function autoReply(ticket: Ticket) {
  const reply = await aiGenerateReply(ticket)
  await sendEmail(ticket.from, reply)
  // 问题：
  // 1. 没有质量检查
  // 2. 退款等敏感操作也可能被自动执行
  // 3. 用户发现回复不对时，信任已经受损
  // 4. 无法追踪和复盘
}

interface WeeklyReport {
  period: string
  totalTickets: number
  topCategories: Array<{ category: string; count: number; percentage: number }>
  knowledgeGaps: string[]       // 高频但知识库未覆盖的问题
  avgResponseTime: number       // 平均响应时间（小时）
  satisfactionScore?: number    // 用户满意度评分
}
 
function generateWeeklyReport(tickets: Ticket[]): WeeklyReport {
  const total = tickets.length
  const categoryCounts = tickets.reduce(
    (acc, t) => {
      acc[t.category] = (acc[t.category] || 0) + 1
      return acc
    },
    {} as Record<string, number>
  )
 
  const topCategories = Object.entries(categoryCounts)
    .map(([category, count]) => ({
      category,
      count,
      percentage: Math.round((count / total) * 100)
    }))
    .sort((a, b) => b.count - a.count)
    .slice(0, 5)
 
  // 检查知识库覆盖
  const knowledgeGaps = topCategories
    .filter(c => c.count >= 5 && !hasKnowledgeBaseArticle(c.category))
    .map(c => c.category)
 
  const avgResponseTime =
    tickets.reduce((sum, t) => sum + t.responseTimeHours, 0) / total
 
  return {
    period: `${tickets[0].createdAt} - ${tickets[tickets.length - 1].createdAt}`,
    totalTickets: total,
    topCategories,
    knowledgeGaps,
    avgResponseTime: Math.round(avgResponseTime * 10) / 10
  }
}