package tokenhub

import (
	"context"
	"encoding/json"
	"fmt"
	"strings"

	"git.lzcwy.cn/zhengchiliu/zt-closet-backend/internal/mysqlmodel"
)

// outfitCategories 穿搭推荐支持的衣物大类，与 mysqlmodel.Clothes.CategoryMain 取值对齐。
var outfitCategories = []string{"上装", "下装", "连衣裙", "外套", "鞋", "配饰"}

// 完整性规则涉及的品类常量（取值必须与 outfitCategories 一致）。
const (
	categoryTop    = "上装"
	categoryBottom = "下装"
	categoryDress  = "连衣裙"
	categoryCoat   = "外套"
	categoryShoes  = "鞋"
)

// RecommendLLMItem 大模型返回的单品推荐。
type RecommendLLMItem struct {
	Type        string `json:"type"`         // 品类：上装/下装/连衣裙/外套/鞋/配饰
	ClothesID   int64  `json:"clothes_id"`   // 衣橱衣物 ID
	ClothesUUID string `json:"clothes_uuid"` // 衣橱衣物 UUID
	Reason      string `json:"reason"`       // 选择理由
}

// RecommendLLMResponse 大模型返回的穿搭推荐。
type RecommendLLMResponse struct {
	OutfitName  string             `json:"outfit_name"`
	Description string             `json:"description"`
	Style       string             `json:"style"` // 穿搭风格
	Scene       string             `json:"scene"` // 适合场景
	Items       []RecommendLLMItem `json:"items"`
}

// GenerateOutfitRecommendation 调用混元生成今日穿搭推荐。
// scene 为用户自定义场景（前端 scene_type=2 时传入），为空表示由模型自行判断。
// retryHint 为「上次输出不完整」时的服务端纠偏提示（由本包 BuildCorrectionHint /
// CorrectionHintStrictSelection 生成，不含用户输入）；为空表示首次调用。
func (c *Client) GenerateOutfitRecommendation(ctx context.Context, zodiac string, fortune *FortuneItem, clothes []mysqlmodel.Clothes, scene, retryHint string) (*RecommendLLMResponse, error) {
	messages := []Message{
		{Role: "user", Content: buildRecommendPrompt(zodiac, fortune, clothes, scene, retryHint)},
	}

	responseFormat := &ResponseFormat{
		Type: "json_schema",
		JSONSchema: &JSONSchema{
			Name:   "outfit_recommendation",
			Schema: buildRecommendSchema(),
		},
	}

	data, err := c.ChatCompletion(ctx, messages, responseFormat)
	if err != nil {
		return nil, fmt.Errorf("call hunyuan for outfit recommend: %w", err)
	}

	var cr chatResponse
	if err := json.Unmarshal(data, &cr); err != nil {
		return nil, fmt.Errorf("unmarshal chat response: %w", err)
	}

	if len(cr.Choices) == 0 {
		return nil, fmt.Errorf("no choices in response")
	}

	var result RecommendLLMResponse
	content := sanitizeJSONContent(cr.Choices[0].Message.Content)
	if err := json.Unmarshal([]byte(content), &result); err != nil {
		return nil, fmt.Errorf("unmarshal outfit recommend json: %w, raw=%s", err, content)
	}

	return &result, nil
}

