/**
 * CmdCode 向量记忆系统 - RRF 融合排序
 * 
 * RRF (Reciprocal Rank Fusion): 
 * 多路搜索结果融合算法，对不同搜索方法的结果进行综合排名
 */

export interface SearchResult {
  id: number
  session_id: string
  role: string
  content: string
  created_at: string
  score: number
  source: 'fts' | 'vec' | 'mixed'
}

/**
 * RRF 融合排序
 * @param resultsMap Map<source, SearchResult[]> 各路搜索结果
 * @param k RRF 参数，默认 60
 */
export function rrfFusion(
  resultsMap: Map<string, SearchResult[]>,
  k: number = 60
): SearchResult[] {
  // 聚合所有结果
  const scoreMap = new Map<number, { result: SearchResult; totalScore: number; sources: Set<string> }>()

  for (const [source, rawResults] of resultsMap) {
    // 同一路结果内按 id 去重（保留首次出现=最高排名）
    const seen = new Set<number>()
    const results = rawResults.filter(r => {
      if (seen.has(r.id)) return false
      seen.add(r.id)
      return true
    })
    results.forEach((result, rank) => {
      const key = result.id
      const rrfScore = 1 / (k + rank + 1)

      if (scoreMap.has(key)) {
        const existing = scoreMap.get(key)!
        existing.totalScore += rrfScore
        existing.sources.add(source)
        existing.result.score = existing.totalScore
        existing.result.source = existing.sources.size > 1 ? 'mixed' : source as 'fts' | 'vec'
      } else {
        scoreMap.set(key, {
          result: { ...result, score: rrfScore, source: source as 'fts' | 'vec' },
          totalScore: rrfScore,
          sources: new Set([source])
        })
      }
    })
  }

  // 排序
  const sorted = Array.from(scoreMap.values())
    .sort((a, b) => b.totalScore - a.totalScore)

  return sorted.map(item => ({
    ...item.result,
    score: item.totalScore,
    source: item.sources.size > 1 ? 'mixed' : item.result.source
  }))
}

/**
 * 简单融合（FTS + 向量结果合并去重）
 */
export function simpleFusion(ftsResults: SearchResult[], vecResults: SearchResult[], limit = 20): SearchResult[] {
  const map = new Map<number, SearchResult>()

  // FTS 结果（权重 1.0）
  ftsResults.forEach((r, i) => {
    map.set(r.id, { ...r, score: 1.0 / (60 + i + 1), source: 'fts' })
  })

  // 向量结果（权重 1.2，略高）
  vecResults.forEach((r, i) => {
    const existing = map.get(r.id)
    if (existing) {
      existing.score += 1.2 / (60 + i + 1)
      existing.source = 'mixed'
    } else {
      map.set(r.id, { ...r, score: 1.2 / (60 + i + 1), source: 'vec' })
    }
  })

  return Array.from(map.values())
    .sort((a, b) => b.score - a.score)
    .slice(0, limit)
}