package squad

import (
	"context"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"io"
	"os"
	"path/filepath"
	"strings"
	"time"
	"unicode"
	"unicode/utf8"

	"chat-agent-system/internal/agent"
	"chat-agent-system/internal/stream"
)

// ProhibitedPhrases 医疗器械文档小队严禁出现的敷衍套话与省略词
var ProhibitedPhrases = []string{
	"不做展开",
	"不展开",
	"篇幅有限",
	"从略",
	"不赘述",
	"略过细节",
	"仅作概要",
	"待续",
	"…（略）",
	"（略）",
}

// QualityGate 负责小队交付物的三层质量门禁与合规审计
type QualityGate struct{}

func NewQualityGate() *QualityGate {
	return &QualityGate{}
}

// Validate 对交付正文执行静态 AST 与质量合规校验
func (q *QualityGate) Validate(wsDir string, taskKey string, content string) (*QualityReport, error) {
	now := time.Now()
	report := &QualityReport{
		Passed:            true,
		Score:             100.0,
		TitleCheck:        true,
		MissingSections:   make([]string, 0),
		ProhibitedPhrases: make([]string, 0),
		Violations:        make([]string, 0),
		QuoteMatches:      true,
		CheckedAt:         now,
	}

	// 1. 检查标题完整性 (对比 template.md 的 ## 章节)
	tmplPath := filepath.Join(wsDir, "template.md")
	tmplData, err := os.ReadFile(tmplPath)
	if err == nil {
		expectedHeadings := extractHeadings(string(tmplData))
		actualHeadings := extractHeadings(content)
		for _, h := range expectedHeadings {
			found := false
			for _, act := range actualHeadings {
				if strings.Contains(act, h) || strings.Contains(h, act) {
					found = true
					break
				}
			}
			if !found && !strings.Contains(content, h) {
				report.MissingSections = append(report.MissingSections, h)
				report.Violations = append(report.Violations, fmt.Sprintf("缺少必填章节: %s", h))
				report.Score -= 15.0
			}
		}
		if len(report.MissingSections) > 0 {
			report.TitleCheck = false
			report.Passed = false
		}
	}

	// 2. 检查敷衍违规套话（否定性自检/禁令复述不计入，避免门禁自污染）
	for _, phrase := range ProhibitedPhrases {
		if containsProhibitedUsage(content, phrase) {
			report.ProhibitedPhrases = append(report.ProhibitedPhrases, phrase)
			// 违规说明勿回写禁用原词，避免修复指令/自检再次自污染
			report.Violations = append(report.Violations, "检测到正文中的省略/敷衍写法（须实质展开；自检勿复述禁用原词）")
			report.Score -= 20.0
			report.Passed = false
		}
	}

	// 3. 检查未渲染的双大括号模板占位符
	if strings.Contains(content, "{{") && strings.Contains(content, "}}") {
		report.Violations = append(report.Violations, "检测到未替换的双大括号占位符 {{...}}")
		report.Score -= 10.0
		report.Passed = false
	}

	// 4. CDO 报价任务检查
	if taskKey == "cdo_quote" {
		xlsxPath := filepath.Join(wsDir, "CDO报价核算-V01.xlsx")
		if _, err := os.Stat(xlsxPath); err != nil {
			report.QuoteMatches = false
			report.Violations = append(report.Violations, "CDO 报价任务缺少配套核算文件 CDO报价核算-V01.xlsx")
			report.Score -= 25.0
			report.Passed = false
		}
	}

	// 5. 智能产品经理工作流：系统需求规格书检查
	if taskKey == "system_reqs" {
		if !strings.Contains(content, "REQ-") && !strings.Contains(content, "SYS-REQ") {
			report.Violations = append(report.Violations, "系统需求规格书缺少规范的需求编号（如 REQ-01 / SYS-REQ-01）")
			report.Score -= 20.0
			report.Passed = false
		}
		hasVerification := strings.Contains(content, "测试") || strings.Contains(content, "分析") ||
			strings.Contains(content, "审查") || strings.Contains(content, "演示") ||
			strings.Contains(content, "检验") || strings.Contains(content, "检") || strings.Contains(content, "测")
		if !hasVerification {
			report.Violations = append(report.Violations, "系统需求清单缺少验证方式字段（测试/分析/审查/演示）")
			report.Score -= 15.0
			report.Passed = false
		}
	}

	// 6. 智能测试经理工作流：系统验证方案及计划检查
	if taskKey == "test_manager" {
		if !strings.Contains(content, "TC-") && !strings.Contains(content, "TEST-") {
			report.Violations = append(report.Violations, "系统验证方案缺少规范的测试用例编号（如 TC-01 / TEST-01）")
			report.Score -= 20.0
			report.Passed = false
		}
		if !strings.Contains(content, "REQ-") {
			report.Violations = append(report.Violations, "系统验证方案缺少对上游系统需求编号（REQ-）的追溯覆盖")
			report.Score -= 15.0
			report.Passed = false
		}
		tcPath := filepath.Join(wsDir, "artifacts", "test_cases.json")
		if tcData, err := os.ReadFile(tcPath); err == nil && len(tcData) > 0 {
			var dummy any
			if err := json.Unmarshal(tcData, &dummy); err != nil {
				report.Violations = append(report.Violations, "artifacts/test_cases.json 不是合法的 JSON 格式")
				report.Score -= 10.0
				report.Passed = false
			}
		}
	}

	if report.Score < 0 {
		report.Score = 0
	}
	if report.Score < 80.0 {
		report.Passed = false
	}

	return report, nil
}

