/**
 * NAC Knowledge Engine - RAG检索增强模块 v2.0
 *
 * 功能：从MongoDB知识库中检索与用户问题最相关的合规规则条文，
 *       作为上下文注入到AI Agent的提示词中，提升回答的准确性和可溯源性。
 *
 * 检索策略（四层递进）：
 *   1. 意图识别 - 提取辖区、资产类别、规则类型等结构化信息
 *   2. MongoDB全文检索（$text index）- 关键词精确匹配
 *   3. 正则关键词匹配 - 覆盖全文索引未命中的情况
 *   4. 随机采样 - 兜底策略，确保始终有上下文
 *
 * 支持两种规则文档格式：
 *   - 旧格式：{ ruleId, ruleName, jurisdiction, category, content }
 *   - 新格式（贸易规则）：{ ruleId, ruleName, jurisdiction, assetClass, ruleType, content, contentEn, ownershipRequirements, tradingRequirements }
 */

import { getMongoDb, COLLECTIONS } from "./mongodb";
import { semanticSearch, buildVectorIndex, getEmbeddingStatus } from "./embeddingRetrieval";

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

export interface RetrievedRule {
  ruleId: string;
  ruleName: string;
  jurisdiction: string;
  category: string;
  assetClass?: string;
  ruleType?: string;
  content: string;
  description?: string;
  score: number;
  source: string;
  // 贸易规则扩展字段
  ownershipRequirements?: Record<string, unknown>;
  tradingRequirements?: Record<string, unknown>;
  legalBasis?: string;
  sourceUrl?: string;
  complianceLevel?: string;
  tags?: string[];
}

export interface RAGContext {
  rules: RetrievedRule[];
  totalFound: number;
  retrievalMethod: "fulltext" | "regex" | "structured" | "sample" | "semantic" | "hybrid" | "none";
  queryKeywords: string[];
  detectedJurisdiction?: string;
  detectedAssetClass?: string;
  detectedRuleType?: string;
}

// ─── 意图识别：辖区/资产类别/规则类型映射 ──────────────────────────

const JURISDICTION_MAP: Record<string, string> = {
  // 中文 → 代码
  "美国": "US", "美利坚": "US",
  "欧盟": "EU", "欧洲": "EU",
  "英国": "GB", "英格兰": "GB",
  "香港": "HK", "港": "HK",
  "新加坡": "SG", "狮城": "SG",
  "迪拜": "AE", "阿联酋": "AE", "阿布扎比": "AE",
  "中国": "CN", "大陆": "CN", "内地": "CN",
  "日本": "JP",
  "澳大利亚": "AU", "澳洲": "AU",
  "瑞士": "CH",
  "韩国": "KR",
  "加拿大": "CA",
  "德国": "DE",
  "法国": "FR",
  "开曼": "KY", "开曼群岛": "KY",
  "英属维尔京": "VG", "BVI": "VG",
  "巴哈马": "BS",
  "百慕大": "BM",
  // 英文代码直接映射
  "US": "US", "EU": "EU", "GB": "GB", "HK": "HK", "SG": "SG",
  "AE": "AE", "CN": "CN", "JP": "JP", "AU": "AU", "CH": "CH",
  "KR": "KR", "CA": "CA", "DE": "DE", "FR": "FR",
};

