package search

import (
	"sort"
	"strings"

	"github.com/aisim/kb-cli/internal/graph"
	"github.com/aisim/kb-cli/internal/index"
)

// SearchOptions 搜索选项
type SearchOptions struct {
	Expanded    []string // 扩展词
	Symptom     []string // 症状词
	TopN        int      // 返回前 N 条
	WithContent bool     // 返回完整文件内容
	WithLinks   bool     // 返回关联文档链接
	TextWeight  float64  // 文本分权重（0~1，缺省 0.5；RWR 图质量权重 = 1 - TextWeight）
}

// SearchResult 搜索结果
type SearchResult struct {
	ID      int64    `json:"id"`
	Path    string   `json:"path"`
	Title   string   `json:"title"`
	Section string   `json:"section"`
	Score   int      `json:"score"`
	Status  string   `json:"status,omitempty"`
	Content string   `json:"content,omitempty"` // 文件内容（WithContent=true 时填充）
	Links   []string `json:"links,omitempty"`   // 关联文档路径（WithLinks=true 时填充）
}

// Search 执行搜索（双信号加权：文本位置分 × TextWeight + RWR 图质量 × (1-TextWeight)，
// 草稿态/待审阅降权 0.6）
func Search(store *index.Store, keywords []string, opts SearchOptions) ([]SearchResult, error) {
	// 合并所有关键词
	allKeywords := append(append(keywords, opts.Expanded...), opts.Symptom...)

	// 长 CJK 词 bigram 展开（统一下沉）：FTS5 unicode61 把连续中文当整串单 token，
	// 长复合词整串 LIKE 匹配不到；ExpandCJKKeywords 拆成 bigram 滑动窗口
	// （原词保留、去重保序）。bigram 参与检索，textScore 按 ScoreExpanded 档计权
	// （与现有 Expanded 机制一致），原词仍按原词档。
	searchKeywords := ExpandCJKKeywords(allKeywords)
	originalSet := make(map[string]bool, len(allKeywords))
	for _, kw := range allKeywords {
		originalSet[kw] = true
	}
	var bigrams []string
	for _, kw := range searchKeywords {
		if !originalSet[kw] {
			bigrams = append(bigrams, kw)
		}
	}

	// 1. 双通道检索（ASCII 走 FTS，CJK 走 LIKE）
	candidates, err := store.KeywordSearch(searchKeywords, 100)
	if err != nil {
		return nil, err
	}
	if len(candidates) == 0 {
		return nil, nil
	}

	// 2. 文本分（沿用位置加权，aliases 按 title 档计权）
	textScore := make(map[int64]int, len(candidates))
	for _, r := range candidates {
		var score int
		for _, kw := range keywords {
			score += scoreResult(r, kw, ScoreNormal)
		}
		for _, kw := range opts.Expanded {
			score += scoreResult(r, kw, ScoreExpanded)
		}
		// bigram 展开词按 Expanded 档计权（与用户显式扩展词同档）
		for _, kw := range bigrams {
			score += scoreResult(r, kw, ScoreExpanded)
		}
		for _, kw := range opts.Symptom {
			score += scoreResult(r, kw, ScoreSymptom)
		}
		textScore[r.ID] = score
	}

	// 3. RWR 图质量（种子 = 候选前 20，全量加载邻接后按种子收敛）
	seedIDs := make([]int64, 0, len(candidates))
	for _, r := range candidates {
		if len(seedIDs) >= 20 {
			break
		}
		seedIDs = append(seedIDs, r.ID)
	}
	rwrMass := map[int64]float64{}
	if len(seedIDs) > 0 {
		adj, err := store.LoadRWRGraph()
		if err == nil {
			rwrMass = graph.RWR(seedIDs, adj, 0.25)
		}
	}

	// 4. 双信号加权：finalScore = norm(textScore)*tw + rwrMass*(1-tw)
	tw := opts.TextWeight
	if tw <= 0 || tw > 1 {
		tw = 0.5
	}
	// 先求文本分真实 min/max，再按 (s-minT)/(maxT-minT) 归一化
	minT, maxT := 0, 0
	for _, s := range textScore {
		if minT == 0 && maxT == 0 {
			minT, maxT = s, s
		} else {
			if s < minT {
				minT = s
			}
			if s > maxT {
				maxT = s
			}
		}
	}
	// status 降权：草稿态或待审阅板块 ×0.6
	statusFactor := make(map[int64]float64, len(candidates))
	for _, r := range candidates {
		if r.Section == "待审阅" || isDraftStatus(r.Status) {
			statusFactor[r.ID] = 0.6
		} else {
			statusFactor[r.ID] = 1.0
		}
	}

	var results []SearchResult
	for _, r := range candidates {
		ts := float64(textScore[r.ID])
		if maxT > minT {
			ts = (ts - float64(minT)) / float64(maxT - minT)
		} else if maxT > 0 {
			ts = 1
		}
		final := ts*tw + rwrMass[r.ID]*(1-tw)
		final *= statusFactor[r.ID]
		results = append(results, SearchResult{
			ID:      r.ID,
			Path:    r.Path,
			Title:   r.Title,
			Section: r.Section,
			Score:   int(final * 100),
			Status:  r.Status,
		})
	}

	// 按分数排序
	sort.Slice(results, func(i, j int) bool {
		return results[i].Score > results[j].Score
	})

	// 限制返回数量
	if opts.TopN > 0 && len(results) > opts.TopN {
		results = results[:opts.TopN]
	}

	// 获取内容（如果请求）
	if opts.WithContent {
		for i := range results {
			content, _, _, err := store.GetNodeContent(results[i].ID)
			if err == nil {
				results[i].Content = content
			}
		}
	}

	// 获取关联链接（如果请求）
	if opts.WithLinks {
		for i := range results {
			links, err := store.GetNodeLinks(results[i].ID)
			if err == nil {
				results[i].Links = links
			}
		}
	}

	return results, nil
}

// isDraftStatus 草稿态降权判断（草稿/待确认/跟进中 降权 0.6）
func isDraftStatus(status string) bool {
	switch status {
	case "草稿", "待确认", "跟进中":
		return true
	}
	return false
}

// scoreResult 计算单个结果的得分
func scoreResult(r index.FTSResult, keyword string, scoreType ScoreType) int {
	score := 0
	kw := strings.ToLower(keyword)

	// 路径匹配
	if strings.Contains(strings.ToLower(r.Path), kw) {
		score += CalcScore(keyword, "path", scoreType)
	}

	// 标题匹配
	if strings.Contains(strings.ToLower(r.Title), kw) {
		score += CalcScore(keyword, "title", scoreType)
	}

	// 板块匹配
	if strings.Contains(strings.ToLower(r.Section), kw) {
		score += CalcScore(keyword, "tag", scoreType)
	}

	// 别名匹配（命中按 title 档计权，一次命中即计）
	if len(r.Aliases) > 0 {
		for _, a := range r.Aliases {
			if strings.Contains(strings.ToLower(a), kw) {
				score += CalcScore(keyword, "title", scoreType)
				break
			}
		}
	}

	// 内容匹配（FTS 已经匹配，给基础分）
	score += CalcScore(keyword, "content", scoreType)

	return score
}