/**
 * TWork V7.2 · 多级意图分类器
 *
 * 对标 Qoder 的多层意图分类体系，将扁平模式匹配升级为：
 * - L1（一级意图，7+1 类）：EDIT / GENERATE / ANALYZE / TRANSFORM / QUERY / EXPLAIN / COMPOSE / UNKNOWN
 * - L2（二级意图，25 类，每类 2-10 子类）
 * - 歧义检测：当多候选置信度接近时触发消解流程
 * - 历史先验加权：同会话内前序意图作为先验提升命中率
 *
 * 设计原则：
 * - 90% 的输入应在本地完成分类（≤ 5ms），避免 LLM 调用
 * - 宁缺勿错：置信度 < 0.5 时返回 'unknown' 而非强行分类
 *
 * @since V7.0
 * @updated V7.2 — 新增 EXPLAIN L1 + 8 个 L2 意图（code_explain / concept_explain / security / config / data_process / log_analysis / git_ops / scaffold）
 */

// ─── 类型定义 ────────────────────────────────────────────────────────

/** 一级意图（L1） */
export type L1Intent =
  | 'EDIT'        // 编辑（修改/更新/调整现有内容）
  | 'GENERATE'    // 生成（创建/编写/产出新内容）
  | 'ANALYZE'     // 分析（诊断/评估/审查/安全扫描）
  | 'TRANSFORM'   // 变换（重构/优化/迁移/格式化/配置/Git操作）
  | 'QUERY'       // 查询（搜索/定位/询问信息/包管理）
  | 'EXPLAIN'     // 解释（理解代码/概念说明/原理分析）— @since V7.2
  | 'COMPOSE'     // 组合（多意图混合，需歧义消解）
  | 'UNKNOWN'     // 无法分类

/** 二级意图（L2）— 对应 V6.1 的 detectEnhanceIntent 输出 */
export type L2Intent =
  // GENERATE（10 类）
  | 'git_report'      // 日报/周报/提交报告
  | 'code_write'      // 编写功能代码
  | 'doc_gen'         // 文档/Wiki/知识库生成
  | 'test'            // 测试用例编写
  | 'api_dev'         // API 接口开发
  | 'ui_design'       // UI/组件设计
  | 'database'        // 数据库设计/SQL
  | 'sop_generation'  // SOP 流程生成
  | 'scaffold'        // 项目脚手架/模板生成 — @since V7.2
  | 'data_process'    // 数据处理/ETL/迁移 — @since V7.2
  // EDIT（2 类）
  | 'bug_fix'         // Bug 修复
  | 'file_ops'        // 文件操作（移动/重命名/整理）— @since V7.2
  // TRANSFORM（6 类）
  | 'refactor'        // 代码重构
  | 'deployment'      // 部署/发布
  | 'translation'     // 翻译/国际化
  | 'config'          // 配置/环境变量管理 — @since V7.2
  | 'git_ops'         // Git 操作（合并/分支/冲突）— @since V7.2
  | 'migration'       // 代码/数据迁移 — @since V7.2
  // ANALYZE（5 类 + 1 子类）
  | 'code_review'     // 代码审查
  | 'architecture'    // 架构设计/分析
  | 'performance'     // 性能优化分析
  | 'performance_problem' // 性能问题诊断 — @since V8.0: 从 V6.1 提升至 L2
  | 'security'        // 安全审计/漏洞扫描 — @since V7.2
  | 'log_analysis'    // 日志分析/排错 — @since V7.2
  // QUERY（2 类）
  | 'file_search'     // 文件搜索/定位
  | 'pkg_mgmt'        // 包/依赖管理 — @since V7.2
  // EXPLAIN（2 类）— @since V7.2
  | 'code_explain'    // 代码解释/理解
  | 'concept_explain' // 概念/原理说明
  // META（2 类）— @since V8.0: 覆盖之前落入 general 的高频场景
  | 'optimize_prompt'  // 提示词优化/增强
  | 'task_execution'   // 通用任务执行（"最优方案，尽善尽美…"）
  // 兜底
  | 'general'         // 通用任务
  | 'unknown'         // 无法分类

/** 意图分类结果 */
export interface IntentClassificationResult {
  /** 一级意图 */
  l1: L1Intent
  /** 二级意图（兼容 V6.1 输出） */
  l2: L2Intent
  /** 分类置信度 [0, 1] */
  confidence: number
  /** 歧义检测结果 */
  ambiguity: AmbiguityResult
  /** 候选意图列表（按置信度降序，最多 3 个） */
  candidates: IntentCandidate[]
  /** 分类耗时（ms） */
  elapsedMs: number
}

export interface IntentCandidate {
  l1: L1Intent
  l2: L2Intent
  confidence: number
  /** 匹配的关键词/模式 */
  matchedBy: string
}

export interface AmbiguityResult {
  /** 是否存在歧义（top2 置信度差值 < 阈值） */
  isAmbiguous: boolean
  /** 推荐处理方式 */
  resolution: 'auto' | 'clarify' | 'fallback'
  /** 歧义候选（当 isAmbiguous 时，供前端展示选择） */
  candidates?: Array<{
    l2: L2Intent
    label: string
    confidence: number
  }>
}