const ASSET_CLASS_MAP: Record<string, string> = {
  // 房地产
  "房地产": "RealEstate", "不动产": "RealEstate", "房产": "RealEstate",
  "商业地产": "RealEstate", "住宅": "RealEstate", "写字楼": "RealEstate",
  "REITs": "RealEstate", "REIT": "RealEstate", "房地产投资信托": "RealEstate",
  // 金融证券
  "证券": "FinancialSecurities", "股票": "FinancialSecurities", "债券": "FinancialSecurities",
  "基金": "FinancialSecurities", "期货": "FinancialSecurities", "期权": "FinancialSecurities",
  "security": "FinancialSecurities", "securities": "FinancialSecurities",
  // 大宗商品
  "大宗商品": "Commodities", "黄金": "Commodities", "白银": "Commodities",
  "原油": "Commodities", "铜": "Commodities", "铁矿石": "Commodities",
  "农产品": "Commodities", "粮食": "Commodities",
  // 数字资产
  "数字资产": "DigitalAssets", "加密资产": "DigitalAssets", "虚拟资产": "DigitalAssets",
  "代币": "DigitalAssets", "Token": "DigitalAssets", "NFT": "DigitalAssets",
  "稳定币": "DigitalAssets", "XTZH": "DigitalAssets",
  // 碳排放权
  "碳排放": "EnvironmentalRights", "碳信用": "EnvironmentalRights",
  "碳权": "EnvironmentalRights", "排放权": "EnvironmentalRights",
  // 知识产权
  "知识产权": "IntellectualProperty", "专利": "IntellectualProperty",
  "商标": "IntellectualProperty", "版权": "IntellectualProperty",
  // 基础设施
  "基础设施": "Infrastructure", "电力": "Infrastructure", "水务": "Infrastructure",
  // 应收账款
  "应收账款": "Receivables", "贸易融资": "Receivables",
};

const RULE_TYPE_MAP: Record<string, string> = {
  "所有权": "ownership_verification", "产权": "ownership_verification",
  "确权": "ownership_verification", "所有人": "ownership_verification",
  "交易": "trading_permission", "买卖": "trading_permission",
  "上市": "trading_permission", "流通": "trading_permission",
  "KYC": "kyc_aml", "AML": "kyc_aml", "反洗钱": "kyc_aml",
  "身份验证": "kyc_aml", "尽职调查": "kyc_aml",
  "税": "tax_compliance", "税务": "tax_compliance", "纳税": "tax_compliance",
  "跨境": "cross_border", "境外": "cross_border", "外资": "cross_border",
  "结算": "settlement", "清算": "settlement",
  "托管": "custody", "保管": "custody",
  "披露": "disclosure", "信息披露": "disclosure",
  "牌照": "licensing", "许可证": "licensing", "执照": "licensing",
};

/**
 * 从用户问题中识别结构化意图（辖区/资产类别/规则类型）
 */
function detectQueryIntent(query: string): {
  jurisdiction?: string;
  assetClass?: string;
  ruleType?: string;
  keywords: string[];
} {
  let detectedJurisdiction: string | undefined;
  let detectedAssetClass: string | undefined;
  let detectedRuleType: string | undefined;

  // 检测司法辖区
  for (const [term, code] of Object.entries(JURISDICTION_MAP)) {
    if (query.includes(term)) {
      detectedJurisdiction = code;
      break;
    }
  }

  // 检测资产类别
  for (const [term, cls] of Object.entries(ASSET_CLASS_MAP)) {
    if (query.toLowerCase().includes(term.toLowerCase())) {
      detectedAssetClass = cls;
      break;
    }
  }

  // 检测规则类型
  for (const [term, type] of Object.entries(RULE_TYPE_MAP)) {
    if (query.includes(term)) {
      detectedRuleType = type;
      break;
    }
  }

  // 提取关键词
  const STOP_WORDS = new Set([
    "的", "了", "是", "在", "我", "有", "和", "就", "不", "人", "都", "一", "一个",
    "上", "也", "很", "到", "说", "要", "去", "你", "会", "着", "没有", "看", "好",
    "自己", "这", "那", "什么", "如何", "怎么", "请问", "帮我", "告诉", "介绍",
    "关于", "对于", "针对", "需要", "可以", "应该", "必须", "规定", "要求",
    "the", "a", "an", "is", "are", "was", "were", "be", "been", "being",
    "have", "has", "had", "do", "does", "did", "will", "would", "could", "should",
    "what", "how", "when", "where", "why", "which", "who",
  ]);

  const chineseTerms = query.match(/[\u4e00-\u9fa5]{2,8}/g) || [];
  const englishTerms = query.match(/[a-zA-Z]{3,}/g) || [];
  const allTerms = [...chineseTerms, ...englishTerms];
  const keywords = Array.from(new Set(allTerms.filter(t => !STOP_WORDS.has(t.toLowerCase())))).slice(0, 8);

  return { jurisdiction: detectedJurisdiction, assetClass: detectedAssetClass, ruleType: detectedRuleType, keywords };
}

