package orchestrator

import (
	"context"
	"encoding/json"
	"fmt"
	"git.yeij.top/AskaEth/Cyrene/pkg/logger"
	"strings"

	"git.yeij.top/AskaEth/Cyrene/ai-core/internal/llm"
	"git.yeij.top/AskaEth/Cyrene/ai-core/internal/model"
)

// IntentAnalyzer 意图分析器
// 使用轻量 LLM 调用判断用户消息的意图
type IntentAnalyzer struct {
	llmAdapter *llm.Adapter
	enabled    bool
}

// NewIntentAnalyzer 创建意图分析器
func NewIntentAnalyzer(llmAdapter *llm.Adapter) *IntentAnalyzer {
	return &IntentAnalyzer{
		llmAdapter: llmAdapter,
		enabled:    llmAdapter != nil,
	}
}

// Analyze 分析用户消息意图
// 优先使用 LLM，对于简单问候使用关键词快速通道（跳过 LLM 调用）
func (a *IntentAnalyzer) Analyze(ctx context.Context, userMessage string, historyHint ...string) (*model.IntentResult, error) {
	// 快速通道：简单问候/闲聊直接返回，跳过 LLM 调用
	if a.isSimpleGreeting(userMessage) {
		logger.Printf("[intent] 快速通道: 检测到简单问候，跳过 LLM 分析")
		result := &model.IntentResult{
			Primary:     "greeting",
			NeedsMemory: false,
			NeedsIoT:    false,
			Sentiment:   "positive",
			Urgency:     "low",
		}
		return result, nil
	}

	// 快速通道：强 IoT 关键词直接使用规则匹配，跳过 LLM 调用（节省 2-3s）
	if a.isStrongIoTCommand(userMessage) {
		logger.Printf("[intent] 快速通道: 检测到 IoT 操控命令，跳过 LLM 分析")
		return a.keywordAnalyze(userMessage), nil
	}

	// 如果 LLM 不可用，直接使用关键词匹配
	if !a.enabled || a.llmAdapter == nil {
		logger.Printf("[intent] LLM 不可用，使用关键词规则分析意图")
		return a.keywordAnalyze(userMessage), nil
	}

	// 构建轻量意图分析提示词
	userContent := userMessage
	if len(historyHint) > 0 && historyHint[0] != "" {
		userContent = fmt.Sprintf("对话上下文: %s\n\n用户消息: %s", historyHint[0], userMessage)
	}
	messages := []model.LLMMessage{
		{
			Role:    model.RoleSystem,
			Content: intentAnalysisSystemPrompt,
		},
		{
			Role:    model.RoleUser,
			Content: userContent,
		},
	}

	// 调用 LLM (同步)
	resp, err := a.llmAdapter.Chat(ctx, messages)
	if err != nil {
		logger.Printf("[intent] LLM 意图分析失败: %v，降级使用关键词规则", err)
		return a.keywordAnalyze(userMessage), nil
	}

	// 解析 JSON 响应
	intent, err := parseIntentResponse(resp.Content)
	if err != nil {
		logger.Printf("[intent] 解析意图 JSON 失败: %v，降级使用关键词规则", err)
		return a.keywordAnalyze(userMessage), nil
	}

	logger.Printf("[intent] 意图分析完成: primary=%s, iot=%v, memory=%v, sentiment=%s",
		intent.Primary, intent.NeedsIoT, intent.NeedsMemory, intent.Sentiment)

	return intent, nil
}

// isSimpleGreeting 检测是否为简单问候/闲聊，无需复杂子会话分派
func (a *IntentAnalyzer) isSimpleGreeting(userMessage string) bool {
	msgLower := strings.TrimSpace(strings.ToLower(userMessage))

	// 精确匹配简单问候
	simpleGreetings := []string{
		"你好", "嗨", "嘿", "哈喽", "hello", "hi", "hey",
		"早上好", "下午好", "晚上好", "晚安", "早安", "午安",
		"在吗", "在不在", "在么", "在不",
		"谢谢", "多谢", "感谢", "thanks", "thank you",
		"好的", "ok", "okay", "行", "可以", "没问题",
		"再见", "拜拜", "bye", "byebye", "晚安",
		"嗯", "哦", "噢", "额",
	}

	for _, g := range simpleGreetings {
		if msgLower == g {
			return true
		}
	}

	// 检测极短消息（<=4个字符）且不包含IoT/问题关键词
	runes := []rune(msgLower)
	if len(runes) <= 4 {
		// 检查是否有明显需要处理的关键词
		complexKeywords := []string{"灯", "空调", "窗帘", "设备", "开关", "温度", "亮度",
			"什么", "怎么", "为什么", "如何", "谁", "哪里",
			"打开", "关闭", "调到", "设置", "帮我", "查"}
		for _, kw := range complexKeywords {
			if strings.Contains(msgLower, kw) {
				return false
			}
		}
		return true
	}

	return false
}