// sanitizeViolationForAgent 修复指令中不得原样回写禁用套话，避免二次自污染。
func sanitizeViolationForAgent(v string) string {
	out := v
	for _, phrase := range ProhibitedPhrases {
		if phrase != "" && strings.Contains(out, phrase) {
			out = strings.ReplaceAll(out, phrase, "「省略/敷衍写法」")
		}
	}
	return out
}

// containsProhibitedUsage 仅当禁词被用作正文省略/敷衍时命中。
// 否定性自检、写作禁令复述（如：无"…"等敷衍套话）不得误报。
func containsProhibitedUsage(content, phrase string) bool {
	if phrase == "" || content == "" {
		return false
	}
	searchFrom := 0
	for {
		rel := strings.Index(content[searchFrom:], phrase)
		if rel < 0 {
			return false
		}
		abs := searchFrom + rel
		if isNegatedOrMetaProhibitedCitation(content, abs, phrase) ||
			isActionPlanStatusCell(content, abs, phrase) {
			searchFrom = abs + len(phrase)
			continue
		}
		return true
	}
}

func isNegatedOrMetaProhibitedCitation(content string, idx int, phrase string) bool {
	lineStart := strings.LastIndex(content[:idx], "\n") + 1
	lineEnd := strings.Index(content[idx:], "\n")
	if lineEnd < 0 {
		lineEnd = len(content)
	} else {
		lineEnd = idx + lineEnd
	}
	line := content[lineStart:lineEnd]
	localIdx := idx - lineStart
	if localIdx < 0 || localIdx > len(line) {
		return false
	}

	// 仅同一自检/规则行，且须同时具备元标注 + 否定词紧邻或引号引用结构。
	// 禁止用「48 字窗口出现 无」豁免：正文「此处无更多数据，不做展开」必须仍命中。
	if !lineHasProhibitedMetaMarker(line) {
		return false
	}
	return phraseQuotedOnLine(line, phrase) || negationAdjacentToPhrase(line, localIdx)
}

func lineHasProhibitedMetaMarker(line string) bool {
	metaMarkers := []string{
		"写作禁令", "敷衍套话", "省略套话", "省略敷衍", "禁止使用", "严禁写",
		"负向红线", "审核结论", "遵守情况", "交付契约", "写作纪律", "验收标准",
	}
	for _, m := range metaMarkers {
		if strings.Contains(line, m) {
			return true
		}
	}
	return false
}

func phraseQuotedOnLine(line, phrase string) bool {
	if phrase == "" {
		return false
	}
	wrappers := [][2]string{
		{`"`, `"`},
		{"「", "」"},
		{`'`, `'`},
		{"“", "”"},
		{"‘", "’"},
	}
	for _, w := range wrappers {
		if strings.Contains(line, w[0]+phrase+w[1]) {
			return true
		}
	}
	return false
}

var (
	actionPlanStatusHeaders  = []string{"阶段", "状态", "进度"}
	actionPlanActionHeaders  = []string{"行动项", "行动", "动作", "后续动作", "后续行动", "工作内容"}
	actionPlanOwnerHeaders   = []string{"负责方", "责任人", "负责人"}
	actionPlanTriggerHeaders = []string{"触发条件", "触发", "完成条件", "前置条件"}
)