// buildRecommendPrompt 构造穿搭推荐 prompt。
// scene 为用户自定义场景（已做注入清洗）：非空时作为硬约束写入 prompt，并指示模型在 scene 字段回填；
// 为空时整段不出现，保持「由模型自行判断场景」的原行为。
// retryHint 为本包生成的纠偏提示（不含用户输入）；为空时整段不出现。
func buildRecommendPrompt(zodiac string, fortune *FortuneItem, clothes []mysqlmodel.Clothes, scene, retryHint string) string {
	clothesText := FormatClothesInfo(clothes)

	sceneSection := ""
	if s := sanitizePromptField(scene); s != "" {
		sceneSection = fmt.Sprintf("\n## 用户指定场景\n用户希望这套搭配用于「%s」，请优先围绕该场景挑选单品，并在 scene 字段回填该场景。\n", s)
	}

	correctionSection := ""
	if h := strings.TrimSpace(retryHint); h != "" {
		correctionSection = fmt.Sprintf("\n## 上次输出问题（本次必须修正）\n%s\n", h)
	}

	return fmt.Sprintf(`你是一位专业的时尚搭配师。请根据用户今天的星座运势和衣橱中的衣物，为用户推荐一套今日穿搭。

## 用户信息
- 星座：%s
- 今日综合运势：%d 星（满分 5 星）
- 今日爱情运势：%d 星
- 今日工作运势：%d 星
- 今日财富运势：%d 星
- 今日运势描述：%s

## 用户衣橱
%s
%s
## 搭配规则
1. 所有推荐单品必须严格选自用户衣橱，clothes_id 与 clothes_uuid 必须与衣橱中存在的衣物一一对应，不得虚构
2. 先识别衣橱中包含的有效品类，仅统计以下 6 类：上装、下装、连衣裙、外套、鞋、配饰：
   - 每个存在的品类最多推荐 1 件最合适的单品
   - 衣橱中没有的品类，不在结果中输出，无需强制凑满 6 件
3. 完整性要求（判定依据为衣橱实际存在的品类，必须满足，否则视为无效输出）：
   - 必须包含「上装」或「连衣裙」二者之一（衣橱存在其中任一时）——不能只推荐外套或只推荐下装
   - 选择「外套」时必须同时搭配「上装」或「连衣裙」（外套是外层，不可孤立出现）
   - 选择「连衣裙」时不再搭配「下装」（二者互斥）
   - 未选择「连衣裙」且衣橱存在「下装」时，必须包含「下装」
   - 衣橱存在「鞋」时必须包含「鞋」；「配饰」为可选点缀
4. 结合今日运势调整风格：运势评分高可选择出彩、有设计感的搭配；运势一般则选择稳重、舒适的基础款搭配
5. 参考衣服的版型（version）、面料材质（material）、图案纹理（pattern）、颜色（主色/副色）、袖型、衣长等进行搭配，确保搭配和谐
6. 保证所选单品之间颜色、风格协调统一
7. 为每件推荐单品撰写一句简洁的推荐理由
8. 为整套穿搭拟定一个贴合风格与运势的好听标题
%s
## 输出要求
必须严格按以下 JSON 结构输出，不要输出任何多余文字、解释或代码围栏：
{
  "outfit_name": "穿搭标题",
  "description": "结合今日运势的整体搭配说明",
  "style": "穿搭风格，如：简约/复古/街头/甜美等",
  "scene": "适合场景，如：通勤/约会/休闲/运动等",
  "items": [
    {"type": "上装", "clothes_id": 1, "clothes_uuid": "衣橱中该衣物对应的UUID", "reason": "单品推荐理由"}
  ]
}
补充约束：
- type 字段取值仅限「上装」「下装」「连衣裙」「外套」「鞋」「配饰」，与衣橱实际品类一一对应
- style 表示穿搭风格（如简约/复古/街头/甜美），scene 表示适合场景（如通勤/约会/休闲/运动），两者含义不同，必须分别输出
- items 数组长度由衣橱中存在的品类数量决定，不存在的品类不写入数组；且必须满足上述「完整性要求」
- clothes_id 必须为整数，且必须是衣橱中真实存在的 ID
- clothes_uuid 必须从「用户衣橱」信息中精确复制，且与 clothes_id 一一对应，严禁编造或改动 UUID`,
		zodiac, fortune.Overall, fortune.Love, fortune.Work, fortune.Money, fortune.Description, clothesText, sceneSection, correctionSection)
}