export interface IntentClassifierConfig {
  /** 置信度阈值：最高候选 ≥ 此值才直接采用。默认 0.65 */
  confidenceThreshold?: number
  /** 歧义阈值：top2 差值 < 此值视为歧义。默认 0.15 */
  ambiguityThreshold?: number
  /** 会话历史意图先验（可选） */
  sessionHistory?: L2Intent[]
}

// ─── L1 → L2 映射 ───────────────────────────────────────────────────

const L1_TO_L2: Record<L1Intent, L2Intent[]> = {
  EDIT: ['bug_fix', 'file_ops'],
  GENERATE: ['git_report', 'code_write', 'doc_gen', 'test', 'api_dev', 'ui_design', 'database', 'sop_generation', 'scaffold', 'data_process'],
  ANALYZE: ['code_review', 'architecture', 'performance', 'performance_problem', 'security', 'log_analysis'],
  TRANSFORM: ['refactor', 'deployment', 'translation', 'config', 'git_ops', 'migration'],
  QUERY: ['file_search', 'pkg_mgmt'],
  EXPLAIN: ['code_explain', 'concept_explain'],
  COMPOSE: ['optimize_prompt', 'task_execution', 'general'],
  UNKNOWN: ['unknown'],
}

/** L2 → L1 反向映射 */
const L2_TO_L1: Record<L2Intent, L1Intent> = {
  git_report: 'GENERATE',
  code_write: 'GENERATE',
  doc_gen: 'GENERATE',
  test: 'GENERATE',
  api_dev: 'GENERATE',
  ui_design: 'GENERATE',
  database: 'GENERATE',
  sop_generation: 'GENERATE',
  scaffold: 'GENERATE',
  data_process: 'GENERATE',
  bug_fix: 'EDIT',
  file_ops: 'EDIT',
  refactor: 'TRANSFORM',
  deployment: 'TRANSFORM',
  translation: 'TRANSFORM',
  config: 'TRANSFORM',
  git_ops: 'TRANSFORM',
  migration: 'TRANSFORM',
  code_review: 'ANALYZE',
  architecture: 'ANALYZE',
  performance: 'ANALYZE',
  performance_problem: 'ANALYZE',
  security: 'ANALYZE',
  log_analysis: 'ANALYZE',
  file_search: 'QUERY',
  pkg_mgmt: 'QUERY',
  code_explain: 'EXPLAIN',
  concept_explain: 'EXPLAIN',
  optimize_prompt: 'COMPOSE',
  task_execution: 'COMPOSE',
  general: 'COMPOSE',
  unknown: 'UNKNOWN',
}

// ─── L2 分类规则 ────────────────────────────────────────────────────

interface L2Rule {
  l2: L2Intent
  /** 字符串包含匹配 */
  keywords?: string[]
  /** 正则匹配 */
  patterns?: RegExp[]
  /** 基础置信度 */
  baseConfidence: number
}