// ─── 主检索函数 ───────────────────────────────────────────────────

/**
 * 从MongoDB知识库检索相关规则（RAG核心函数）
 */
export async function retrieveRelevantRules(
  query: string,
  options: {
    maxResults?: number;
    jurisdictions?: string[];
    categories?: string[];
    language?: string;
  } = {}
): Promise<RAGContext> {
  const { maxResults = 6, jurisdictions, categories, language = "zh" } = options;
  const db = await getMongoDb();

  if (!db) {
    return { rules: [], totalFound: 0, retrievalMethod: "none", queryKeywords: [] };
  }

  // 意图识别
  const intent = detectQueryIntent(query);
  const keywords = intent.keywords;

  const collection = db.collection(COLLECTIONS.COMPLIANCE_RULES);

  // 构建基础过滤条件（兼容新旧两种文档格式）
  const baseFilter: Record<string, unknown> = {};

  // 优先使用意图识别的辖区，其次使用传入的辖区参数
  const targetJurisdictions = jurisdictions ||
    (intent.jurisdiction ? [intent.jurisdiction, "GLOBAL"] : undefined);

  if (targetJurisdictions && targetJurisdictions.length > 0) {
    baseFilter.jurisdiction = { $in: targetJurisdictions };
  }

  // 资产类别过滤（新格式用 assetClass，旧格式用 category）
  const targetAssetClass = intent.assetClass;
  if (targetAssetClass) {
    baseFilter.$or = [
      { assetClass: { $in: [targetAssetClass, "ALL"] } },
      { category: { $regex: targetAssetClass, $options: "i" } },
    ];
  } else if (categories && categories.length > 0) {
    baseFilter.category = { $in: categories };
  }

  // 规则类型过滤
  if (intent.ruleType) {
    baseFilter.ruleType = intent.ruleType;
  }

  let rules: RetrievedRule[] = [];
  let retrievalMethod: RAGContext["retrievalMethod"] = "none";

  // ── 策略1：结构化精确匹配（意图识别命中时）──────────────────
  if (intent.jurisdiction || intent.assetClass || intent.ruleType) {
    try {
      const structuredResults = await collection
        .find(baseFilter)
        .sort({ tier: 1, relevance: -1 })
        .limit(maxResults)
        .toArray();

      if (structuredResults.length > 0) {
        rules = structuredResults.map((doc, idx) => {
          // 结构化检索基于精确匹配，给予较高基础分
          const baseScore = Math.max(0.6, 1.0 - (idx / Math.max(1, structuredResults.length)) * 0.3);
          return formatRule(doc, language, idx, structuredResults.length, baseScore);
        });
        retrievalMethod = "structured";
      }
    } catch (e) {
      console.warn("[RAG] 结构化检索失败:", (e as Error).message);
    }
  }

  // ── 策略2：MongoDB全文检索 ────────────────────────────────────
  if (rules.length < 3 && keywords.length > 0) {
    try {
      const searchText = keywords.join(" ");
      const textFilter: Record<string, unknown> = {
        $text: { $search: searchText },
      };
      // 不加辖区过滤，扩大全文检索范围
      if (intent.assetClass) {
        textFilter.$or = [
          { assetClass: { $in: [intent.assetClass, "ALL"] } },
          { category: { $regex: intent.assetClass, $options: "i" } },
        ];
      }

      const textResults = await collection
        .find(textFilter, {
          projection: {
            score: { $meta: "textScore" },
            ruleId: 1, ruleName: 1, jurisdiction: 1, category: 1, assetClass: 1,
            ruleType: 1, content: 1, contentEn: 1, description: 1,
            ownershipRequirements: 1, tradingRequirements: 1,
            legalBasis: 1, sourceUrl: 1, complianceLevel: 1, tags: 1,
            "translations.zh": 1, "translations.en": 1,
          },
        })
        .sort({ score: { $meta: "textScore" } })
        .limit(maxResults)
        .toArray();

      if (textResults.length > 0) {
        const newRules = textResults
          .filter(r => !rules.some(existing => existing.ruleId === String(r.ruleId || r._id)))
          .map((doc, idx) => {
          // textScore 可能为 undefined 或 NaN，需要安全处理
          const textScore = typeof doc.score === "number" && !isNaN(doc.score as number)
            ? Math.min(1.0, (doc.score as number) / 10)  // textScore 通常在 0-10 范围，归一化到 0-1
            : undefined;
          return formatRule(doc, language, idx, textResults.length, textScore);
        });
        rules = [...rules, ...newRules].slice(0, maxResults);
        if (retrievalMethod === "none") retrievalMethod = "fulltext";
      }
    } catch (e) {
      console.warn("[RAG] 全文检索失败，降级到正则检索:", (e as Error).message);
    }
  }

  // ── 策略3：正则关键词匹配 ─────────────────────────────────────
  if (rules.length < 3 && keywords.length > 0) {
    try {
      const regexConditions = keywords.slice(0, 4).map(kw => ({
        $or: [
          { ruleName: { $regex: kw, $options: "i" } },
          { ruleNameEn: { $regex: kw, $options: "i" } },
          { description: { $regex: kw, $options: "i" } },
          { content: { $regex: kw, $options: "i" } },
          { contentEn: { $regex: kw, $options: "i" } },
          { tags: { $regex: kw, $options: "i" } },
          { "translations.zh": { $regex: kw, $options: "i" } },
        ],
      }));

      const regexFilter: Record<string, unknown> = { $and: regexConditions };

      const regexResults = await collection
        .find(regexFilter)
        .limit(maxResults)
        .toArray();

      if (regexResults.length > 0) {
        const newRules = regexResults
          .filter(r => !rules.some(existing => existing.ruleId === String(r.ruleId || r._id)))
          .map((doc, idx) => {
            // 正则检索基于关键词匹配，给予中等分数
            const baseScore = Math.max(0.5, 0.9 - (idx / Math.max(1, regexResults.length)) * 0.4);
            return formatRule(doc, language, idx, regexResults.length, baseScore);
          });
        rules = [...rules, ...newRules].slice(0, maxResults);
        if (retrievalMethod === "none") retrievalMethod = "regex";
      }
    } catch (e) {
      console.warn("[RAG] 正则检索失败:", (e as Error).message);
    }
  }

  // ── 策略4：随机采样（兜底策略）──────────────────────────────
  if (rules.length === 0) {
    try {
      const sampleResults = await collection
        .aggregate([
          { $match: {} },
          { $sample: { size: maxResults } },
        ])
        .toArray();

      if (sampleResults.length > 0) {
        rules = sampleResults.map((doc, idx) => formatRule(doc, language, idx, sampleResults.length, 0.3));
        retrievalMethod = "sample";
      }
    } catch (e) {
      console.warn("[RAG] 随机采样失败:", (e as Error).message);
    }
  }

  // ── 策略5：语义向量检索（增强层）──────────────────────────────
  // 无论前面是否找到结果，都尝试语义检索来补充或替换低质量结果
  try {
    // 预热向量索引（异步，不阻塞）
    buildVectorIndex().catch(() => {});

    const semanticResults = await semanticSearch(query, {
      topK: maxResults,
      jurisdiction: intent.jurisdiction,
      assetClass: intent.assetClass,
      ruleType: intent.ruleType,
      minScore: 0.05,
    });

    if (semanticResults.length > 0) {
      if (rules.length === 0) {
        // 关键词检索无结果，完全使用语义检索
        rules = semanticResults.map(r => ({
          ruleId: r.ruleId,
          ruleName: r.ruleName,
          jurisdiction: r.jurisdiction,
          category: r.assetClass,
          assetClass: r.assetClass,
          ruleType: r.ruleType,
          content: r.content,
          score: r.score,
          source: `${r.jurisdiction}·${r.assetClass}·${r.ruleName.slice(0, 20)}`,
          legalBasis: r.legalBasis,
          ownershipRequirements: r.ownershipRequirements,
          tradingRequirements: r.tradingRequirements,
          sourceUrl: r.sourceUrl,
          complianceLevel: r.complianceLevel,
          tags: r.tags,
        }));
        retrievalMethod = "semantic";
      } else {
        // 混合：将语义检索结果中未出现的规则追加到结果末尾
        const existingIds = new Set(rules.map(r => r.ruleId));
        const newSemanticRules = semanticResults
          .filter(r => !existingIds.has(r.ruleId))
          .slice(0, Math.max(0, maxResults - rules.length))
          .map(r => ({
            ruleId: r.ruleId,
            ruleName: r.ruleName,
            jurisdiction: r.jurisdiction,
            category: r.assetClass,
            assetClass: r.assetClass,
            ruleType: r.ruleType,
            content: r.content,
            score: r.score * 0.9, // 语义补充结果略降分
            source: `${r.jurisdiction}·${r.assetClass}·${r.ruleName.slice(0, 20)}`,
            legalBasis: r.legalBasis,
            ownershipRequirements: r.ownershipRequirements,
            tradingRequirements: r.tradingRequirements,
            sourceUrl: r.sourceUrl,
            complianceLevel: r.complianceLevel,
            tags: r.tags,
          }));

        if (newSemanticRules.length > 0) {
          rules = [...rules, ...newSemanticRules];
          retrievalMethod = "hybrid";
        }
      }
    }
  } catch (e) {
    console.warn("[RAG] 语义检索失败（降级到关键词结果）:", (e as Error).message);
  }

  return {
    rules,
    totalFound: rules.length,
    retrievalMethod,
    queryKeywords: keywords,
    detectedJurisdiction: intent.jurisdiction,
    detectedAssetClass: intent.assetClass,
    detectedRuleType: intent.ruleType,
  };
}