// isActionPlanStatusCell 仅豁免行动计划/后续动作表中「阶段/状态/进度」列的独立单元格「待续」。
// 命中列必须与表头状态列索引一致；动作/负责/触发按表头取值。不得凭同行任意列或邻近词放宽。
// 只接受同一连续表格：表头后须紧跟合法 separator，且数据行列数与表头相等。
func isActionPlanStatusCell(content string, idx int, phrase string) bool {
	if phrase != "待续" || idx < 0 || idx >= len(content) {
		return false
	}
	lineStart := strings.LastIndex(content[:idx], "\n") + 1
	lineEnd := strings.Index(content[idx:], "\n")
	if lineEnd < 0 {
		lineEnd = len(content)
	} else {
		lineEnd = idx + lineEnd
	}
	line := content[lineStart:lineEnd]
	cells := markdownTableCells(line)
	if len(cells) < 4 || isMarkdownTableSeparator(cells) {
		return false
	}
	header := findPrecedingTableHeader(content, lineStart)
	if len(header) == 0 || len(cells) != len(header) {
		return false
	}
	cols, ok := parseActionPlanColumns(header)
	if !ok {
		return false
	}
	cell, hitIdx, ok := tableCellAt(line, idx-lineStart)
	if !ok || hitIdx != cols.status || stripMarkdownEmphasis(cell) != "待续" {
		return false
	}
	if cols.action >= len(cells) || cols.owner >= len(cells) || cols.trigger >= len(cells) || cols.status >= len(cells) {
		return false
	}
	if strings.TrimSpace(stripMarkdownEmphasis(cells[cols.owner])) == "" ||
		strings.TrimSpace(stripMarkdownEmphasis(cells[cols.trigger])) == "" {
		return false
	}
	return hasSubstantialActionText(stripMarkdownEmphasis(cells[cols.action]))
}

func markdownTableCells(line string) []string {
	trimmed := strings.TrimSpace(line)
	if !strings.HasPrefix(trimmed, "|") {
		return nil
	}
	parts := strings.Split(trimmed, "|")
	if len(parts) > 0 && parts[0] == "" {
		parts = parts[1:]
	}
	if len(parts) > 0 && strings.TrimSpace(parts[len(parts)-1]) == "" {
		parts = parts[:len(parts)-1]
	}
	if len(parts) == 0 {
		return nil
	}
	return parts
}

func tableCellAt(line string, localIdx int) (string, int, bool) {
	if localIdx < 0 || localIdx >= len(line) {
		return "", -1, false
	}
	var pipes []int
	for i := 0; i < len(line); i++ {
		if line[i] == '|' {
			pipes = append(pipes, i)
		}
	}
	if len(pipes) < 2 {
		return "", -1, false
	}
	for i := 0; i < len(pipes)-1; i++ {
		start, end := pipes[i], pipes[i+1]
		if localIdx > start && localIdx < end {
			return line[start+1 : end], i, true
		}
	}
	return "", -1, false
}

func isMarkdownTableSeparator(cells []string) bool {
	if len(cells) == 0 {
		return false
	}
	for _, c := range cells {
		s := strings.Trim(strings.TrimSpace(c), ":")
		s = strings.TrimSpace(s)
		if s == "" || strings.Trim(s, "-") != "" {
			return false
		}
	}
	return true
}

func stripMarkdownEmphasis(s string) string {
	s = strings.TrimSpace(s)
	s = strings.ReplaceAll(s, "**", "")
	s = strings.ReplaceAll(s, "__", "")
	s = strings.TrimSpace(s)
	if len(s) >= 2 && strings.HasPrefix(s, "*") && strings.HasSuffix(s, "*") {
		s = strings.TrimSpace(s[1 : len(s)-1])
	}
	return strings.TrimSpace(s)
}

func hasSubstantialActionText(s string) bool {
	s = strings.TrimSpace(s)
	if s == "" || strings.Contains(s, "待续") {
		return false
	}
	if utf8.RuneCountInString(s) < 12 {
		return false
	}
	letters := 0
	for _, r := range s {
		if unicode.Is(unicode.Han, r) || unicode.IsLetter(r) {
			letters++
		}
	}
	return letters >= 10
}

