package main

import (
	"encoding/json"
	"fmt"
	"os"
	"sort"
	"strings"

	"git.iwork-ai.com/xdc/iqudo-top1/internal/scriptkit"
	"github.com/xuri/excelize/v2"
)

// Data sources for the script package.
const petScriptSource = "症状-疾病-话术.json"
const petQuestionSource = "症状确认话术.json"
const petSmallCategorySource = "症状小类-大类.json"
const petSmallAskScriptSource = "症状小类询问话术.json"
const petPreGuideSource = "症状确认前引导话术.json"
const petClassificationSource = "症状分类.json"
const petKnowledgeSource = "症状-疾病-方案.xlsx"

type petScriptEntry struct {
	Title    string `json:"title"`
	Template string `json:"template"`
}

type petClassification struct {
	Symptoms []struct {
		Type string   `json:"type"`
		Subs []string `json:"subs"`
	} `json:"symptoms"`
	Diagnosis []struct {
		Type string `json:"type"`
		Subs []struct {
			SubType string `json:"subType"`
		} `json:"subs"`
	} `json:"diagnosis"`
}

type petCombination struct {
	Name     string `json:"name"`
	Weight   int    `json:"weight"`
	Products []struct {
		SKUCode     string `json:"sku_code"`
		ProductName string `json:"product_name"`
	} `json:"products"`
	Script string `json:"script"`
}

type petScriptDisease struct {
	Combinations []petCombination `json:"combinations"`
}

type petKnowledgeRow struct {
	Symptom     string
	Disease     string
	SKUCode     string
	ProductName string
}

// petQuestionBank is the customer-facing copy bank for the script package.
// Every question lives in the JSON data file, not in Go code.
type petQuestionBank struct {
	OpeningGreeting          string `json:"opening_greeting"`
	DiagnosisFallback        string `json:"diagnosis_fallback"`
	RecommendFallback        string `json:"recommend_fallback"`
	SymptomScreeningTemplate string `json:"symptom_screening_template"`
	SymptomConfirmOptions    struct {
		Yes string `json:"yes"`
		No  string `json:"no"`
	} `json:"symptom_confirm_options"`
	DiseaseConfirmOptions struct {
		Yes string `json:"yes"`
		No  string `json:"no"`
	} `json:"disease_confirm_options"`
	Symptoms map[string]petSymptomQuestions `json:"symptoms"`

	DiseaseConfirmTemplate       string                      `json:"disease_confirm_template"`
	DiseaseConfirmedCopyTemplate string                      `json:"disease_confirmed_copy_template"`
	DiseasePlanIntro             string                      `json:"disease_plan_intro"`
	DiseaseCareNote              string                      `json:"disease_care_note"`
	Diseases                     map[string]petDiseasePhrase `json:"diseases"`
}

type petSymptomQuestions struct {
	Confirm string              `json:"confirm"`
	Short   string              `json:"short"`
	Choices []petChoiceQuestion `json:"choices"`
}

type petChoiceQuestion struct {
	Title    string            `json:"title"`
	Question string            `json:"question"`
	Multiple bool              `json:"multiple"`
	Options  []petChoiceOption `json:"options"`
}

type petChoiceOption struct {
	Key   string `json:"key"`
	Label string `json:"label"`
}

type petDiseasePhrase struct {
	Phrase string `json:"phrase"`
}

// scriptKeyGenerator produces stable ASCII keys for dimension values and
// scripts. Chinese display names live in the Name field.
type scriptKeyGenerator struct {
	counters map[string]int
}

func (g *scriptKeyGenerator) key(prefix string) string {
	g.counters[prefix]++
	return fmt.Sprintf("%s_%03d", prefix, g.counters[prefix])
}

