package index

import (
	"crypto/sha256"
	"encoding/hex"
	"fmt"
	"os"
	"path/filepath"
	"strings"

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

// ReconcileResult 对账结果统计
type ReconcileResult struct {
	Added     int
	Modified  int
	Deleted   int
	Unchanged int
}

// Reconcile 增量对账：stat 比对 → 只对变更文件解析和写库
func Reconcile(store *Store, vaultPath string) (*ReconcileResult, error) {
	res := &ReconcileResult{}

	// 1. vault 侧指纹
	vaultStats, err := vault.ScanVaultStat(vaultPath)
	if err != nil {
		return nil, fmt.Errorf("扫描失败: %w", err)
	}
	dbStats, err := store.GetFileStats()
	if err != nil {
		return nil, fmt.Errorf("读取索引指纹失败: %w", err)
	}

	// 2. 分类
	type change struct {
		path  string
		stat  vault.FileStat
		known FileStat
	}
	var added, modified []change
	for _, v := range vaultStats {
		known, ok := dbStats[v.Path]
		if !ok {
			added = append(added, change{v.Path, v, FileStat{}})
			continue
		}
		if v.Size == known.Size && v.Mtime == known.Mtime {
			res.Unchanged++
			continue
		}
		// size/mtime 变化 → sha256 二次确认
		hash, err := fileHash(filepath.Join(vaultPath, v.Path))
		if err != nil {
			return nil, fmt.Errorf("哈希 %s 失败: %w", v.Path, err)
		}
		if known.ContentHash != "" && hash == known.ContentHash {
			res.Unchanged++ // 内容没变（如 touch），只更新指纹
			store.db.Exec(`UPDATE nodes SET size=?, mtime=? WHERE path=?`, v.Size, v.Mtime, v.Path)
			continue
		}
		modified = append(modified, change{v.Path, v, known})
	}
	// 3. 删除
	for path := range dbStats {
		found := false
		for _, v := range vaultStats {
			if v.Path == path {
				found = true
				break
			}
		}
		if !found {
			if err := store.DeleteNode(path); err != nil {
				return nil, err
			}
			res.Deleted++
		}
	}

	// 4. 新增 + 修改：解析 → 写节点 → 重建该节点边
	for _, c := range append(added, modified...) {
		isNew := c.known.Path == ""
		meta, err := vault.ParseFile(filepath.Join(vaultPath, c.path), c.path)
		if err != nil {
			return nil, fmt.Errorf("解析 %s 失败: %w", c.path, err)
		}
		hash, err := fileHash(filepath.Join(vaultPath, c.path))
		if err != nil {
			return nil, err
		}
		if isNew {
			res.Added++
		} else {
			res.Modified++
		}
		if err := applyNode(store, vaultPath, meta, c.stat.Size, c.stat.Mtime, hash); err != nil {
			return nil, err
		}
	}

	// 5. 悬空链接重试（新增/修改节点可能让 failed 链接变可解析）
	if res.Added+res.Modified > 0 {
		store.RetryUnresolved() // 见 Task 4，此处先以空实现占位编译通过
	}
	return res, nil
}

func fileHash(path string) (string, error) {
	data, err := os.ReadFile(path)
	if err != nil {
		return "", err
	}
	sum := sha256.Sum256(data)
	return hex.EncodeToString(sum[:]), nil
}

// applyNode 写节点 + 重建该节点的出边（tag/entity/wikilink）+ 悬空入表
func applyNode(store *Store, vaultPath string, meta *vault.FileMeta, size, mtime int64, hash string) error {
	n := &graph.Node{
		Path: meta.Path, Title: meta.Title, Section: meta.Section,
		Tags: meta.Tags, Entities: meta.Entities, Wikilinks: meta.Wikilinks,
		Aliases: meta.Aliases, Status: meta.Status, Content: meta.Content,
	}
	if err := store.UpsertNode(n, size, mtime, hash); err != nil {
		return err
	}
	var nodeID int64
	if err := store.db.QueryRow(`SELECT id FROM nodes WHERE path=?`, meta.Path).Scan(&nodeID); err != nil {
		return err
	}
	// 删旧边后重建出边
	if err := store.DeleteNodeEdges(nodeID); err != nil {
		return err
	}
	return store.buildNodeEdges(nodeID, meta)
}

// buildNodeEdges 为单个节点建出边；wikilink 解析失败入 unresolved_links
func (s *Store) buildNodeEdges(nodeID int64, meta *vault.FileMeta) error {
	// tag / entity 边（虚拟节点 ID 沿用 1000000+ 规则，按 label 查现有行避免重复）
	for _, tag := range meta.Tags {
		if err := s.insertTagEntityEdge(nodeID, "tag:"+tag, "tag", tag); err != nil {
			return err
		}
	}
	for _, entity := range meta.Entities {
		if err := s.insertTagEntityEdge(nodeID, "entity:"+entity, "entity", entity); err != nil {
			return err
		}
	}
	// wikilink 边 + 悬空
	for _, link := range meta.Wikilinks {
		targetID, prov, ok := s.resolveWikilink(link)
		if !ok {
			tail := nameTail(link)
			s.db.Exec(`INSERT INTO unresolved_links (from_node, link_text, name_tail, status)
				VALUES (?, ?, ?, 'pending') ON CONFLICT DO NOTHING`, nodeID, link, tail)
			continue
		}
		if err := s.InsertEdge(&graph.Edge{
			FromNode: nodeID, ToNode: targetID,
			Relation: "wikilink", Label: link, Provenance: prov,
		}); err != nil {
			return err
		}
	}
	return nil
}

// insertTagEntityEdge tag/entity 边（虚拟节点按 label 复用 ID）
func (s *Store) insertTagEntityEdge(fromNode int64, key, relation, label string) error {
	var virtualID int64
	err := s.db.QueryRow(`SELECT to_node FROM edges WHERE relation=? AND label=? LIMIT 1`, relation, label).Scan(&virtualID)
	if err != nil {
		// 新虚拟节点：分配 ID = 1000000 + 行号（稳定：按 label 排序后的行号）
		var maxID int64
		s.db.QueryRow(`SELECT COALESCE(MAX(to_node), 1000000) FROM edges WHERE to_node >= 1000000 AND relation=?`, relation).Scan(&maxID)
		virtualID = maxID + 1
	}
	return s.InsertEdge(&graph.Edge{FromNode: fromNode, ToNode: virtualID, Relation: relation, Label: label})
}

// resolveWikilink 解析 wikilink 目标，返回 (nodeID, provenance, ok)
// provenance: exact = 标题或文件名精确匹配；fuzzy = 标题包含匹配
func (s *Store) resolveWikilink(link string) (int64, string, bool) {
	// 去锚点：[[标题|别名]] 取标题部分
	if idx := strings.Index(link, "|"); idx >= 0 {
		link = link[:idx]
	}
	var id int64
	var title, path string
	// 1. 标题精确
	err := s.db.QueryRow(`SELECT id, title, path FROM nodes WHERE title = ? LIMIT 1`, link).Scan(&id, &title, &path)
	if err == nil {
		return id, "exact", true
	}
	// 2. 文件名精确（去 .md 和编号前缀）
	rows, err := s.db.Query(`SELECT id, title, path FROM nodes`)
	if err != nil {
		return 0, "", false
	}
	defer rows.Close()
	var fuzzyID int64
	for rows.Next() {
		var nid int64
		var nTitle, nPath string
		if err := rows.Scan(&nid, &nTitle, &nPath); err != nil {
			return 0, "", false
		}
		base := filepath.Base(nPath)
		base = strings.TrimSuffix(base, ".md")
		if dash := strings.Index(base, "-"); dash >= 0 {
			base = base[dash+1:]
		}
		if base == link || nTitle == link {
			return nid, "exact", true
		}
		if fuzzyID == 0 && strings.Contains(nTitle, link) {
			fuzzyID = nid
		}
	}
	if fuzzyID != 0 {
		return fuzzyID, "fuzzy", true
	}
	return 0, "", false
}

// nameTail 取 link 尾部用于重试匹配（去锚点修饰）
func nameTail(link string) string {
	if idx := strings.Index(link, "|"); idx >= 0 {
		link = link[:idx]
	}
	return link
}

// RetryUnresolved 重试解析悬空链接（Task 4 补全完整实现）
func (s *Store) RetryUnresolved() {}

// QuickCheck 只 stat 比对（不读内容不哈希），返回是否有差异
func QuickCheck(store *Store, vaultPath string) (bool, error) {
	vaultStats, err := vault.ScanVaultStat(vaultPath)
	if err != nil {
		return false, err
	}
	dbStats, err := store.GetFileStats()
	if err != nil {
		return false, err
	}
	if len(vaultStats) != len(dbStats) {
		return true, nil
	}
	for _, v := range vaultStats {
		known, ok := dbStats[v.Path]
		if !ok || v.Size != known.Size || v.Mtime != known.Mtime {
			return true, nil
		}
	}
	return false, nil
}