// buildRecommendSchema 构造 JSON Schema 要求大模型结构化输出。
func buildRecommendSchema() map[string]interface{} {
	return map[string]interface{}{
		"type": "object",
		"properties": map[string]interface{}{
			"outfit_name": map[string]interface{}{
				"type":        "string",
				"description": "穿搭标题",
			},
			"description": map[string]interface{}{
				"type":        "string",
				"description": "穿搭整体描述，结合运势说明搭配理由",
			},
			"style": map[string]interface{}{
				"type":        "string",
				"description": "穿搭风格，如：简约、复古、街头、甜美等",
			},
			"scene": map[string]interface{}{
				"type":        "string",
				"description": "适合场景，如：通勤、约会、休闲、运动等",
			},
			"items": map[string]interface{}{
				"type":        "array",
				"description": "推荐的单品列表，每个存在的品类最多一件，不存在的品类不输出",
				"items": map[string]interface{}{
					"type": "object",
					"properties": map[string]interface{}{
						"type": map[string]interface{}{
							"type":        "string",
							"description": "品类，必须是以下之一：上装、下装、连衣裙、外套、鞋、配饰",
							"enum":        outfitCategories,
						},
						"clothes_id": map[string]interface{}{
							"type":        "integer",
							"description": "衣橱中衣物的 ID",
						},
						"clothes_uuid": map[string]interface{}{
							"type":        "string",
							"description": "衣橱中衣物的 UUID，必须与 clothes_id 对应",
						},
						"reason": map[string]interface{}{
							"type":        "string",
							"description": "推荐理由，一句话说明为什么选这件",
						},
					},
					"required": []string{"type", "clothes_id", "clothes_uuid", "reason"},
				},
			},
		},
		"required": []string{"outfit_name", "description", "style", "scene", "items"},
	}
}

// ValidateClothesIDs 校验并纠偏大模型返回的推荐结果：
//  1. 过滤 clothes_id 不在用户衣橱中的项；
//  2. 将 type 规范化为衣物实际的大类（CategoryMain）；
//  3. 以衣橱实际数据回填正确的 ClothesUUID（防止模型抄错 UUID）；
//  4. 对重复的 clothes_id 去重（保留首次出现）。
func (r *RecommendLLMResponse) ValidateClothesIDs(clothes []mysqlmodel.Clothes) {
	clothesByID := make(map[int64]mysqlmodel.Clothes, len(clothes))
	for _, c := range clothes {
		clothesByID[c.ID] = c
	}

	filtered := make([]RecommendLLMItem, 0, len(r.Items))
	seen := make(map[int64]struct{}, len(r.Items))
	for _, item := range r.Items {
		c, ok := clothesByID[item.ClothesID]
		if !ok {
			continue
		}
		if _, dup := seen[item.ClothesID]; dup {
			continue
		}
		// 以衣橱中实际数据为准，纠偏模型可能返回的 type 与 UUID。
		item.Type = c.CategoryMain
		item.ClothesUUID = c.ClothesUUID
		seen[item.ClothesID] = struct{}{}
		filtered = append(filtered, item)
	}
	r.Items = filtered
}

// GetClothesIDs 获取推荐中所有不重复的 clothes ID。
func (r *RecommendLLMResponse) GetClothesIDs() []int64 {
	ids := make([]int64, 0, len(r.Items))
	seen := make(map[int64]struct{}, len(r.Items))
	for _, item := range r.Items {
		if _, ok := seen[item.ClothesID]; ok {
			continue
		}
		seen[item.ClothesID] = struct{}{}
		ids = append(ids, item.ClothesID)
	}
	return ids
}

// ---- 搭配完整性保障 ----

// CorrectionHintStrictSelection 首次输出没有任何有效单品时的纠偏提示（要求严格从衣橱选品）。
const CorrectionHintStrictSelection = "上一次输出没有任何有效单品。请严格从「用户衣橱」中选择衣物，" +
	"clothes_id 与 clothes_uuid 必须与衣橱中真实存在的衣物完全一致，不得虚构或使用未列出的衣物。"