// buildScriptPackage builds the 问诊问药 script package from the docs files.
func buildScriptPackage(scriptFile, knowledgeFile, smallCategoryFile, smallAskScriptFile, preGuideFile, classificationFile, questionFile string) (scriptkit.PackageInput, error) {
	bank, err := readQuestionBank(questionFile)
	if err != nil {
		return scriptkit.PackageInput{}, err
	}
	classification, err := readClassification(classificationFile)
	if err != nil {
		return scriptkit.PackageInput{}, err
	}
	smallToBig, err := readStringMap(smallCategoryFile)
	if err != nil {
		return scriptkit.PackageInput{}, err
	}
	smallAsk, err := readPetScriptMap(smallAskScriptFile)
	if err != nil {
		return scriptkit.PackageInput{}, err
	}
	preGuide, err := readPreGuide(preGuideFile)
	if err != nil {
		return scriptkit.PackageInput{}, err
	}
	combinations, combinationSymptoms, err := readCombinations(scriptFile)
	if err != nil {
		return scriptkit.PackageInput{}, err
	}
	rows, err := readPetKnowledge(knowledgeFile)
	if err != nil {
		return scriptkit.PackageInput{}, err
	}

	keys := &scriptKeyGenerator{counters: map[string]int{}}
	input := scriptkit.PackageInput{
		Name:          "宠物问诊问药话术包",
		StartStageKey: "opening",
		Dimensions:    []scriptkit.DimensionInput{},
		Stages:        []scriptkit.StageInput{},
		Linkages:      []scriptkit.LinkageInput{},
		Adapters:      []scriptkit.AdapterInput{},
	}

	// 症状大类来自小类映射、诊断分组、组合话术和 SKU 表的并集。
	bigSet := map[string]bool{}
	for _, big := range smallToBig {
		if big != "" {
			bigSet[big] = true
		}
	}
	for _, diagnosis := range classification.Diagnosis {
		if diagnosis.Type != "" {
			bigSet[diagnosis.Type] = true
		}
	}
	for big := range combinationSymptoms {
		bigSet[big] = true
	}
	for _, row := range rows {
		if row.Symptom != "" {
			bigSet[row.Symptom] = true
		}
	}
	bigNames := make([]string, 0, len(bigSet))
	for name := range bigSet {
		bigNames = append(bigNames, name)
	}
	sort.Strings(bigNames)
	bigKey := map[string]string{}
	bigDimension := scriptkit.DimensionInput{DimKey: "symptom", Name: "症状", SortOrder: 1, Values: []scriptkit.ValueInput{}}
	for _, name := range bigNames {
		key := keys.key("symptom")
		bigKey[name] = key
		bigDimension.Values = append(bigDimension.Values, scriptkit.ValueInput{ValueKey: key, Name: name, InitialWeight: 0, SortOrder: len(bigDimension.Values)})
	}
	input.Dimensions = append(input.Dimensions, bigDimension)

	subSet := map[string]bool{}
	for sub := range smallToBig {
		if sub != "" {
			subSet[sub] = true
		}
	}
	for _, symptom := range classification.Symptoms {
		for _, sub := range symptom.Subs {
			if sub != "" {
				subSet[sub] = true
			}
		}
	}
	subNames := make([]string, 0, len(subSet))
	for name := range subSet {
		subNames = append(subNames, name)
	}
	sort.Strings(subNames)
	subKey := map[string]string{}
	subDimension := scriptkit.DimensionInput{DimKey: "symptom_sub", Name: "症状小类", SortOrder: 2, Values: []scriptkit.ValueInput{}}
	for _, name := range subNames {
		key := keys.key("symptom_sub")
		subKey[name] = key
		subDimension.Values = append(subDimension.Values, scriptkit.ValueInput{ValueKey: key, Name: name, InitialWeight: 0, SortOrder: len(subDimension.Values)})
	}
	input.Dimensions = append(input.Dimensions, subDimension)

	diseaseNames := make([]string, 0)
	diseaseKey := map[string]string{}
	for _, diagnosis := range classification.Diagnosis {
		for _, sub := range diagnosis.Subs {
			if sub.SubType == "" {
				continue
			}
			diseaseNames = append(diseaseNames, sub.SubType)
		}
	}
	sort.Strings(diseaseNames)
	diseaseDimension := scriptkit.DimensionInput{DimKey: "disease", Name: "疾病分型", SortOrder: 3, Values: []scriptkit.ValueInput{}}
	for _, name := range diseaseNames {
		key := keys.key("disease")
		diseaseKey[name] = key
		diseaseDimension.Values = append(diseaseDimension.Values, scriptkit.ValueInput{ValueKey: key, Name: name, InitialWeight: 0, SortOrder: len(diseaseDimension.Values)})
	}
	input.Dimensions = append(input.Dimensions, diseaseDimension)

	// 每个症状都必须配置确认题和选择题；每个疾病都必须配置口语化说法。
	var missingSymptoms, missingDiseases []string
	for _, name := range bigNames {
		questions, ok := bank.Symptoms[name]
		if !ok || strings.TrimSpace(questions.Confirm) == "" || len(questions.Choices) == 0 {
			missingSymptoms = append(missingSymptoms, name)
		}
	}
	for _, name := range diseaseNames {
		if _, ok := bank.Diseases[name]; !ok {
			missingDiseases = append(missingDiseases, name)
		}
	}
	if len(missingSymptoms) > 0 {
		return scriptkit.PackageInput{}, fmt.Errorf("话术库 %s 缺少症状确认题/选择题: %v", questionFile, missingSymptoms)
	}
	if len(missingDiseases) > 0 {
		return scriptkit.PackageInput{}, fmt.Errorf("话术库 %s 缺少疾病口语化说法: %v", questionFile, missingDiseases)
	}

	// Linkages: 小类 -> 大类, 大类 -> 疾病. 激活阈值 5：只有已确认的症状
	// （权重达到 5 以上）才会把疾病带入拟诊阶段；模糊提示（权重 3）只触发
	// 症状确认题，不会直接带出疾病。
	linkages := make([]scriptkit.LinkageInput, 0)
	for sub, big := range smallToBig {
		if subKey[sub] == "" || bigKey[big] == "" {
			continue
		}
		linkages = append(linkages, scriptkit.LinkageInput{FromDimensionValueKey: subKey[sub], ToDimensionValueKey: bigKey[big], RelationType: "contributes_to", Contribution: 8, ActivationThreshold: 5, SortOrder: len(linkages)})
	}
	for _, diagnosis := range classification.Diagnosis {
		for _, sub := range diagnosis.Subs {
			if bigKey[diagnosis.Type] == "" || diseaseKey[sub.SubType] == "" {
				continue
			}
			linkages = append(linkages, scriptkit.LinkageInput{FromDimensionValueKey: bigKey[diagnosis.Type], ToDimensionValueKey: diseaseKey[sub.SubType], RelationType: "contributes_to", Contribution: 5, ActivationThreshold: 5, SortOrder: len(linkages)})
		}
	}
	sort.SliceStable(linkages, func(i, j int) bool { return linkages[i].SortOrder < linkages[j].SortOrder })
	input.Linkages = linkages

	// Adapters: symptom tags and order SKUs initialize symptom weights.
	// SKU 只提示相关症状（权重 3，触发症状确认题），不会直接命中疾病——
	// 疾病必须由已确认的症状联动带出。
	adapters := make([]scriptkit.AdapterInput, 0)
	for _, name := range bigNames {
		adapters = append(adapters, scriptkit.AdapterInput{SourceField: "input.input_symptom_tags", MatchValue: name, TargetDimensionValueKey: bigKey[name], Weight: 8, SortOrder: len(adapters)})
	}
	for _, name := range subNames {
		adapters = append(adapters, scriptkit.AdapterInput{SourceField: "input.input_symptom_tags", MatchValue: name, TargetDimensionValueKey: subKey[name], Weight: 8, SortOrder: len(adapters)})
	}
	for _, row := range rows {
		if strings.TrimSpace(row.SKUCode) == "" {
			continue
		}
		if bigKey[row.Symptom] != "" {
			adapters = append(adapters, scriptkit.AdapterInput{SourceField: "derived.matched_skus", MatchValue: row.SKUCode, TargetDimensionValueKey: bigKey[row.Symptom], Weight: 3, SortOrder: len(adapters)})
		}
	}
	sort.SliceStable(adapters, func(i, j int) bool { return adapters[i].SortOrder < adapters[j].SortOrder })
	input.Adapters = adapters

	// Stage 1: 开场. 开场只做问候和宠物档案补充，不显示任何维度（症状只在症状节点显示）。
	opening := scriptkit.StageInput{
		StageKey: "opening", Name: "开场", Purpose: "确认顾客与宠物信息，并补充宠物档案", PrimaryDimensionKey: "", SortOrder: 1, Scripts: []scriptkit.ScriptInput{
			{ScriptKey: "opening_greeting", Name: "开场话术", ScriptType: "template", Content: bank.OpeningGreeting, SortOrder: 10},
		},
	}
	input.Stages = append(input.Stages, opening)

	// Stage 2: 症状确认。候选症状超过 3 个时先做一道多选筛选题，
	// 筛完再对选中的症状按由浅入深的顺序做选择题。
	symptomStage := scriptkit.StageInput{StageKey: "symptom", Name: "症状确认", Purpose: "确认宠物当前的主要症状", PrimaryDimensionKey: "symptom", SortOrder: 2, Scripts: []scriptkit.ScriptInput{}}
	for index, guide := range preGuide {
		symptomStage.Scripts = append(symptomStage.Scripts, scriptkit.ScriptInput{ScriptKey: keys.key("symptom_guide"), Name: "引导话术" + guide.Title, ScriptType: "fallback", Content: guide.Template, SortOrder: 100 + index})
	}
	screenOptions := make([]scriptkit.OptionInput, 0, len(bigNames))
	for _, name := range bigNames {
		short := bank.Symptoms[name].Short
		if short == "" {
			short = name
		}
		screenOptions = append(screenOptions, scriptkit.OptionInput{OptionKey: bigKey[name], Label: short, TargetDimensionValueKey: bigKey[name], Effect: "set", EffectValue: 10, SortOrder: len(screenOptions) + 1})
	}
	symptomStage.Scripts = append(symptomStage.Scripts, scriptkit.ScriptInput{
		ScriptKey: keys.key("symptom_screen"), Name: "症状筛选", ScriptType: "screen",
		Content: bank.SymptomScreeningTemplate, Multiple: true,
		SortOrder: 50, Options: screenOptions,
	})
	for _, name := range bigNames {
		questions := bank.Symptoms[name]
		confirm := scriptkit.ScriptInput{
			ScriptKey: keys.key("symptom_confirm"), Name: "确认" + name + "症状", ScriptType: "confirm",
			Content:           questions.Confirm,
			DimensionValueKey: bigKey[name], ConfirmThreshold: 3, ShowThreshold: 5, SortOrder: 1000,
			Options: []scriptkit.OptionInput{
				{OptionKey: "yes", Label: bank.SymptomConfirmOptions.Yes, TargetDimensionValueKey: bigKey[name], Effect: "set", EffectValue: 8, SortOrder: 1},
				{OptionKey: "no", Label: bank.SymptomConfirmOptions.No, TargetDimensionValueKey: bigKey[name], Effect: "zero", EffectValue: 0, SortOrder: 2},
			},
		}
		symptomStage.Scripts = append(symptomStage.Scripts, confirm)
		for choiceIndex, choice := range questions.Choices {
			options := make([]scriptkit.OptionInput, 0, len(choice.Options))
			for optionIndex, option := range choice.Options {
				options = append(options, scriptkit.OptionInput{OptionKey: option.Key, Label: option.Label, Effect: "set", EffectValue: 0, SortOrder: optionIndex + 1})
			}
			scriptKey := keys.key("symptom_choice")
			symptomStage.Scripts = append(symptomStage.Scripts, scriptkit.ScriptInput{
				ScriptKey: scriptKey, Name: name + choice.Title, ScriptType: "choice",
				Content: choice.Question, DimensionValueKey: bigKey[name],
				ConfirmThreshold: 3, ShowThreshold: 5, CollectFieldKey: scriptKey,
				Multiple:  choice.Multiple,
				SortOrder: 1100 + choiceIndex, Options: options,
			})
		}
	}
	for _, name := range subNames {
		for index, ask := range smallAsk[name] {
			symptomStage.Scripts = append(symptomStage.Scripts, scriptkit.ScriptInput{ScriptKey: keys.key("symptom_sub_ask"), Name: name + ask.Title, ScriptType: "info", Content: ask.Template, DimensionValueKey: subKey[name], ConfirmThreshold: 3, ShowThreshold: 5, SortOrder: 5000 + index})
		}
	}
	input.Stages = append(input.Stages, symptomStage)

	// Stage 3: 拟诊确认. 候选疾病（由已确认症状带出，权重5）先显示确认题；
	// 客户确认后（权重10）才显示该疾病的确认话术，可同时确认多个疾病。
	diagnosisStage := scriptkit.StageInput{StageKey: "diagnosis", Name: "拟诊确认", Purpose: "结合症状确认可能的疾病方向（可确认多个），确认后再进入推荐", PrimaryDimensionKey: "disease", SortOrder: 3, Scripts: []scriptkit.ScriptInput{
		{ScriptKey: "diagnosis_fallback", Name: "拟诊兜底话术", ScriptType: "fallback", Content: bank.DiagnosisFallback, SortOrder: 100},
	}}
	for _, name := range diseaseNames {
		phrase := bank.Diseases[name].Phrase
		confirm := scriptkit.ScriptInput{
			ScriptKey: keys.key("disease_confirm"), Name: "确认" + name + "方向", ScriptType: "confirm",
			Content:           strings.ReplaceAll(bank.DiseaseConfirmTemplate, "{{disease_phrase}}", phrase),
			DimensionValueKey: diseaseKey[name], ConfirmThreshold: 5, ShowThreshold: 10, SortOrder: 1000,
			Options: []scriptkit.OptionInput{
				{OptionKey: "yes", Label: bank.DiseaseConfirmOptions.Yes, TargetDimensionValueKey: diseaseKey[name], Effect: "set", EffectValue: 10, SortOrder: 1},
				{OptionKey: "no", Label: bank.DiseaseConfirmOptions.No, TargetDimensionValueKey: diseaseKey[name], Effect: "zero", EffectValue: 0, SortOrder: 2},
			},
		}
		diagnosisStage.Scripts = append(diagnosisStage.Scripts, confirm)
		diagnosisStage.Scripts = append(diagnosisStage.Scripts, scriptkit.ScriptInput{
			ScriptKey: keys.key("disease_copy"), Name: name + "疾病确认话术", ScriptType: "message",
			Content:           strings.ReplaceAll(bank.DiseaseConfirmedCopyTemplate, "{{disease_phrase}}", phrase),
			DimensionValueKey: diseaseKey[name], ConfirmThreshold: 5, ShowThreshold: 10, SortOrder: 1100,
		})
		diagnosisStage.Scripts = append(diagnosisStage.Scripts, scriptkit.ScriptInput{
			ScriptKey: keys.key("disease_copy"), Name: name + "方案引入话术", ScriptType: "message",
			Content:           bank.DiseasePlanIntro,
			DimensionValueKey: diseaseKey[name], ConfirmThreshold: 5, ShowThreshold: 10, SortOrder: 1101,
		})
	}
	input.Stages = append(input.Stages, diagnosisStage)

	// Stage 4: 药品推荐与注意事项. 只有客户确认过的疾病（权重10）才会推荐。
	recommendStage := scriptkit.StageInput{StageKey: "recommend", Name: "药品推荐与注意事项", Purpose: "按已确认的疾病方向推荐方案、商品和注意事项", PrimaryDimensionKey: "disease", SortOrder: 4, Scripts: []scriptkit.ScriptInput{
		{ScriptKey: "recommend_fallback", Name: "推荐兜底话术", ScriptType: "fallback", Content: bank.RecommendFallback, SortOrder: 100},
	}}
	for _, name := range diseaseNames {
		order := 1000
		combos := combinations[name]
		sort.SliceStable(combos, func(i, j int) bool { return combos[i].Weight > combos[j].Weight })
		for _, combination := range combos {
			products := make([]scriptkit.ProductInput, 0, len(combination.Products))
			for _, product := range combination.Products {
				if strings.TrimSpace(product.SKUCode) == "" {
					continue
				}
				products = append(products, scriptkit.ProductInput{SKUCode: product.SKUCode, ProductName: product.ProductName})
			}
			recommendStage.Scripts = append(recommendStage.Scripts, scriptkit.ScriptInput{
				ScriptKey: keys.key("recommend_combination"), Name: name + combination.Name, ScriptType: "message",
				Content:           strings.ReplaceAll(combination.Script, "{{purchased_products}}", "{{input.product_names}}"),
				DimensionValueKey: diseaseKey[name], ConfirmThreshold: 5, ShowThreshold: 10,
				Products: products, SortOrder: order,
			})
			order++
		}
		recommendStage.Scripts = append(recommendStage.Scripts, scriptkit.ScriptInput{
			ScriptKey: keys.key("recommend_note"), Name: name + "注意事项", ScriptType: "message",
			Content:           bank.DiseaseCareNote,
			DimensionValueKey: diseaseKey[name], ConfirmThreshold: 5, ShowThreshold: 10, SortOrder: order,
		})
	}
	input.Stages = append(input.Stages, recommendStage)

	// Verify generated keys are valid before returning.
	if err := scriptkit.ValidatePackageInput(input); err != nil {
		return scriptkit.PackageInput{}, fmt.Errorf("generated package is invalid: %w", err)
	}
	return input, nil
}