// isStrongIoTCommand 检测是否为明确的 IoT 操控命令，可直接跳过 LLM 意图分析
func (a *IntentAnalyzer) isStrongIoTCommand(userMessage string) bool {
	msgLower := strings.TrimSpace(strings.ToLower(userMessage))

	// 控制类关键词 + 设备类关键词组合出现，即可判断为 IoT 命令
	controlWords := []string{"打开", "关闭", "关掉", "关上", "调到", "设置", "开关", "调节", "调高", "调低", "开一下", "关一下"}
	deviceWords := []string{"灯", "空调", "窗帘", "电视", "风扇", "加湿器", "插座", "门锁", "传感器"}

	hasControl := false
	for _, w := range controlWords {
		if strings.Contains(msgLower, w) {
			hasControl = true
			break
		}
	}

	hasDevice := false
	for _, w := range deviceWords {
		if strings.Contains(msgLower, w) {
			hasDevice = true
			break
		}
	}

	return hasControl && hasDevice
}

// keywordAnalyze 基于关键词的意图分析（降级方案）
func (a *IntentAnalyzer) keywordAnalyze(userMessage string) *model.IntentResult {
	result := &model.IntentResult{
		Primary:     "chat",
		NeedsMemory: true,  // 默认检索记忆
		Sentiment:   "neutral",
		Urgency:     "low",
	}

	msgLower := strings.ToLower(userMessage)

	// IoT 关键词检测
	iotKeywords := []string{
		"灯", "空调", "窗帘", "电视", "设备", "开关",
		"打开", "关闭", "调到", "设置", "温度", "亮度",
		"传感器", "门锁", "插座", "风扇", "加湿器",
	}
	for _, kw := range iotKeywords {
		if strings.Contains(msgLower, kw) {
			result.NeedsIoT = true
			result.Primary = "iot_control"
			break
		}
	}

	// 情感检测
	positiveWords := []string{"开心", "高兴", "哈哈", "好棒", "喜欢", "爱", "谢谢", "棒", "赞", "太好了"}
	negativeWords := []string{"难过", "伤心", "生气", "烦", "累", "不开心", "讨厌", "恨", "糟糕", "烦死了"}

	for _, w := range positiveWords {
		if strings.Contains(msgLower, w) {
			result.Sentiment = "positive"
			break
		}
	}
	for _, w := range negativeWords {
		if strings.Contains(msgLower, w) {
			result.Sentiment = "negative"
			result.Primary = "emotional"
			break
		}
	}

	// 问题检测
	questionWords := []string{"什么", "怎么", "为什么", "如何", "谁", "哪里", "哪个", "多少", "能不能", "可以"}
	for _, w := range questionWords {
		if strings.Contains(msgLower, w) {
			result.Primary = "question"
			break
		}
	}

	return result
}

// intentAnalysisSystemPrompt 意图分析系统提示词 (轻量，快速返回)
const intentAnalysisSystemPrompt = `分析以下用户消息的意图。只需返回 JSON，不要其他内容。

返回格式:
{
  "primary": "chat|iot_control|iot_query|question|emotional",
  "needs_iot": true/false,
  "needs_memory": true/false,
  "sentiment": "positive|neutral|negative",
  "urgency": "low|medium|high"
}

规则:
- primary: 用户的主要意图
  - chat: 日常闲聊
  - iot_control: 需要控制智能设备
  - iot_query: 查询设备状态（仅当明确提到设备名时才用，如灯/空调/温度）
  - question: 提问（短追问如"看到了什么""什么意思""然后呢"归此类）
  - emotional: 情绪表达/倾诉
- needs_iot: 是否需要调用 IoT 相关功能（仅当明确提到设备名词时才为 true）
- needs_memory: 是否需要检索用户记忆（大部分情况为 true）
- sentiment: 用户情绪
- urgency: low=普通闲聊, medium=需要回应, high=紧急求助
- 重要：短追问绝不判定为 iot_control 或 iot_query，应判定为 question`

// parseIntentResponse 从 LLM 响应中解析意图 JSON
func parseIntentResponse(content string) (*model.IntentResult, error) {
	// 尝试找到 JSON 块
	content = strings.TrimSpace(content)

	// 如果被 markdown 代码块包裹，提取内容
	if strings.HasPrefix(content, "```") {
		// 找到第一行换行符
		idx := strings.Index(content, "\n")
		if idx >= 0 {
			content = content[idx+1:]
		}
		// 找到结尾的 ```
		lastIdx := strings.LastIndex(content, "```")
		if lastIdx >= 0 {
			content = content[:lastIdx]
		}
		content = strings.TrimSpace(content)
	}

	// 尝试找到 JSON 对象
	startIdx := strings.Index(content, "{")
	endIdx := strings.LastIndex(content, "}")
	if startIdx >= 0 && endIdx > startIdx {
		content = content[startIdx : endIdx+1]
	}

	var result model.IntentResult
	if err := json.Unmarshal([]byte(content), &result); err != nil {
		return nil, fmt.Errorf("JSON 解析失败: %w", err)
	}

	// 设置默认值
	if result.Primary == "" {
		result.Primary = "chat"
	}
	if result.Sentiment == "" {
		result.Sentiment = "neutral"
	}
	if result.Urgency == "" {
		result.Urgency = "low"
	}

	return &result, nil
}