func findPrecedingTableHeader(content string, lineStart int) []string {
	var above []string
	prevEnd := lineStart - 1
	for prevEnd >= 0 {
		prevStart := 0
		if prevEnd > 0 {
			if i := strings.LastIndex(content[:prevEnd], "\n"); i >= 0 {
				prevStart = i + 1
			}
		}
		line := strings.TrimSpace(content[prevStart:prevEnd])
		if line == "" {
			break
		}
		cells := markdownTableCells(line)
		if cells == nil {
			break
		}
		above = append(above, line)
		prevEnd = prevStart - 1
	}
	if len(above) < 2 {
		return nil
	}
	header := markdownTableCells(above[len(above)-1])
	sep := markdownTableCells(above[len(above)-2])
	if len(header) == 0 || isMarkdownTableSeparator(header) {
		return nil
	}
	if !isMarkdownTableSeparator(sep) || len(sep) != len(header) {
		return nil
	}
	return header
}

type actionPlanColumns struct {
	status  int
	action  int
	owner   int
	trigger int
}

func headerColumnIndex(header []string, names []string) int {
	want := make(map[string]struct{}, len(names))
	for _, n := range names {
		want[n] = struct{}{}
	}
	for i, c := range header {
		if _, ok := want[stripMarkdownEmphasis(c)]; ok {
			return i
		}
	}
	return -1
}

func parseActionPlanColumns(header []string) (actionPlanColumns, bool) {
	cols := actionPlanColumns{
		status:  headerColumnIndex(header, actionPlanStatusHeaders),
		action:  headerColumnIndex(header, actionPlanActionHeaders),
		owner:   headerColumnIndex(header, actionPlanOwnerHeaders),
		trigger: headerColumnIndex(header, actionPlanTriggerHeaders),
	}
	if cols.status < 0 || cols.action < 0 || cols.owner < 0 || cols.trigger < 0 {
		return actionPlanColumns{}, false
	}
	seen := map[int]struct{}{cols.status: {}, cols.action: {}, cols.owner: {}, cols.trigger: {}}
	if len(seen) != 4 {
		return actionPlanColumns{}, false
	}
	return cols, true
}

func isActionPlanTableHeader(cells []string) bool {
	_, ok := parseActionPlanColumns(cells)
	return ok
}

func negationAdjacentToPhrase(line string, phraseIdx int) bool {
	if phraseIdx <= 0 || phraseIdx > len(line) {
		return false
	}
	prefix := strings.TrimRight(line[:phraseIdx], " \t\"'「“‘")
	negMarkers := []string{"无", "禁止", "严禁", "不得", "勿", "杜绝", "没有", "不含", "未使用", "不出现", "不应出现"}
	for _, n := range negMarkers {
		if strings.HasSuffix(prefix, n) {
			return true
		}
	}
	return false
}

// GenerateManifest 扫描工作区核心文件生成 SHA-256 指纹与防篡改审计清单
func (q *QualityGate) GenerateManifest(wsDir string, docKey string, report QualityReport) (*Manifest, error) {
	now := time.Now()
	files := make(map[string]string)

	trackedPaths := []string{
		"workspace.json",
		"squad.json",
		"workflow.json",
		"template.md",
		"blackboard.json",
		"output.md",
		filepath.Join("context", "index.json"),
		filepath.Join("context", "user.md"),
		filepath.Join("context", "project.md"),
		filepath.Join("context", "agent.md"),
	}

	for _, rel := range trackedPaths {
		p := filepath.Join(wsDir, rel)
		if hash, err := computeSHA256(p); err == nil {
			files[filepath.ToSlash(rel)] = hash
		}
	}

	// 扫描 artifacts/
	artDir := filepath.Join(wsDir, "artifacts")
	if entries, err := os.ReadDir(artDir); err == nil {
		for _, e := range entries {
			if !e.IsDir() {
				rel := filepath.Join("artifacts", e.Name())
				p := filepath.Join(wsDir, rel)
				if hash, err := computeSHA256(p); err == nil {
					files[filepath.ToSlash(rel)] = hash
				}
			}
		}
	}

	// 扫描 tasks/*/output.md
	tasksDir := filepath.Join(wsDir, "tasks")
	if entries, err := os.ReadDir(tasksDir); err == nil {
		for _, e := range entries {
			if e.IsDir() {
				outPath := filepath.Join(tasksDir, e.Name(), "output.md")
				if hash, err := computeSHA256(outPath); err == nil {
					rel := filepath.Join("tasks", e.Name(), "output.md")
					files[filepath.ToSlash(rel)] = hash
				}
			}
		}
	}

	manifest := &Manifest{
		ManifestVersion: "1.0.0",
		WorkspaceID:     filepath.Base(wsDir),
		DocKey:          docKey,
		GeneratedAt:     now,
		Deliverable:     filepath.Join(wsDir, "output.md"),
		Files:           files,
		QualityReport:   report,
	}

	manifestPath := filepath.Join(wsDir, "manifest.json")
	if err := writeJSON(manifestPath, manifest); err != nil {
		return nil, fmt.Errorf("write manifest.json: %w", err)
	}

	return manifest, nil
}