func readQuestionBank(filename string) (petQuestionBank, error) {
	raw, err := os.ReadFile(filename)
	if err != nil {
		return petQuestionBank{}, fmt.Errorf("read pet question bank %s: %w", filename, err)
	}
	var bank petQuestionBank
	if err := json.Unmarshal(raw, &bank); err != nil {
		return petQuestionBank{}, fmt.Errorf("parse pet question bank %s: %w", filename, err)
	}
	if bank.SymptomConfirmOptions.Yes == "" {
		bank.SymptomConfirmOptions.Yes = "有"
	}
	if bank.SymptomConfirmOptions.No == "" {
		bank.SymptomConfirmOptions.No = "没有"
	}
	if bank.DiseaseConfirmOptions.Yes == "" {
		bank.DiseaseConfirmOptions.Yes = "对，按这个判断"
	}
	if bank.DiseaseConfirmOptions.No == "" {
		bank.DiseaseConfirmOptions.No = "感觉不太像"
	}
	if bank.SymptomScreeningTemplate == "" {
		return petQuestionBank{}, fmt.Errorf("pet question bank %s is missing symptom_screening_template", filename)
	}
	if bank.DiseaseConfirmTemplate == "" || bank.DiseaseConfirmedCopyTemplate == "" {
		return petQuestionBank{}, fmt.Errorf("pet question bank %s is missing disease templates", filename)
	}
	return bank, nil
}