// ─── 格式化工具函数 ───────────────────────────────────────────────

function formatRule(
  doc: Record<string, unknown>,
  language: string,
  idx: number,
  total: number,
  baseScore?: number
): RetrievedRule {
  // 防止 total=0 时产生 NaN（idx/0 = NaN）
  const safeTotal = total > 0 ? total : 1;
  const score = baseScore !== undefined
    ? (isNaN(baseScore) ? 0.5 : Math.min(1.0, Math.max(0.0, baseScore)))
    : Math.max(0.4, 1.0 - (idx / safeTotal) * 0.5);

  // 兼容新旧两种格式的内容字段
  const translations = doc.translations as Record<string, string> | undefined;
  let content = "";
  if (language === "zh") {
    content = String(doc.content || translations?.zh || doc.contentEn || translations?.en || "");
  } else {
    content = String(doc.contentEn || translations?.en || doc.content || translations?.zh || "");
  }

  // 截断内容到800字（贸易规则内容较长）
  const truncatedContent = content.length > 800
    ? content.slice(0, 800) + "..."
    : content;

  const ruleId = String(doc.ruleId || doc._id || "");
  const ruleName = String(doc.ruleName || doc.ruleNameEn || "未命名规则");
  const jurisdiction = String(doc.jurisdiction || "未知");
  const category = String(doc.category || doc.assetClass || "通用");
  const description = doc.description ? String(doc.description) : undefined;

  return {
    ruleId,
    ruleName,
    jurisdiction,
    category,
    assetClass: doc.assetClass ? String(doc.assetClass) : undefined,
    ruleType: doc.ruleType ? String(doc.ruleType) : undefined,
    content: truncatedContent,
    description,
    score,
    source: `${jurisdiction}·${category}·${ruleName.slice(0, 20)}`,
    ownershipRequirements: doc.ownershipRequirements as Record<string, unknown> | undefined,
    tradingRequirements: doc.tradingRequirements as Record<string, unknown> | undefined,
    legalBasis: doc.legalBasis ? String(doc.legalBasis) : undefined,
    sourceUrl: doc.sourceUrl ? String(doc.sourceUrl) : undefined,
    complianceLevel: doc.complianceLevel ? String(doc.complianceLevel) : undefined,
    tags: Array.isArray(doc.tags) ? doc.tags.map(String) : undefined,
  };
}