// EnsureQualityOrRepair 质量门禁自动闭环：若质检未通过，动态向工作流追加修复步骤直到达标或达到重试上限。
// 提升根 output.md 的唯一条件：runErr==nil、无受保护父级越界、本地目标可信。
func (q *QualityGate) EnsureQualityOrRepair(
	ctx context.Context,
	wsDir string,
	taskKey string,
	driver *WorkflowDriver,
	backend agent.Backend,
	maxRetries int,
	opts ExecuteOptions,
) (*QualityReport, error) {
	outPath := filepath.Join(wsDir, "output.md")
	contentBytes, err := os.ReadFile(outPath)
	if err != nil {
		return nil, fmt.Errorf("read output.md: %w", err)
	}

	report, err := q.Validate(wsDir, taskKey, string(contentBytes))
	if err != nil {
		return nil, err
	}

	if report.Passed || maxRetries <= 0 {
		_, _ = q.GenerateManifest(wsDir, taskKey, *report)
		return report, nil
	}

	// 治理：加载预算账本（修复轮预算预扣 + 跨轮停滞检测）
	ledger := LoadOrCreateLedger(wsDir, DefaultBudgetPolicy())
	prevRepairContent := string(contentBytes)
	stallHinted := false
	stallBreak := false

	for attempt := 1; attempt <= maxRetries; attempt++ {
		// 治理：修复轮预算预扣（超限硬停，杜绝机械空转烧成本）
		if lErr := ledger.ReserveRepair(); lErr != nil {
			_ = ledger.Save(wsDir)
			if st := stream.FromContext(ctx); st != nil {
				st.EmitPhase("governance", "修复预算硬停: "+lErr.Error(), "taskgov", 0, 0, 0)
			}
			break
		}

		repairStepID := fmt.Sprintf("step_repair_%d", attempt)
		subDir := fmt.Sprintf("tasks/repair_%d", attempt)

		var acceptCriteria []string
		if len(report.MissingSections) > 0 {
			acceptCriteria = append(acceptCriteria, "补齐缺失章节: "+strings.Join(report.MissingSections, ", "))
		}
		if len(report.ProhibitedPhrases) > 0 {
			acceptCriteria = append(acceptCriteria, "清除正文中实际使用的省略/敷衍写法；自检表勿复述禁用原词")
		}
		for _, v := range report.Violations {
			acceptCriteria = append(acceptCriteria, "解决违规点: "+v)
		}

		repairStep := StepSpec{
			ID:           repairStepID,
			Role:         "writer",
			Title:        fmt.Sprintf("根据质量门禁反馈修复交付初稿 (第%d次修正)", attempt),
			SubWorkspace: subDir,
			Mode:         "execute",
			Needs:        []string{"output.md"},
			InputLayout:  InputLayoutSnapshot,
			Accept:       acceptCriteria,
		}

		parentSnap := SnapshotWorkspaceInputs(wsDir)

		if err := driver.AddStep(wsDir, repairStep); err != nil {
			return report, fmt.Errorf("add repair step: %w", err)
		}

		repairAbs := filepath.Join(wsDir, filepath.FromSlash(subDir))
		if err := WriteRepairTaskMarkdown(repairAbs, attempt, report, stallHinted); err != nil {
			return report, fmt.Errorf("write repair TASK.md: %w", err)
		}

		// 执行修复步骤（治理入账：轨迹 + 预算）
		runErr := driver.runOneStep(ctx, wsDir, repairStep, backend, opts.Timeout, opts.StepNotify, nil, &[]string{}, ledger)

		repairedBytes, localOK := TrustedLocalDeliverable(repairAbs, RepairTargetName)
		mutated := ParentInputsMutated(wsDir, parentSnap)
		if len(mutated) > 0 {
			recordContainmentViolation(wsDir, attempt, mutated, localOK, parentSnap)
			if rerr := restoreWorkspaceInputsFn(wsDir, parentSnap); rerr != nil {
				appendGovAudit(wsDir, GovAuditRestoreFailure, map[string]string{
					"attempt": fmt.Sprintf("%d", attempt),
					"error":   rerr.Error(),
					"mutated": strings.Join(mutated, ","),
				})
				if st := stream.FromContext(ctx); st != nil {
					st.EmitPhase("governance", "修复 containment 恢复失败: "+rerr.Error(), "taskgov", 0, 0, 0)
				}
				return report, fmt.Errorf("restore parent inputs after containment: %w", rerr)
			}
			if st := stream.FromContext(ctx); st != nil {
				st.EmitPhase("governance", "修复 containment 违规: 父级输入已被越界改写，已恢复运行前字节，本轮作废", "taskgov", 0, 0, 0)
			}
		}

		promote, reason := DecideRepairPromote(runErr, mutated, localOK)
		if !promote {
			detail := map[string]string{"attempt": fmt.Sprintf("%d", attempt), "reason": reason}
			if runErr != nil {
				detail["error"] = runErr.Error()
			}
			appendGovAudit(wsDir, "repair_round_discarded", detail)
			continue
		}

		// 仅 runErr==nil、无 containment、本地目标可信时才覆盖根 output.md 并 Validate。
		sim := OutputSimilarity(prevRepairContent, string(repairedBytes))
		if sim >= 0.98 {
			if stallHinted {
				if st := stream.FromContext(ctx); st != nil {
					st.EmitPhase("governance", fmt.Sprintf("修复停滞止损: 连续两轮修复产物相似度 %.1f%%，终止机械重试", sim*100), "taskgov", 0, 0, 0)
				}
				appendGovAudit(wsDir, "repair_stall_break", map[string]string{"attempt": fmt.Sprintf("%d", attempt), "similarity": fmt.Sprintf("%.3f", sim)})
				stallBreak = true
			} else {
				stallHinted = true
				appendGovAudit(wsDir, "repair_stall_hinted", map[string]string{"attempt": fmt.Sprintf("%d", attempt), "similarity": fmt.Sprintf("%.3f", sim)})
			}
		}
		prevRepairContent = string(repairedBytes)
		if err := writeRegularFile(outPath, repairedBytes); err != nil {
			return report, fmt.Errorf("promote repair output: %w", err)
		}
		report, _ = q.Validate(wsDir, taskKey, string(repairedBytes))
		if report.Passed || stallBreak {
			break
		}
	}
	_ = ledger.Save(wsDir)

	_, _ = q.GenerateManifest(wsDir, taskKey, *report)
	return report, nil
}