const L2_RULES: L2Rule[] = [
  {
    l2: 'git_report',
    keywords: ['日报', '周报', 'git', 'commit', '提交记录', 'daily report', 'git log'],
    patterns: [/结合.*提交/, /git.*报告/, /提交.*汇总/, /git.*report/i],
    baseConfidence: 0.92,
  },
  {
    l2: 'bug_fix',
    keywords: ['修复', 'bug', '报错', '错误', '异常', 'fix', 'patch', 'crash', '崩溃', '回归',
      '问题', '故障', '不工作', '无法', '失效'],
    patterns: [
      /修复.*[问问]/, /[bB]ug\s*修/, /fix\s*(the\s*)?(bug|error|issue)/i,
      /(?:针对|关于).*(?:问题|bug|异常|故障)/,
      /.*的问题[（(]/,
      /(?:遇到|存在|出现|有).*(?:问题|bug|异常|故障|错误)/,
    ],
    baseConfidence: 0.90,
  },
  {
    l2: 'refactor',
    keywords: ['重构', 'refactor', '重构优化', '代码质量', '技术债务', 'clean code'],
    patterns: [
      /重构.*代码/,
      // @since V7.5: "优化/改善/改进" 必须在 10 字符内跟随代码名词，防止"优化完善"等泛化表达误匹配
      /(?:优化|改善|改进).{0,10}(?:代码|逻辑|结构|架构|模块|函数|方法|类|组件|文件|算法|实现)/i,
      /refactor/i,
      /技术债|债务|cleanup|clean\s*up/i,
    ],
    baseConfidence: 0.88,
  },
  {
    l2: 'code_review',
    keywords: ['审查', 'review', '代码审查', 'code review', 'review code', '审查代码'],
    patterns: [/对.*审查/, /review\s*(the\s*)?code/i],
    baseConfidence: 0.90,
  },
  {
    l2: 'code_write',
    // @since V8.1: 新增独立关键词 '编写'、'新增'、'模块'、'功能'，覆盖"编写一个XXX功能模块"场景
    keywords: ['实现', '编写代码', '编写', '创建', '开发', 'implement', 'create', '新增功能', '功能开发', '编码', '新增'],
    // @since V8.1: 放宽正则 — 允许动词和代码名词之间有最多 20 个字符的修饰词
    patterns: [
      /(?:实现|编写|创建|开发|新增).{0,20}(?:功能|模块|组件|接口|页面|类|函数|方法|脚本|服务|系统)/,
      /编写.*代码/, /写[一个]?代码/,
      /implement.*feature/i, /create.*module/i,
    ],
    baseConfidence: 0.80,
  },
  {
    l2: 'api_dev',
    keywords: ['接口', 'api', 'REST', 'endpoint', 'GraphQL', 'gRPC', 'CRUD'],
    patterns: [/设计.*接口/, /实现.*api/i, /api.*设计/],
    baseConfidence: 0.88,
  },
  {
    l2: 'doc_gen',
    // @since V7.5: 新增 '专家模式' 关键词，提升文档场景覆盖率
    keywords: ['文档', '说明', 'document', 'documentation', 'README', '手册', 'wiki', 'Wiki', '知识库', '知识管理', '操作指南', '操作手册', '用户手册', '技术文档', '说明文档', '帮助文档', '知识文档', '专家指令', 'persona', '对标', '专家模式'],
    patterns: [
      /编写.*文档/,
      /生成.*文档/,
      /文档.*生成/,
      /(?:wiki|Wiki).*(?:文档|页面|知识库|标准|规范)/i,
      /(?:专家|expert|persona|角色|数字分身).*(?:指令|文档|配置|手册|模式)/i,
      /(?:对标|参考).*(?:标准|规范)/i,
      /write.*doc/i,
    ],
    // @since V8.0: 从 0.93 提升至 0.95，确保文档场景绝对优先
    baseConfidence: 0.95,
  },
  {
    l2: 'test',
    keywords: ['测试', 'test', '单元测试', '测试用例', '覆盖率', 'unit test', 'E2E'],
    patterns: [/编写.*测试/, /test.*case/i, /unit\s*test/i],
    baseConfidence: 0.88,
  },
  {
    l2: 'architecture',
    keywords: ['架构', 'architecture', '系统设', '技术方案', '方案设计', '架构设计'],
    patterns: [/设计.*架构/, /架构.*设计/, /architecture\s*design/i, /系统.*设计/],
    baseConfidence: 0.85,
  },
  {
    l2: 'performance',
    keywords: ['性能', '瓶颈', 'profiling', '慢', '延迟', 'latency', 'performance',
      '过慢', '太慢', '速度慢', '执行慢', '超时', '未完成', '卡', '卡顿', '假死'],
    patterns: [
      /性能.*优化/, /优化.*性能/, /性能.*提升/, /performance.*optim/i,
      /(?:速度|性能|执行|运行).*(?:过慢|太慢|很慢|慢)/,
      /(?:执行|运行|加载|处理).*(?:两|2|三|3|\d+).*(?:小时|分钟).*(?:未|没|还)/,
      /(?:速度|性能).*(?:问题|瓶颈)/,
      /(?:执行|运行).*(?:超时|未完成|卡[顿住]?|假死|无响应)/,
    ],
    baseConfidence: 0.90,
  },
  {
    // @since V8.0: 性能问题诊断（区别于"性能优化"）— 用户在描述一个具体的性能问题
    // @since V8.2: 新增 "步骤超时"/"节点超时"/"规避风险" 等工作流场景模式
    l2: 'performance_problem',
    keywords: ['速度过慢', '执行慢', '运行慢', '太慢', '卡顿', '超时', '假死', '无响应', '未完成', '两小时', '30分钟', '执行不了', '步骤超时', '节点超时', '耗时过长'],
    patterns: [
      /(?:速度|性能|执行|运行).*(?:过慢|太慢|很慢|慢).*(?:问题|故障|异常)/,
      /(?:执行|运行|加载|处理).*(?:两|2|三|3|\d+).*(?:小时|分钟).*(?:未|没|还)/,
      /(?:速度|性能).*(?:问题|瓶颈)/,
      /(?:执行|运行).*(?:超时|未完成|卡[顿住]?|假死|无响应)/,
      // @since V8.2: 工作流/任务步骤超时场景
      /(?:步骤|节点|环节|任务).*(?:超时|失败|超时失败)/,
      /(?:超时|失败).*(?:步骤|节点|环节)/,
      /规避.*(?:超时|风险)/,
    ],
    baseConfidence: 0.92,
  },
  {
    l2: 'database',
    keywords: ['数据库', 'SQL', '表结构', '索引', 'database', 'migration', '迁移脚本'],
    patterns: [/设计.*表/, /编写.*sql/i, /database.*design/i],
    baseConfidence: 0.85,
  },
  {
    l2: 'deployment',
    keywords: ['部署', 'deploy', '发布', 'Docker', 'CI/CD', '运维', '容器', '回滚'],
    patterns: [/部署.*方案/, /deploy.*config/i, /编写.*部署/],
    baseConfidence: 0.85,
  },
  {
    l2: 'ui_design',
    keywords: ['组件', 'UI', '页面', '界面', '响应式', 'component', '样式', 'CSS'],
    patterns: [/设计.*组件/, /实现.*UI/i, /component.*design/i],
    baseConfidence: 0.85,
  },
  {
    l2: 'file_search',
    keywords: ['搜索', '查找', '定位', 'search', 'find', 'locate', 'grep'],
    patterns: [/搜索.*文件/, /查找.*函数/, /find.*file/i, /search.*code/i],
    baseConfidence: 0.82,
  },
  {
    l2: 'translation',
    keywords: ['翻译', 'translate', '国际化', 'i18n', '多语言'],
    patterns: [/翻译.*为/, /translate.*to/i],
    baseConfidence: 0.90,
  },
  {
    l2: 'sop_generation',
    keywords: ['SOP', '流程', '标准作业', '工作流', 'workflow', '流程生成'],
    patterns: [/生成.*SOP/i, /SOP.*流程/, /创建.*工作流/],
    baseConfidence: 0.90,
  },
  // ─── @since V7.2 新增意图 ───────────────────────────────────────
  {
    l2: 'code_explain',
    keywords: ['解释', '什么意思', '干什么', '什么用', 'explain', 'understand', 'what does', 'read through', '看[一]?懂'],
    patterns: [
      /(?:解释|说明|分析|解读).*?(?:代码|函数|方法|逻辑|这段|这段代码)/,
      /(?:这段|这个|那[段个]).*?(?:代码|逻辑|函数|方法|算法).*(?:是什么|干什么|啥意思|意思|怎么理解)/,
      /(?:帮[我我]?|请)?(?:看|读|理解)(?:一下|下)?(?:这[段个]|代码|逻辑)/,
      /explain.*(?:code|function|logic|this|what)/i,
      /what\s*(does|is)\s*(this|the|that)/i,
      /how\s*(does|is|do).*work/i,
    ],
    baseConfidence: 0.90,
  },
  {
    l2: 'concept_explain',
    keywords: ['什么是', '原理', '概念', '解释.*是', '怎么理解', '介绍.*是', '科普', '什么是', 'concept', 'principle'],
    patterns: [
      /(?:什么|啥)(?:叫|是).*[?？]?$/,
      /(?:介绍|说明|解释).*(?:是什么|的概念|的原理|原理)/,
      /(?:对比|比较|区别).*(?:和|与|vs)/i,
      /(?:原理|机制|机制是|底层).*?(?:是|为|怎么)/,
      /what\s*is\s+/i,
      /(?:difference|comparison|vs)\s*(?:between|of)/i,
    ],
    baseConfidence: 0.88,
  },
  {
    l2: 'security',
    keywords: ['安全', '漏洞', 'XSS', 'SQL注入', 'CSRF', '安全审计', 'security', 'vulnerability', 'CVE', '注入攻击', '安全扫描', '渗透'],
    patterns: [
      /(?:安全|security).*(?:审计|检查|扫描|分析|加固|漏洞)/i,
      /(?:漏洞|vulnerability|XSS|CSRF|注入|injection).*(?:检查|修复|扫描|分析)?/i,
      /(?:依赖|dependency|npm|pip).*(?:安全|漏洞|audit|CVE)/i,
      /(?:渗透|pentest|penetration).*(?:测试|分析)/i,
      /(?:加固|hardening).*(?:安全|server|服务)/i,
    ],
    baseConfidence: 0.92,
  },
  {
    l2: 'config',
    keywords: ['配置', '环境变量', 'env', '.env', 'yaml', 'yml', 'toml', 'config', 'nginx', 'webpack配置', 'vite配置', 'tsconfig',
      '关闭', '禁用', '隐藏', '去掉', '去除', '开启', '启用', '激活',  // ── 功能/提示开关 ── @since V7.4
      '保留', '不影响'],
    patterns: [
      /(?:配置|设置|修改|调整).*(?:文件|参数|选项|环境|变量)/,
      /(?:env|环境变量|\.env|dotenv)/i,
      /(?:nginx|apache|webpack|vite|tsconfig|eslint|prettier).*(?:配置|config)/i,
      /(?:yaml|yml|toml|json|ini).*(?:配置|文件|格式)/i,
      /(?:设置|configure|config).*(?:参数|选项|属性)/i,
      // ── 功能/提示开关 ── @since V7.4
      /(?:关闭|禁用|隐藏|去掉|去除|移除).*(?:提示|功能|选项|开关|引擎|模式|按钮|弹窗|通知|建议|快捷键|快捷)/,
      /(?:开启|启用|打开|显示|激活).*(?:提示|功能|选项|开关|引擎|模式|按钮|弹窗|通知|建议|快捷键|快捷)/,
      /(?:提示|功能|选项|引擎|模式).*(?:关闭|禁用|隐藏|开启|启用|打开|显示)/,
      /(?:保留|不影响|不改变|不破坏).*(?:功能|逻辑|引擎|现有|原有)/,
    ],
    baseConfidence: 0.88,
  },
  {
    l2: 'data_process',
    keywords: ['数据迁移', '数据清洗', 'ETL', '批量处理', 'CSV', 'JSON转换', '数据转换', '数据处理', 'migrate data', 'data pipeline'],
    patterns: [
      /(?:数据|data).*(?:迁移|转换|清洗|处理|导入|导出|同步)/i,
      /(?:CSV|JSON|XML|Excel).*(?:转换|解析|生成|处理)/i,
      /(?:ETL|pipeline|数据管道)/i,
      /(?:批量|batch).*(?:处理|导入|更新|删除)/,
      /(?:数据|data).*(?:格式|format).*(?:转换|change)/i,
    ],
    baseConfidence: 0.88,
  },
  {
    l2: 'log_analysis',
    keywords: ['日志', 'log', '错误日志', '排错', '排查', '分析日志', 'access log', 'error log', '日志分析'],
    patterns: [
      /(?:分析|查看|排查|检查).*(?:日志|log)/i,
      /(?:日志|log).*(?:分析|排查|报错|错误|异常)/i,
      /(?:错误|error|exception).*(?:日志|log|堆栈|stack\s*trace)/i,
      /(?:access|error|system).*(?:log|日志)/i,
      /(?:排查|定位|trace).*(?:问题|错误|异常|bug)/,
    ],
    baseConfidence: 0.88,
  },
  {
    l2: 'git_ops',
    keywords: ['合并', '分支', '冲突', 'rebase', 'cherry-pick', 'tag', 'stash', 'merge', 'branch', 'resolve conflict', 'resolve'],
    patterns: [
      /(?:合并|merge).*(?:分支|branch|代码)/i,
      /(?:解决|resolve).*(?:冲突|conflict)/i,
      /(?:rebase|cherry.?pick|stash|tag)/i,
      /(?:分支|branch).*(?:创建|删除|切换|管理|对比)/i,
      /(?:git).*(?:merge|rebase|stash|tag|reset|checkout)/i,
    ],
    baseConfidence: 0.88,
  },
  {
    l2: 'scaffold',
    keywords: ['脚手架', '初始化', 'scaffold', 'boilerplate', '模板项目', '项目模板', 'init project', 'create project', 'yeoman', 'create-react-app', 'create-vue'],
    patterns: [
      /(?:初始化|创建|搭建).*(?:项目|工程|脚手架)/,
      /(?:scaffold|boilerplate|starter|template).*(?:project|项目)?/i,
      /(?:create|init|generate).*(?:project|app|repo)/i,
      /(?:搭建|搭建).*(?:环境|项目|框架)/,
      /(?:vue.?cli|create-react-app|create-next-app|nest.?new)/i,
    ],
    baseConfidence: 0.88,
  },
  {
    l2: 'file_ops',
    keywords: ['移动', '重命名', '复制', '删除文件', '整理目录', 'rename', 'move', 'copy', '文件操作'],
    patterns: [
      /(?:移动|重命名|复制|删除|整理).*(?:文件|目录|文件夹)/,
      /(?:rename|move|copy|delete).*(?:file|folder|directory)/i,
      /(?:文件|目录).*(?:移动|重命名|归类|整理)/,
    ],
    baseConfidence: 0.82,
  },
  {
    l2: 'pkg_mgmt',
    keywords: ['安装', '依赖', 'package', 'npm install', 'yarn add', 'pnpm', 'pip install', 'brew', '升级依赖', 'update deps'],
    patterns: [
      /(?:安装|install|add).*(?:依赖|包|package|module)/i,
      /(?:npm|yarn|pnpm|pip|brew|cargo).*(?:install|add|update|remove)/i,
      /(?:升级|update|upgrade).*(?:依赖|版本|package|deps)/i,
      /(?:依赖|dependency|dependencies).*(?:管理|冲突|冲突解决|检查|审计)/i,
      /(?:lock|package\.json|requirements\.txt).*(?:更新|锁定|冲突)/i,
    ],
    baseConfidence: 0.85,
  },
  {
    l2: 'migration',
    keywords: ['迁移', '升级版本', 'migration', '从.*迁移到', '版本升级', 'upgrade', '从 Vue 2 到 Vue 3', '从 JS 到 TS'],
    patterns: [
      /(?:迁移|migrate|migration).*(?:到|to|从|from)/i,
      /(?:从|from).*(?:迁移|升级|转换).*(?:到|to)/i,
      /(?:升级|upgrade).*(?:版本|version|框架|库)/i,
      /(?:Vue\s*2|React\s*\d+|JS|JavaScript).*(?:到|to).*(?:Vue\s*3|React\s*\d+|TS|TypeScript)/i,
      /(?:代码|项目).*(?:迁移|migration)/i,
    ],
    baseConfidence: 0.88,
  },
  // ─── @since V8.0 新增 META 意图 ───────────────────────────────────────
  {
    l2: 'optimize_prompt',
    keywords: ['优化提示词', '增强提示词', '优化输入', '提示词优化', '优化prompt', 'enhance prompt', '提示词增强'],
    patterns: [
      /(?:优化|增强|改进).*(?:提示词|prompt|输入)/,
      /(?:提示词|prompt).*(?:优化|增强|改进)/,
    ],
    baseConfidence: 0.90,
  },
  {
    l2: 'task_execution',
    keywords: ['最优方案', '尽善尽美', '优化完善', '按照方案', '按照计划', '按计划执行'],
    patterns: [
      /(?:最优|最佳).*(?:方案|实施|执行)/,
      /尽善尽美.*(?:优化|完善|实现|执行|完成)/,
      /(?:按照|按).*(?:方案|计划).*(?:执行|实施|完成)/,
    ],
    baseConfidence: 0.85,
  },
]

// ─── 歧义标签（中文） ──────────────────────────────────────────────

const L2_LABELS_ZH: Record<L2Intent, string> = {
  git_report: '生成日报/周报',
  code_write: '编写功能代码',
  doc_gen: '编写技术文档',
  test: '编写测试用例',
  api_dev: '设计 API 接口',
  ui_design: '设计 UI 组件',
  database: '设计数据库',
  sop_generation: '生成 SOP 流程',
  scaffold: '项目脚手架/初始化',
  data_process: '数据处理/ETL',
  bug_fix: '修复 Bug',
  file_ops: '文件操作/整理',
  refactor: '重构优化代码',
  deployment: '部署发布',
  translation: '翻译/国际化',
  config: '配置/环境变量管理',
  git_ops: 'Git 操作/分支管理',
  migration: '代码/版本迁移',
  code_review: '代码审查',
  architecture: '架构设计',
  performance: '性能优化',
  performance_problem: '性能问题诊断',
  security: '安全审计/漏洞扫描',
  log_analysis: '日志分析/排错',
  file_search: '搜索定位',
  pkg_mgmt: '包/依赖管理',
  code_explain: '代码解释/理解',
  concept_explain: '概念/原理说明',
  optimize_prompt: '提示词优化/增强',
  task_execution: '按方案执行任务',
  general: '通用任务',
  unknown: '未识别',
}

const L2_LABELS_EN: Record<L2Intent, string> = {
  git_report: 'Generate report from Git',
  code_write: 'Write feature code',
  doc_gen: 'Write documentation',
  test: 'Write test cases',
  api_dev: 'Design API endpoint',
  ui_design: 'Design UI component',
  database: 'Design database',
  sop_generation: 'Generate SOP workflow',
  scaffold: 'Project scaffolding',
  data_process: 'Data processing / ETL',
  bug_fix: 'Fix a bug',
  file_ops: 'File operations',
  refactor: 'Refactor code',
  deployment: 'Deploy / Release',
  translation: 'Translate / i18n',
  config: 'Config / env management',
  git_ops: 'Git operations / branching',
  migration: 'Code / version migration',
  code_review: 'Code review',
  architecture: 'Architecture design',
  performance: 'Performance optimization',
  performance_problem: 'Performance problem diagnosis',
  security: 'Security audit',
  log_analysis: 'Log analysis / debugging',
  file_search: 'Search / Locate',
  pkg_mgmt: 'Package / dependency mgmt',
  code_explain: 'Explain code',
  concept_explain: 'Explain concept',
  optimize_prompt: 'Optimize prompt',
  task_execution: 'Execute task per plan',
  general: 'General task',
  unknown: 'Unknown',
}

// ─── 主类 ────────────────────────────────────────────────────────────

export class EnhanceIntentClassifier {
  private readonly confidenceThreshold: number
  private readonly ambiguityThreshold: number
  private readonly sessionHistory: L2Intent[]

  constructor(config?: IntentClassifierConfig) {
    this.confidenceThreshold = config?.confidenceThreshold ?? 0.65
    this.ambiguityThreshold = config?.ambiguityThreshold ?? 0.15
    this.sessionHistory = config?.sessionHistory ?? []
  }

  /**
   * 执行意图分类
   * @param input 用户输入文本
   * @returns 多级分类结果 + 歧义检测
   */
  classify(input: string): IntentClassificationResult {
    const startTime = Date.now()
    const lowerInput = input.toLowerCase()
    const candidates: IntentCandidate[] = []

    // 第一轮：规则匹配，收集所有命中候选
    for (const rule of L2_RULES) {
      const matchResult = this.matchRule(lowerInput, input, rule)
      if (matchResult.matched) {
        let confidence = rule.baseConfidence * matchResult.strength

        // 历史先验加权：同会话内出现过的意图 +0.08
        if (this.sessionHistory.includes(rule.l2)) {
          confidence = Math.min(1.0, confidence + 0.08)
        }

        candidates.push({
          l1: L2_TO_L1[rule.l2],
          l2: rule.l2,
          confidence,
          matchedBy: matchResult.matchedBy,
        })
      }
    }

    // 按置信度降序排列
    candidates.sort((a, b) => b.confidence - a.confidence)

    // 取 Top-3
    const top3 = candidates.slice(0, 3)

    // 确定最终分类
    const winner = top3[0]
    let l1: L1Intent
    let l2: L2Intent
    let confidence: number

    if (!winner || winner.confidence < this.confidenceThreshold) {
      // 无候选或置信度过低
      // 检查是否存在多意图混合（≥ 3 个候选且置信度均 > 0.5）
      const strongCandidates = candidates.filter(c => c.confidence > 0.5)
      if (strongCandidates.length >= 3) {
        l1 = 'COMPOSE'
        l2 = 'general'
        confidence = 0.5
      } else {
        l1 = 'UNKNOWN'
        l2 = 'unknown'
        confidence = 0
      }
    } else {
      l1 = winner.l1
      l2 = winner.l2
      confidence = winner.confidence

      // ── doc_gen 冲突检测：当输入包含强问题信号时，降低 doc_gen 置信度 ── @since V7.3
      // @since V8.0: 扩展检查 performance_problem 候选，避免"执行速度过慢的问题"被误判为 doc_gen
      if (l2 === 'doc_gen') {
        const problemSignals = /(?:过慢|太慢|超时|未完成|瓶颈|假死|无响应)/
        // 仅当"问题"与性能/执行信号同时出现时才降级（"问题"单独出现不降级，因为文档中"问题"很常见）
        const hasPerfProblemSignal = /(?:速度|性能|执行|运行|加载|处理).*(?:过慢|太慢|很慢|慢|超时|未完成|卡[顿住]?|假死|无响应)/.test(input)
          || /(?:执行|运行|加载|处理).*(?:两|2|三|3|\d+).*(?:小时|分钟).*(?:未|没|还)/.test(input)
        if (problemSignals.test(input) && hasPerfProblemSignal) {
          confidence *= 0.5
          // 重新检查是否有更强的候选（包括 performance_problem）
          const perfCandidate = candidates.find(c => c.l2 === 'performance')
          const perfProblemCandidate = candidates.find(c => c.l2 === 'performance_problem')
          const bugCandidate = candidates.find(c => c.l2 === 'bug_fix')
          const betterCandidate = perfProblemCandidate || perfCandidate || bugCandidate
          if (betterCandidate && betterCandidate.confidence > confidence) {
            l1 = betterCandidate.l1
            l2 = betterCandidate.l2
            confidence = betterCandidate.confidence
          }
        }
      }

      // ── bug_fix 冲突检测：当输入包含强性能/超时信号时，让 performance/performance_problem 胜出 ── @since V7.5
      // @since V8.2: 扩展检查范围 — 不仅检查 performance，也检查 performance_problem；新增工作流超时模式
      if (l2 === 'bug_fix') {
        const perfKeywords = /(?:速度|性能|执行|运行|加载|处理).*(?:过慢|太慢|很慢|慢|超时|未完成|卡[顿住]?|假死|无响应)/
        const perfTimePattern = /(?:执行|运行|加载|处理).*(?:两|2|三|3|\d+).*(?:小时|分钟).*(?:未|没|还)/
        // @since V8.2: 工作流步骤超时 / 规避风险场景
        const workflowTimeoutPattern = /(?:步骤|节点|环节|任务).*(?:超时|失败|超时失败)/
        const riskAvoidPattern = /规避.*(?:超时|风险)/
        if (perfKeywords.test(input) || perfTimePattern.test(input) || workflowTimeoutPattern.test(input) || riskAvoidPattern.test(input)) {
          confidence *= 0.4
          // @since V8.2: 优先选择 performance_problem（比 performance 更精准匹配问题诊断场景）
          const perfProblemCandidate = candidates.find(c => c.l2 === 'performance_problem')
          const perfCandidate = candidates.find(c => c.l2 === 'performance')
          const betterCandidate = perfProblemCandidate || perfCandidate
          if (betterCandidate && betterCandidate.confidence > confidence) {
            l1 = betterCandidate.l1
            l2 = betterCandidate.l2
            confidence = betterCandidate.confidence
          }
        }
      }

      // ── refactor 冲突检测：当输入包含功能/提示开关信号时，降低 refactor 置信度 ── @since V7.4
      if (l2 === 'refactor') {
        const toggleSignals = /(?:关闭|禁用|隐藏|去掉|去除|移除|开启|启用|打开|显示|激活|保留|不影响).*(?:提示|功能|选项|引擎|模式|按钮|弹窗|通知|建议|逻辑)/
        const preserveSignals = /(?:保留|不影响|不改变|不破坏).*(?:功能|逻辑|引擎|现有|原有)/
        if (toggleSignals.test(input) || preserveSignals.test(input)) {
          confidence *= 0.4
          const configCandidate = candidates.find(c => c.l2 === 'config')
          if (configCandidate && configCandidate.confidence > confidence) {
            l1 = configCandidate.l1
            l2 = configCandidate.l2
            confidence = configCandidate.confidence
          }
        }

        // ── refactor 冲突检测：强文档信号时压制 refactor ── @since V7.5
        // 当输入包含 ≥3 个文档/Wiki/专家相关词汇时，refactor 不应胜出
        if (l2 === 'refactor') {
          const docSignals = /(?:文档|wiki|Wiki|知识库|知识管理|专家|expert|persona|手册|对标|规范|指令)/gi
          const docSignalCount = (input.match(docSignals) || []).length
          if (docSignalCount >= 3) {
            confidence *= 0.3
            const docCandidate = candidates.find(c => c.l2 === 'doc_gen')
            if (docCandidate && docCandidate.confidence > confidence) {
              l1 = docCandidate.l1
              l2 = docCandidate.l2
              confidence = docCandidate.confidence
            }
          }
        }
      }

      // ── task_execution 冲突检测：当输入包含功能/提示开关信号时，让 config 胜出 ── @since V8.0
      // @since V8.1: 乘数从 0.4 降至 0.2，确保即使 task_execution 被 pattern-boost（strength 1.2）
      //   也能降到阈值 0.35 以下（0.85 × 1.2 × 0.2 = 0.204 < 0.35 → 回退到 V6.1）
      if (l2 === 'task_execution') {
        const toggleSignals = /(?:关闭|禁用|隐藏|去掉|去除|移除|开启|启用|打开|显示|激活).*(?:提示|功能|选项|引擎|模式|按钮|弹窗|通知|建议|快捷键|快捷)/
        const preserveSignals = /(?:保留|不影响|不改变|不破坏).*(?:功能|逻辑|引擎|现有|原有)/
        if (toggleSignals.test(input) || preserveSignals.test(input)) {
          confidence *= 0.2
          const configCandidate = candidates.find(c => c.l2 === 'config')
          if (configCandidate && configCandidate.confidence > confidence) {
            l1 = configCandidate.l1
            l2 = configCandidate.l2
            confidence = configCandidate.confidence
          }
        }
      }
    }

    // 歧义检测
    const ambiguity = this.detectAmbiguity(top3, l2)

    return {
      l1,
      l2,
      confidence,
      ambiguity,
      candidates: top3,
      elapsedMs: Date.now() - startTime,
    }
  }

  /**
   * 获取 L2 意图的显示标签
   */
  getLabel(l2: L2Intent, lang: 'zh' | 'en' = 'zh'): string {
    return lang === 'zh' ? L2_LABELS_ZH[l2] : L2_LABELS_EN[l2]
  }

  /**
   * 获取 L1 下的所有 L2 子类
   */
  getL2ForL1(l1: L1Intent): L2Intent[] {
    return L1_TO_L2[l1] || []
  }

  // ─── 内部方法 ─────────────────────────────────────────────────────

  /** 匹配单条规则 */
  private matchRule(lowerInput: string, originalInput: string, rule: L2Rule): { matched: boolean; strength: number; matchedBy: string } {
    let matchedBy = ''
    let strength = 0

    // 关键词匹配
    if (rule.keywords) {
      for (const kw of rule.keywords) {
        if (lowerInput.includes(kw.toLowerCase())) {
          matchedBy = `keyword:${kw}`
          strength = Math.max(strength, 1.0)
          break
        }
      }
    }

    // 正则匹配（更强信号）
    if (rule.patterns) {
      for (const pattern of rule.patterns) {
        if (pattern.test(originalInput) || pattern.test(lowerInput)) {
          matchedBy = `pattern:${pattern.source}`
          strength = Math.max(strength, 1.1)  // 正则匹配略高于纯关键词
          break
        }
      }
    }

    return {
      matched: strength > 0,
      strength: Math.min(strength, 1.2),  // 上限 1.2
      matchedBy,
    }
  }

  /** 歧义检测 */
  private detectAmbiguity(top3: IntentCandidate[], winnerL2: L2Intent): AmbiguityResult {
    if (top3.length < 2) {
      return { isAmbiguous: false, resolution: 'auto' }
    }

    const first = top3[0]!
    const second = top3[1]!
    const gap = first.confidence - second.confidence

    if (gap >= this.ambiguityThreshold) {
      // 置信度差距足够大，无歧义
      return { isAmbiguous: false, resolution: 'auto' }
    }

    if (first.confidence < this.confidenceThreshold) {
      // 最高候选本身也不够置信，降级到兜底
      return {
        isAmbiguous: true,
        resolution: 'fallback',
        candidates: top3.map(c => ({
          l2: c.l2,
          label: L2_LABELS_ZH[c.l2],
          confidence: c.confidence,
        })),
      }
    }

    // 两个候选置信度接近，需澄清
    return {
      isAmbiguous: true,
      resolution: 'clarify',
      candidates: [
        { l2: first.l2, label: L2_LABELS_ZH[first.l2], confidence: first.confidence },
        { l2: second.l2, label: L2_LABELS_ZH[second.l2], confidence: second.confidence },
      ],
    }
  }
}

// ─── 工厂函数 ────────────────────────────────────────────────────────

let _defaultInstance: EnhanceIntentClassifier | null = null

/**
 * 获取默认意图分类器实例（单例）
 * 可传入 sessionHistory 更新会话先验
 */
export function getIntentClassifier(config?: IntentClassifierConfig): EnhanceIntentClassifier {
  if (!_defaultInstance || config?.sessionHistory?.length) {
    _defaultInstance = new EnhanceIntentClassifier(config)
  }
  return _defaultInstance
}