// BuildCorrectionHint 生成重试时的纠偏提示：仅由固定品类枚举拼装（不含任何用户输入）；无问题时返回空串。
func BuildCorrectionHint(missing, conflicts []string) string {
	if len(missing) == 0 && len(conflicts) == 0 {
		return ""
	}
	var sb strings.Builder
	sb.WriteString("上一次输出不符合搭配完整性规则，本次必须修正：")
	if len(missing) > 0 {
		sb.WriteString("\n- 必须补充以下品类（每类 1 件，且必须选自用户衣橱）：" + strings.Join(missing, "、"))
	}
	if len(conflicts) > 0 {
		sb.WriteString("\n- 以下品类与已选单品冲突，必须移除：" + strings.Join(conflicts, "、"))
	}
	sb.WriteString("\n- 其余单品可沿用上一次的选择，但必须同时满足「## 搭配规则」的全部要求。")
	return sb.String()
}

// NormalizeCategories 同一品类最多保留 1 件（保留首次出现），返回被移除的品类。
// 与提示词「每个存在的品类最多推荐 1 件」保持一致，避免模型重复给出同类单品造成搭配冗余。
func (r *RecommendLLMResponse) NormalizeCategories() (removed []string) {
	seen := make(map[string]bool, len(r.Items))
	kept := make([]RecommendLLMItem, 0, len(r.Items))
	for _, item := range r.Items {
		if item.Type != "" {
			if seen[item.Type] {
				removed = append(removed, item.Type)
				continue
			}
			seen[item.Type] = true
		}
		kept = append(kept, item)
	}
	r.Items = kept
	return removed
}

// CompletenessIssues 按衣橱实际存在的品类判定搭配完整性，返回缺失品类与冲突品类；两者皆空表示搭配完整。
//
// 规则（衣橱中不存在的品类不强制，避免要求补齐一个衣橱里根本没有的品类）：
//  1. 内层必选（含「外套不可孤立」）：结果必须包含「上装」或「连衣裙」二者之一；选了外套同样如此，
//     因为外套是外层、无法单独构成一套穿搭；
//  2. 下装：结果未选「连衣裙」且衣橱存在「下装」时，必须包含「下装」；
//  3. 鞋：衣橱存在「鞋」时必须包含「鞋」；「配饰」为可选点缀，不做要求；
//  4. 冲突：结果同时包含「连衣裙」与「下装」（二者互斥）。
//
// 调用前需先执行 ValidateClothesIDs，保证 item.Type 为衣橱实际大类。
func (r *RecommendLLMResponse) CompletenessIssues(clothes []mysqlmodel.Clothes) (missing []string, conflicts []string) {
	wardrobe := wardrobeCategories(clothes)
	picked := r.pickedCategories()

	hasDress := picked[categoryDress]
	if hasInner := picked[categoryTop] || hasDress; !hasInner &&
		(picked[categoryCoat] || wardrobe[categoryTop] || wardrobe[categoryDress]) {
		// 优先补「上装」，衣橱没有上装时补「连衣裙」；两者都没有则无法补齐，不做要求。
		switch {
		case wardrobe[categoryTop]:
			missing = append(missing, categoryTop)
		case wardrobe[categoryDress]:
			missing = append(missing, categoryDress)
		}
	}
	if !hasDress && wardrobe[categoryBottom] && !picked[categoryBottom] {
		missing = append(missing, categoryBottom)
	}
	if wardrobe[categoryShoes] && !picked[categoryShoes] {
		missing = append(missing, categoryShoes)
	}
	if hasDress && picked[categoryBottom] {
		conflicts = append(conflicts, categoryBottom)
	}
	return missing, conflicts
}