func readClassification(filename string) (petClassification, error) {
	raw, err := os.ReadFile(filename)
	if err != nil {
		return petClassification{}, fmt.Errorf("read pet classification %s: %w", filename, err)
	}
	var wrapper struct {
		ConsultPayload string `json:"consultPayload"`
	}
	if err := json.Unmarshal(raw, &wrapper); err != nil {
		return petClassification{}, fmt.Errorf("parse pet classification wrapper %s: %w", filename, err)
	}
	var result petClassification
	if err := json.Unmarshal([]byte(wrapper.ConsultPayload), &result); err != nil {
		return petClassification{}, fmt.Errorf("parse pet classification %s: %w", filename, err)
	}
	return result, nil
}

func readStringMap(filename string) (map[string]string, error) {
	raw, err := os.ReadFile(filename)
	if err != nil {
		return nil, fmt.Errorf("read pet string map %s: %w", filename, err)
	}
	var result map[string]string
	if err := json.Unmarshal(raw, &result); err != nil {
		return nil, fmt.Errorf("parse pet string map %s: %w", filename, err)
	}
	return result, nil
}

func readPetScriptMap(filename string) (map[string][]petScriptEntry, error) {
	raw, err := os.ReadFile(filename)
	if err != nil {
		return nil, fmt.Errorf("read pet script map %s: %w", filename, err)
	}
	var source map[string][]petScriptEntry
	if err := json.Unmarshal(raw, &source); err != nil {
		return nil, fmt.Errorf("parse pet script map %s: %w", filename, err)
	}
	return source, nil
}