// ─── 构建RAG提示词上下文 ─────────────────────────────────────────

/**
 * 将检索到的规则格式化为AI提示词中的上下文段落（增强版）
 */
export function buildRAGPromptContext(ragCtx: RAGContext): string {
  if (ragCtx.rules.length === 0) {
    return "";
  }

  const lines: string[] = [
    "【知识库检索结果】",
    `（共检索到 ${ragCtx.totalFound} 条相关规则，检索方式：${
      ragCtx.retrievalMethod === "semantic" ? "语义向量检索" :
      ragCtx.retrievalMethod === "hybrid" ? "混合检索（关键词+语义）" :
      ragCtx.retrievalMethod === "structured" ? "结构化精确匹配" :
      ragCtx.retrievalMethod === "fulltext" ? "全文关键词检索" :
      ragCtx.retrievalMethod === "regex" ? "正则关键词检索" :
      ragCtx.retrievalMethod === "sample" ? "随机采样（兜底）" : "未知"
    }）`,
  ];

  if (ragCtx.detectedJurisdiction) {
    lines.push(`（识别到司法辖区：${ragCtx.detectedJurisdiction}）`);
  }
  if (ragCtx.detectedAssetClass) {
    lines.push(`（识别到资产类别：${ragCtx.detectedAssetClass}）`);
  }
  lines.push("");

  ragCtx.rules.forEach((rule, idx) => {
    lines.push(`【规则 ${idx + 1}】${rule.ruleName}`);
    const safeScore = (rule.score !== undefined && !isNaN(rule.score)) ? rule.score : 0.5;
    lines.push(`  辖区：${rule.jurisdiction} | 类别：${rule.category} | 相关度：${Math.round(safeScore * 100)}%`);
    if (rule.ruleType) lines.push(`  规则类型：${rule.ruleType}`);
    if (rule.legalBasis) lines.push(`  法律依据：${rule.legalBasis}`);
    if (rule.complianceLevel) lines.push(`  合规级别：${rule.complianceLevel}`);
    if (rule.description) lines.push(`  摘要：${rule.description}`);
    lines.push(`  内容：${rule.content}`);

    // 所有权要求（核心字段）
    if (rule.ownershipRequirements) {
      const req = rule.ownershipRequirements as Record<string, unknown>;
      if (req.proofDocuments && Array.isArray(req.proofDocuments)) {
        lines.push(`  所有权证明文件：${(req.proofDocuments as string[]).join("、")}`);
      }
      if (req.registrationAuthority) {
        lines.push(`  登记机构：${req.registrationAuthority}`);
      }
      if (req.transferMechanism) {
        lines.push(`  转移机制：${req.transferMechanism}`);
      }
      if (req.chainRecognition) {
        lines.push(`  链上法律认可：${req.chainRecognition}`);
      }
      if (req.foreignOwnershipRestriction) {
        lines.push(`  外资限制：${req.foreignOwnershipRestriction}`);
      }
    }

    // 交易要求
    if (rule.tradingRequirements) {
      const req = rule.tradingRequirements as Record<string, unknown>;
      if (req.minimumInvestor) lines.push(`  最低投资者资质：${req.minimumInvestor}`);
      if (req.settlementPeriod) lines.push(`  结算周期：${req.settlementPeriod}`);
      if (req.allowedCurrencies && Array.isArray(req.allowedCurrencies)) {
        lines.push(`  允许结算货币：${(req.allowedCurrencies as string[]).join("、")}`);
      }
    }

    if (rule.sourceUrl) lines.push(`  来源：${rule.sourceUrl}`);
    lines.push("");
  });

  lines.push("请严格基于以上知识库规则回答用户问题，并在回答中注明引用的规则编号和来源。");
  lines.push("如果知识库中没有完全匹配的规则，请基于已有规则进行合理推断，并说明推断依据。");

  return lines.join("\n");
}

// 别名导出（兼容旧版引擎调用）
export const retrieveComplianceRules = retrieveRelevantRules;