func extractHeadings(md string) []string {
	var headings []string
	lines := strings.Split(md, "\n")
	for _, line := range lines {
		trimmed := strings.TrimSpace(line)
		if strings.HasPrefix(trimmed, "## ") {
			raw := strings.TrimPrefix(trimmed, "## ")
			clean := cleanHeadingTitle(raw)
			if clean != "" {
				headings = append(headings, clean)
			}
		}
	}
	return headings
}

func cleanHeadingTitle(title string) string {
	// 去除前缀序号如 "一、", "二、", "1.", "1.1", "（一）" 等
	t := strings.TrimSpace(title)
	runes := []rune(t)
	// 去掉中文序号如 "一、", "二、", "三、", "四、", "五、", "六、", "七、", "八、", "九、", "十、"
	chineseNums := []string{"一、", "二、", "三、", "四、", "五、", "六、", "七、", "八、", "九、", "十、"}
	for _, cn := range chineseNums {
		if strings.HasPrefix(t, cn) {
			t = strings.TrimPrefix(t, cn)
			break
		}
	}
	// 去掉数字序号如 "1. ", "1、"
	for len(runes) > 0 && ((runes[0] >= '0' && runes[0] <= '9') || runes[0] == '.' || runes[0] == '、' || runes[0] == ' ') {
		t = strings.TrimSpace(string(runes[1:]))
		runes = []rune(t)
	}
	// 去除可能括号后缀
	if idx := strings.Index(t, "（"); idx > 0 {
		t = strings.TrimSpace(t[:idx])
	}
	if idx := strings.Index(t, "("); idx > 0 {
		t = strings.TrimSpace(t[:idx])
	}
	return strings.TrimSpace(t)
}

func computeSHA256(filePath string) (string, error) {
	f, err := os.Open(filePath)
	if err != nil {
		return "", err
	}
	defer f.Close()

	h := sha256.New()
	if _, err := io.Copy(h, f); err != nil {
		return "", err
	}
	return hex.EncodeToString(h.Sum(nil)), nil
}