func readPreGuide(filename string) ([]petScriptEntry, error) {
	raw, err := os.ReadFile(filename)
	if err != nil {
		return nil, fmt.Errorf("read pet pre-symptom guide %s: %w", filename, err)
	}
	var source struct {
		PreSymptomScripts []petScriptEntry `json:"pre_symptom_scripts"`
	}
	if err := json.Unmarshal(raw, &source); err != nil {
		return nil, fmt.Errorf("parse pet pre-symptom guide %s: %w", filename, err)
	}
	return source.PreSymptomScripts, nil
}

// readCombinations loads 疾病 -> 组合方案话术 and the symptom keys of the source.
func readCombinations(filename string) (map[string][]petCombination, map[string]bool, error) {
	raw, err := os.ReadFile(filename)
	if err != nil {
		return nil, nil, fmt.Errorf("read pet script combinations %s: %w", filename, err)
	}
	var source map[string]map[string]petScriptDisease
	if err := json.Unmarshal(raw, &source); err != nil {
		return nil, nil, fmt.Errorf("parse pet script combinations %s: %w", filename, err)
	}
	result := map[string][]petCombination{}
	symptoms := map[string]bool{}
	for symptom, diseases := range source {
		symptoms[symptom] = true
		for disease, definition := range diseases {
			result[disease] = append(result[disease], definition.Combinations...)
		}
	}
	return result, symptoms, nil
}