// ApplyAutoComplete 确定性补齐缺失品类并剔除冲突项，返回新增与移除的品类。
// 补齐顺序与 CompletenessIssues 的缺失顺序一致（内层 → 下装 → 鞋）；候选单品按固定优先级排序，保证同输入同输出。
func (r *RecommendLLMResponse) ApplyAutoComplete(clothes []mysqlmodel.Clothes) (added []string, removed []string) {
	removed = append(removed, r.removeConflicts()...)

	pref := r.completionPref(clothes)
	// 循环上限取品类总数（补齐最多 3 件），防御异常输入导致死循环。
	for round := 0; round < len(outfitCategories); round++ {
		missing, conflicts := r.CompletenessIssues(clothes)
		if len(conflicts) > 0 {
			removed = append(removed, r.removeConflicts()...)
			continue
		}
		if len(missing) == 0 {
			break
		}
		item, ok := r.pickCompletionItem(clothes, missing[0], pref)
		if !ok {
			break // 衣橱中该品类没有可用单品：无法补齐，保留现状。
		}
		r.Items = append(r.Items, *item)
		added = append(added, missing[0])
	}
	return added, removed
}

// completionPreference 补齐偏好：已选单品的风格 / 主色 / 视觉冲击力众数（空串表示无偏好）。
type completionPreference struct {
	style        string
	color        string
	visualImpact string
}

// completionPref 汇总已选单品对应衣物的风格/主色/视觉冲击力众数，用于挑选最协调的补齐单品。
func (r *RecommendLLMResponse) completionPref(clothes []mysqlmodel.Clothes) completionPreference {
	clothesByID := make(map[int64]mysqlmodel.Clothes, len(clothes))
	for _, c := range clothes {
		clothesByID[c.ID] = c
	}
	styles := make([]string, 0, len(r.Items))
	colors := make([]string, 0, len(r.Items))
	impacts := make([]string, 0, len(r.Items))
	for _, item := range r.Items {
		c, ok := clothesByID[item.ClothesID]
		if !ok {
			continue
		}
		styles = append(styles, c.Style)
		colors = append(colors, c.ColorMain)
		impacts = append(impacts, c.VisualImpact)
	}
	return completionPreference{
		style:        mostFrequent(styles),
		color:        mostFrequent(colors),
		visualImpact: mostFrequent(impacts),
	}
}

// pickCompletionItem 为指定品类挑选补齐单品：排除已在结果中的衣物，按
// 「同风格 → 主色一致 → 视觉冲击力一致 → ID 最新」的确定性优先级取第一件。
func (r *RecommendLLMResponse) pickCompletionItem(clothes []mysqlmodel.Clothes, category string, pref completionPreference) (*RecommendLLMItem, bool) {
	picked := make(map[int64]bool, len(r.Items))
	for _, item := range r.Items {
		picked[item.ClothesID] = true
	}
	var best *mysqlmodel.Clothes
	for i := range clothes {
		c := &clothes[i]
		if c.CategoryMain != category || picked[c.ID] {
			continue
		}
		if best == nil || completionBetter(c, best, pref) {
			best = c
		}
	}
	if best == nil {
		return nil, false
	}
	return &RecommendLLMItem{
		Type:        best.CategoryMain,
		ClothesID:   best.ID,
		ClothesUUID: best.ClothesUUID,
		Reason:      "系统按搭配完整性规则补齐（原推荐缺少" + category + "）",
	}, true
}

// completionBetter 报告 a 是否应优先于 b（确定性排序键，保证同输入同输出）。
func completionBetter(a, b *mysqlmodel.Clothes, pref completionPreference) bool {
	if hitA, hitB := prefMatch(a.Style, pref.style), prefMatch(b.Style, pref.style); hitA != hitB {
		return hitA
	}
	if hitA, hitB := prefMatch(a.ColorMain, pref.color), prefMatch(b.ColorMain, pref.color); hitA != hitB {
		return hitA
	}
	if hitA, hitB := prefMatch(a.VisualImpact, pref.visualImpact), prefMatch(b.VisualImpact, pref.visualImpact); hitA != hitB {
		return hitA
	}
	return a.ID > b.ID // 同一优先级时取最近上传的一件，保证结果稳定可复现。
}

// prefMatch 判断候选值是否命中偏好值（偏好为空视为不命中，避免空值互相“匹配”造成排序漂移）。
func prefMatch(value, preference string) bool {
	return preference != "" && value == preference
}