func readPetKnowledge(filename string) ([]petKnowledgeRow, error) {
	book, err := excelize.OpenFile(filename)
	if err != nil {
		return nil, fmt.Errorf("open pet knowledge %s: %w", filename, err)
	}
	defer book.Close()
	sheets := book.GetSheetList()
	if len(sheets) == 0 {
		return nil, fmt.Errorf("pet knowledge %s has no worksheet", filename)
	}
	iterator, err := book.Rows(sheets[0])
	if err != nil {
		return nil, fmt.Errorf("read pet knowledge worksheet: %w", err)
	}
	defer iterator.Close()
	columns := map[string]int{}
	result := make([]petKnowledgeRow, 0)
	rowNumber := 0
	for iterator.Next() {
		rowNumber++
		values, err := iterator.Columns()
		if err != nil {
			return nil, fmt.Errorf("read pet knowledge row %d: %w", rowNumber, err)
		}
		if rowNumber == 1 {
			for index, value := range values {
				columns[strings.TrimSpace(value)] = index
			}
			for _, required := range []string{"症状", "疾病", "方案", "SKU_CODE", "商品标题"} {
				if _, ok := columns[required]; !ok {
					return nil, fmt.Errorf("pet knowledge is missing column %q", required)
				}
			}
			continue
		}
		row := petKnowledgeRow{
			Symptom:     excelValue(values, columns["症状"]),
			Disease:     excelValue(values, columns["疾病"]),
			SKUCode:     excelValue(values, columns["SKU_CODE"]),
			ProductName: excelValue(values, columns["商品标题"]),
		}
		if row.Symptom == "" && row.Disease == "" {
			continue
		}
		if row.Symptom == "" || row.Disease == "" {
			return nil, fmt.Errorf("pet knowledge row %d must contain 症状 and 疾病", rowNumber)
		}
		result = append(result, row)
	}
	if err := iterator.Error(); err != nil {
		return nil, fmt.Errorf("iterate pet knowledge: %w", err)
	}
	if len(result) == 0 {
		return nil, fmt.Errorf("pet knowledge contains no data")
	}
	return result, nil
}

func excelValue(values []string, index int) string {
	if index >= len(values) {
		return ""
	}
	return strings.TrimSpace(values[index])
}