// removeConflicts 剔除与「连衣裙」互斥的「下装」，返回被移除的品类。
func (r *RecommendLLMResponse) removeConflicts() (removed []string) {
	picked := r.pickedCategories()
	if !picked[categoryDress] || !picked[categoryBottom] {
		return nil
	}
	kept := make([]RecommendLLMItem, 0, len(r.Items))
	for _, item := range r.Items {
		if item.Type == categoryBottom {
			removed = append(removed, item.Type)
			continue
		}
		kept = append(kept, item)
	}
	r.Items = kept
	return removed
}

// pickedCategories 返回推荐结果覆盖的品类集合。
func (r *RecommendLLMResponse) pickedCategories() map[string]bool {
	picked := make(map[string]bool, len(r.Items))
	for _, item := range r.Items {
		picked[item.Type] = true
	}
	return picked
}

// wardrobeCategories 统计衣橱中实际存在的大类（仅 6 类有意义，其它取值不影响规则判定）。
func wardrobeCategories(clothes []mysqlmodel.Clothes) map[string]bool {
	wardrobe := make(map[string]bool, len(outfitCategories))
	for _, c := range clothes {
		wardrobe[c.CategoryMain] = true
	}
	return wardrobe
}

// mostFrequent 返回非空值中出现次数最多的值（并列时取先出现者）；全为空时返回空串。
func mostFrequent(values []string) string {
	counts := make(map[string]int, len(values))
	best, bestCount := "", 0
	for _, v := range values {
		if v == "" {
			continue
		}
		counts[v]++
		if counts[v] > bestCount {
			best, bestCount = v, counts[v]
		}
	}
	return best
}

// FormatClothesInfo 将衣橱衣物列表转换为传给 LLM 的摘要格式。
// 使用「字段名:值」标注，补全穿搭相关字段，便于模型准确理解每个属性。
// 所有字符串字段经 sanitizePromptField 清洗，降低 prompt 注入风险。
func FormatClothesInfo(clothesList []mysqlmodel.Clothes) string {
	var sb strings.Builder
	for _, c := range clothesList {
		sb.WriteString(fmt.Sprintf(
			"- ID:%d | UUID:%s | 大类:%s | 小类:%s | 名称:%s | 主色:%s | 副色:%s | 风格:%s | 版型:%s | 材质:%s | 花纹:%s | 厚度:%s | 袖型:%s | 衣长:%s | 领型:%s | 正式度:%s | 场合:%s | 视觉冲击力:%s\n",
			c.ID,
			sanitizePromptField(c.ClothesUUID), sanitizePromptField(c.CategoryMain), sanitizePromptField(c.CategorySub),
			sanitizePromptField(c.Name), sanitizePromptField(c.ColorMain), sanitizePromptField(c.ColorSub),
			sanitizePromptField(c.Style), sanitizePromptField(c.Version), sanitizePromptField(c.Material),
			sanitizePromptField(c.Pattern), sanitizePromptField(c.Thickness), sanitizePromptField(c.SleeveType),
			sanitizePromptField(c.ClothesType), sanitizePromptField(c.NecklineType), sanitizePromptField(c.Formality),
			sanitizePromptField(c.Occasions), sanitizePromptField(c.VisualImpact)))
	}
	return sb.String()
}

// sanitizePromptField 清洗拼入 prompt 的用户可控字段：
// 截断长度、移除换行与控制字符、压缩连续空白，降低 prompt 注入风险。
func sanitizePromptField(s string) string {
	const maxLen = 200
	if s == "" {
		return ""
	}

	var b strings.Builder
	for _, r := range s {
		switch {
		case r == '\n' || r == '\r' || r == '\t':
			b.WriteRune(' ') // 换行/制表符压缩为空格，防止注入换行指令。
		case r < 0x20 || r == 0x7F:
			continue // 丢弃其它控制字符。
		default:
			b.WriteRune(r)
		}
	}

	// 压缩连续空白。
	out := strings.Join(strings.Fields(b.String()), " ")
	runes := []rune(out)
	if len(runes) > maxLen {
		out = string(runes[:maxLen])
	}
	return out
}