package main

import (
	"encoding/json"
	"fmt"
	"reflect"
	"sort"
	"strings"
	"time"

	"qiweimanager/config"
)

const (
	afterSalesDispatchUnassigned = "unassigned"
	afterSalesDispatchSuggested  = "suggested"
	afterSalesDispatchAssigned   = "assigned"

	afterSalesNotifyNotSent = "not_sent"
	afterSalesNotifySent    = "sent"
	afterSalesNotifyFailed  = "failed"

	defaultDispatchNotifyCooldownSeconds = 300
	defaultDispatchMinConfidence         = 0.75

	dispatchSourceAI     = "ai_suggested"
	dispatchSourceManual = "manual_assigned"
	dispatchSourceRule   = "rule_suggested"
)

type AfterSalesEngineer struct {
	UserID      string `json:"userId"`
	Name        string `json:"name"`
	Description string `json:"description"`
	Remark      string `json:"remark"`
	Enabled     bool   `json:"enabled"`
}

type AfterSalesDispatchRule struct {
	ID              string   `json:"id"`
	Name            string   `json:"name"`
	EngineerUserID  string   `json:"engineerUserId"`
	EngineerName    string   `json:"engineerName"`
	ConversationIDs []string `json:"conversationIds"`
	CustomerNames   []string `json:"customerNames"`
	ProductKeywords []string `json:"productKeywords"`
	IssueKeywords   []string `json:"issueKeywords"`
	Enabled         bool     `json:"enabled"`
}

type AfterSalesDispatchConfig struct {
	Engineers               []AfterSalesEngineer     `json:"engineers"`
	Rules                   []AfterSalesDispatchRule `json:"rules"`
	NotifyTemplate          string                   `json:"notifyTemplate"`
	NotifyCooldownSeconds   int                      `json:"notifyCooldownSeconds"`
	AutoNotifyEnabled       bool                     `json:"autoNotifyEnabled"`
	AutoNotifyMinConfidence float64                  `json:"autoNotifyMinConfidence"`
}

type AfterSalesDispatchSummary struct {
	Pending    int `json:"pending"`
	Unassigned int `json:"unassigned"`
	Assigned   int `json:"assigned"`
	Sent       int `json:"sent"`
	Failed     int `json:"failed"`
	TodayNew   int `json:"todayNew"`
	NotSent    int `json:"notSent"`
}

type AfterSalesDispatchQueue struct {
	Issues  []AfterSalesIssue         `json:"issues"`
	Summary AfterSalesDispatchSummary `json:"summary"`
	Config  AfterSalesDispatchConfig  `json:"config"`
}

type AfterSalesNotifyResult struct {
	IssueID string `json:"issueId"`
	Success bool   `json:"success"`
	Message string `json:"message"`
}

type afterSalesDispatchMatch struct {
	Rule         AfterSalesDispatchRule
	Priority     int
	MatchedLabel string
}

type afterSalesDispatchAIChoice struct {
	EngineerUserID string  `json:"engineer_user_id"`
	Reason         string  `json:"reason"`
	Confidence     float64 `json:"confidence"`
}

var (
	afterSalesDispatchMatcher        = callAfterSalesDispatchAI
	afterSalesDispatchAIConfigSource = currentAfterSalesDispatchAIConfig
)

func defaultAfterSalesDispatchConfig() AfterSalesDispatchConfig {
	return AfterSalesDispatchConfig{
		Engineers:               []AfterSalesEngineer{},
		Rules:                   []AfterSalesDispatchRule{},
		NotifyTemplate:          "",
		NotifyCooldownSeconds:   defaultDispatchNotifyCooldownSeconds,
		AutoNotifyEnabled:       false,
		AutoNotifyMinConfidence: defaultDispatchMinConfidence,
	}
}

func afterSalesDispatchConfigPath() string {
	return resolveAutoReplyPath("config/after_sales_dispatch_config.json")
}

func readAfterSalesDispatchConfig() (AfterSalesDispatchConfig, error) {
	cfg := defaultAfterSalesDispatchConfig()
	if err := readJSONFile(afterSalesDispatchConfigPath(), &cfg); err != nil {
		return cfg, err
	}
	normalizeAfterSalesDispatchConfig(&cfg)
	return cfg, nil
}

func saveAfterSalesDispatchConfig(cfg AfterSalesDispatchConfig) error {
	normalizeAfterSalesDispatchConfig(&cfg)
	return atomicWriteJSON(afterSalesDispatchConfigPath(), cfg)
}

func normalizeAfterSalesDispatchConfig(cfg *AfterSalesDispatchConfig) {
	if cfg == nil {
		return
	}
	if cfg.NotifyCooldownSeconds <= 0 {
		cfg.NotifyCooldownSeconds = defaultDispatchNotifyCooldownSeconds
	}
	if cfg.AutoNotifyMinConfidence <= 0 || cfg.AutoNotifyMinConfidence > 1 {
		cfg.AutoNotifyMinConfidence = defaultDispatchMinConfidence
	}
	for i := range cfg.Engineers {
		cfg.Engineers[i].UserID = strings.TrimSpace(cfg.Engineers[i].UserID)
		cfg.Engineers[i].Name = strings.TrimSpace(cfg.Engineers[i].Name)
		cfg.Engineers[i].Description = strings.TrimSpace(cfg.Engineers[i].Description)
		cfg.Engineers[i].Remark = strings.TrimSpace(cfg.Engineers[i].Remark)
		if !cfg.Engineers[i].Enabled && cfg.Engineers[i].UserID != "" {
			cfg.Engineers[i].Enabled = true
		}
	}
	cfg.Engineers = uniqueAfterSalesEngineers(cfg.Engineers)
	for i := range cfg.Rules {
		rule := &cfg.Rules[i]
		rule.ID = strings.TrimSpace(rule.ID)
		if rule.ID == "" {
			rule.ID = newAfterSalesID()
		}
		rule.Name = strings.TrimSpace(rule.Name)
		rule.EngineerUserID = strings.TrimSpace(rule.EngineerUserID)
		rule.EngineerName = strings.TrimSpace(rule.EngineerName)
		rule.ConversationIDs = uniqueNonEmptyStrings(rule.ConversationIDs)
		rule.CustomerNames = uniqueNonEmptyStrings(rule.CustomerNames)
		rule.ProductKeywords = uniqueNonEmptyStrings(rule.ProductKeywords)
		rule.IssueKeywords = uniqueNonEmptyStrings(rule.IssueKeywords)
		if !rule.Enabled && rule.EngineerUserID != "" {
			rule.Enabled = true
		}
	}
}

func uniqueAfterSalesEngineers(items []AfterSalesEngineer) []AfterSalesEngineer {
	seen := make(map[string]bool)
	result := make([]AfterSalesEngineer, 0, len(items))
	for _, item := range items {
		item.UserID = strings.TrimSpace(item.UserID)
		if item.UserID == "" || seen[item.UserID] {
			continue
		}
		seen[item.UserID] = true
		result = append(result, item)
	}
	return result
}

func normalizeAfterSalesDispatchFields(issue *AfterSalesIssue) {
	if issue == nil {
		return
	}
	issue.AssignedEngineerID = strings.TrimSpace(issue.AssignedEngineerID)
	issue.AssignedEngineerName = strings.TrimSpace(issue.AssignedEngineerName)
	issue.DispatchStatus = normalizeAfterSalesDispatchStatus(issue.DispatchStatus, issue.AssignedEngineerID)
	issue.NotifyStatus = normalizeAfterSalesNotifyStatus(issue.NotifyStatus)
	issue.DispatchReason = strings.TrimSpace(issue.DispatchReason)
	issue.DispatchRuleID = strings.TrimSpace(issue.DispatchRuleID)
	issue.DispatchSource = strings.TrimSpace(issue.DispatchSource)
	if issue.DispatchConfidence < 0 {
		issue.DispatchConfidence = 0
	}
	if issue.DispatchConfidence > 1 {
		issue.DispatchConfidence = 1
	}
	issue.NotifyError = strings.TrimSpace(issue.NotifyError)
	if issue.NotifyStatus == afterSalesNotifySent {
		issue.NotifyError = ""
	}
}

func normalizeAfterSalesDispatchStatus(status string, engineerID string) string {
	switch strings.ToLower(strings.TrimSpace(status)) {
	case afterSalesDispatchSuggested:
		if strings.TrimSpace(engineerID) != "" {
			return afterSalesDispatchSuggested
		}
	case afterSalesDispatchAssigned:
		if strings.TrimSpace(engineerID) != "" {
			return afterSalesDispatchAssigned
		}
	}
	return afterSalesDispatchUnassigned
}

func normalizeAfterSalesNotifyStatus(status string) string {
	switch strings.ToLower(strings.TrimSpace(status)) {
	case afterSalesNotifySent:
		return afterSalesNotifySent
	case afterSalesNotifyFailed:
		return afterSalesNotifyFailed
	default:
		return afterSalesNotifyNotSent
	}
}

func (e *AfterSalesIssueEngine) dispatchQueue() (AfterSalesDispatchQueue, error) {
	cfg, err := readAfterSalesDispatchConfig()
	if err != nil {
		return AfterSalesDispatchQueue{}, err
	}
	e.refreshDispatchAssignments(cfg)
	e.mu.Lock()
	issues := append([]AfterSalesIssue(nil), e.issues...)
	e.mu.Unlock()
	sort.Slice(issues, func(i, j int) bool {
		return issues[i].CreatedAt > issues[j].CreatedAt
	})
	return AfterSalesDispatchQueue{
		Issues:  issues,
		Summary: summarizeAfterSalesDispatch(issues),
		Config:  cfg,
	}, nil
}

func (e *AfterSalesIssueEngine) refreshDispatchAssignments(cfg AfterSalesDispatchConfig) {
	candidates := e.dispatchAssignmentCandidates(cfg)
	for _, issue := range candidates {
		choice, err := dispatchIssueWithAI(cfg, issue)
		e.applyDispatchChoice(issue.ID, cfg, choice, err)
	}
	if cfg.AutoNotifyEnabled {
		for _, issueID := range e.autoNotifyCandidateIDs(cfg) {
			e.notifyEngineer(issueID)
		}
	}
}

func (e *AfterSalesIssueEngine) refreshDispatchAssignmentsAsync() {
	go func() {
		cfg, err := readAfterSalesDispatchConfig()
		if err != nil {
			if globalLogger != nil {
				globalLogger.Warn("[工程师派单] 加载配置失败: %v", err)
			}
			return
		}
		e.refreshDispatchAssignments(cfg)
	}()
}

func (e *AfterSalesIssueEngine) dispatchAssignmentCandidates(cfg AfterSalesDispatchConfig) []AfterSalesIssue {
	e.mu.Lock()
	defer e.mu.Unlock()
	changed := e.applyLegacyDispatchSuggestionsLocked(cfg)
	if changed {
		_ = e.saveIssuesLocked()
	}
	result := make([]AfterSalesIssue, 0)
	for _, issue := range e.issues {
		if shouldDispatchWithAI(issue, cfg) {
			result = append(result, issue)
		}
	}
	return result
}

func shouldDispatchWithAI(issue AfterSalesIssue, cfg AfterSalesDispatchConfig) bool {
	if issue.Status != afterSalesIssueStatusPending {
		return false
	}
	if issue.DispatchSource == dispatchSourceManual || issue.DispatchStatus == afterSalesDispatchAssigned {
		return false
	}
	if issue.NotifyStatus == afterSalesNotifySent {
		return false
	}
	if len(enabledDispatchEngineers(cfg)) == 0 {
		return false
	}
	return true
}

func enabledDispatchEngineers(cfg AfterSalesDispatchConfig) []AfterSalesEngineer {
	result := make([]AfterSalesEngineer, 0, len(cfg.Engineers))
	for _, engineer := range cfg.Engineers {
		if !engineer.Enabled || strings.TrimSpace(engineer.UserID) == "" {
			continue
		}
		if strings.TrimSpace(engineer.Description) == "" {
			continue
		}
		result = append(result, engineer)
	}
	return result
}

func dispatchIssueWithAI(cfg AfterSalesDispatchConfig, issue AfterSalesIssue) (afterSalesDispatchAIChoice, error) {
	aiCfg, err := afterSalesDispatchAIConfigSource()
	if err != nil {
		return afterSalesDispatchAIChoice{}, err
	}
	return afterSalesDispatchMatcher(aiCfg, issue, enabledDispatchEngineers(cfg))
}

func currentAfterSalesDispatchAIConfig() (config.AIConfig, error) {
	appConfig := config.GetGlobalConfig()
	if appConfig == nil {
		return config.AIConfig{}, fmt.Errorf("AI 配置未加载")
	}
	appConfig.ApplyDefaults()
	aiCfg := appConfig.AutoReplyConfig.AI
	if strings.TrimSpace(aiCfg.BaseURL) == "" || strings.TrimSpace(aiCfg.Model) == "" {
		return config.AIConfig{}, fmt.Errorf("AI 配置未完整")
	}
	return aiCfg, nil
}

func (e *AfterSalesIssueEngine) applyDispatchChoice(issueID string, cfg AfterSalesDispatchConfig, choice afterSalesDispatchAIChoice, matchErr error) {
	e.mu.Lock()
	defer e.mu.Unlock()
	for i := range e.issues {
		issue := &e.issues[i]
		if issue.ID != issueID {
			continue
		}
		before := *issue
		normalizeAfterSalesDispatchFields(issue)
		if !shouldDispatchWithAI(*issue, cfg) {
			return
		}
		if matchErr != nil {
			clearDispatchSuggestion(issue, "AI匹配失败: "+matchErr.Error())
		} else if choice.Confidence < cfg.AutoNotifyMinConfidence || strings.TrimSpace(choice.EngineerUserID) == "" {
			clearDispatchSuggestion(issue, strings.TrimSpace(firstNonEmpty(choice.Reason, "AI置信度低，需人工确认")))
			issue.DispatchConfidence = choice.Confidence
			issue.DispatchSource = dispatchSourceAI
		} else {
			issue.AssignedEngineerID = strings.TrimSpace(choice.EngineerUserID)
			issue.AssignedEngineerName = dispatchEngineerName(choice.EngineerUserID, "", cfg)
			issue.DispatchStatus = afterSalesDispatchSuggested
			issue.DispatchReason = strings.TrimSpace(choice.Reason)
			if issue.DispatchReason == "" {
				issue.DispatchReason = "AI根据工程师职责说明匹配"
			}
			issue.DispatchRuleID = ""
			issue.DispatchConfidence = choice.Confidence
			issue.DispatchSource = dispatchSourceAI
		}
		if !reflect.DeepEqual(*issue, before) {
			issue.UpdatedAt = time.Now().Local().Format(time.RFC3339)
			_ = e.saveIssuesLocked()
		}
		return
	}
}

func clearDispatchSuggestion(issue *AfterSalesIssue, reason string) {
	issue.AssignedEngineerID = ""
	issue.AssignedEngineerName = ""
	issue.DispatchStatus = afterSalesDispatchUnassigned
	issue.DispatchReason = strings.TrimSpace(reason)
	issue.DispatchRuleID = ""
}

func (e *AfterSalesIssueEngine) autoNotifyCandidateIDs(cfg AfterSalesDispatchConfig) []string {
	e.mu.Lock()
	defer e.mu.Unlock()
	result := make([]string, 0)
	for _, issue := range e.issues {
		if issue.Status != afterSalesIssueStatusPending {
			continue
		}
		if issue.NotifyStatus != afterSalesNotifyNotSent {
			continue
		}
		if issue.DispatchSource != dispatchSourceAI || issue.DispatchConfidence < cfg.AutoNotifyMinConfidence {
			continue
		}
		if strings.TrimSpace(issue.AssignedEngineerID) == "" {
			continue
		}
		result = append(result, issue.ID)
	}
	return result
}

func summarizeAfterSalesDispatch(issues []AfterSalesIssue) AfterSalesDispatchSummary {
	var summary AfterSalesDispatchSummary
	today := time.Now().Local().Format("2006-01-02")
	for _, issue := range issues {
		if issue.Status != afterSalesIssueStatusPending {
			continue
		}
		summary.Pending++
		if strings.HasPrefix(issue.CreatedAt, today) {
			summary.TodayNew++
		}
		switch normalizeAfterSalesDispatchStatus(issue.DispatchStatus, issue.AssignedEngineerID) {
		case afterSalesDispatchAssigned, afterSalesDispatchSuggested:
			summary.Assigned++
		default:
			summary.Unassigned++
		}
		switch normalizeAfterSalesNotifyStatus(issue.NotifyStatus) {
		case afterSalesNotifySent:
			summary.Sent++
		case afterSalesNotifyFailed:
			summary.Failed++
		default:
			summary.NotSent++
		}
	}
	return summary
}

func (e *AfterSalesIssueEngine) applyLegacyDispatchSuggestionsLocked(cfg AfterSalesDispatchConfig) bool {
	changed := false
	for i := range e.issues {
		issue := &e.issues[i]
		before := *issue
		normalizeAfterSalesDispatchFields(issue)
		if issue.Status == afterSalesIssueStatusPending &&
			issue.DispatchStatus != afterSalesDispatchAssigned &&
			issue.DispatchSource != dispatchSourceManual &&
			len(enabledDispatchEngineers(cfg)) == 0 {
			if match, ok := matchAfterSalesDispatchRule(*issue, cfg); ok {
				issue.AssignedEngineerID = strings.TrimSpace(match.Rule.EngineerUserID)
				issue.AssignedEngineerName = dispatchEngineerName(match.Rule.EngineerUserID, match.Rule.EngineerName, cfg)
				issue.DispatchStatus = afterSalesDispatchSuggested
				issue.DispatchReason = match.MatchedLabel
				issue.DispatchRuleID = match.Rule.ID
				issue.DispatchConfidence = 1
				issue.DispatchSource = dispatchSourceRule
			} else if issue.DispatchStatus == afterSalesDispatchSuggested {
				issue.AssignedEngineerID = ""
				issue.AssignedEngineerName = ""
				issue.DispatchStatus = afterSalesDispatchUnassigned
				issue.DispatchReason = ""
				issue.DispatchRuleID = ""
				issue.DispatchConfidence = 0
				issue.DispatchSource = ""
			}
		}
		if !reflect.DeepEqual(*issue, before) {
			changed = true
		}
	}
	return changed
}

func matchAfterSalesDispatchRule(issue AfterSalesIssue, cfg AfterSalesDispatchConfig) (afterSalesDispatchMatch, bool) {
	best := afterSalesDispatchMatch{}
	found := false
	for _, rule := range cfg.Rules {
		if !rule.Enabled || strings.TrimSpace(rule.EngineerUserID) == "" {
			continue
		}
		if priority, label := dispatchRuleMatchPriority(issue, rule); priority > 0 {
			if !found || priority > best.Priority {
				best = afterSalesDispatchMatch{Rule: rule, Priority: priority, MatchedLabel: label}
				found = true
			}
		}
	}
	return best, found
}

func callAfterSalesDispatchAI(aiCfg config.AIConfig, issue AfterSalesIssue, engineers []AfterSalesEngineer) (afterSalesDispatchAIChoice, error) {
	if len(engineers) == 0 {
		return afterSalesDispatchAIChoice{}, fmt.Errorf("未配置工程师职责说明")
	}
	aiCfg.MaxTokens = maxInt(aiCfg.MaxTokens, 700)
	aiCfg.TimeoutSeconds = maxInt(aiCfg.TimeoutSeconds, 20)
	systemPrompt := `你是售后问题派单助手。请根据售后问题内容和工程师职责说明，选择最应该处理该问题的一位工程师。
规则：
1. 只能从给定工程师列表中选择 user_id。
2. 如果没有明确匹配，engineer_user_id 输出空字符串，confidence 不高于 0.5。
3. confidence 是 0 到 1 的数字，越确定越接近 1。
4. 只输出 JSON 对象，不要 markdown，不要解释文字。
JSON 字段：engineer_user_id, reason, confidence。`
	userPrompt := buildAfterSalesDispatchPrompt(issue, engineers)
	var result *AIResult
	var err error
	switch strings.ToLower(strings.TrimSpace(aiCfg.Provider)) {
	case "local", "ollama":
		result, err = callOllamaChat(aiCfg, systemPrompt, userPrompt)
	default:
		result, err = callOpenAICompatibleChat(aiCfg, systemPrompt, userPrompt)
	}
	if err != nil {
		return afterSalesDispatchAIChoice{}, err
	}
	choice, err := parseAfterSalesDispatchAIResponse(result.Answer)
	if err != nil {
		return afterSalesDispatchAIChoice{}, err
	}
	if choice.EngineerUserID != "" && !dispatchEngineerExists(choice.EngineerUserID, engineers) {
		return afterSalesDispatchAIChoice{}, fmt.Errorf("AI 返回了未配置的工程师: %s", choice.EngineerUserID)
	}
	return choice, nil
}

func buildAfterSalesDispatchPrompt(issue AfterSalesIssue, engineers []AfterSalesEngineer) string {
	var b strings.Builder
	b.WriteString("售后问题：\n")
	b.WriteString("问题ID：")
	b.WriteString(issue.ID)
	b.WriteString("\n群聊：")
	b.WriteString(firstNonEmpty(issue.RoomName, issue.ConversationID))
	b.WriteString("\n客户：")
	b.WriteString(normalizeAfterSalesDisplayName(issue.CustomerName))
	b.WriteString("\n问题描述：")
	b.WriteString(strings.TrimSpace(issue.IssueContent))
	b.WriteString("\nAI建议：")
	b.WriteString(strings.TrimSpace(issue.AISuggestion))
	b.WriteString("\n图片数量：")
	b.WriteString(fmt.Sprintf("%d", len(issue.ImagePaths)+len(issue.ImageRefs)))
	b.WriteString("\n\n工程师列表：\n")
	for _, engineer := range engineers {
		b.WriteString("- user_id=")
		b.WriteString(engineer.UserID)
		b.WriteString(" name=")
		b.WriteString(firstNonEmpty(engineer.Name, engineer.UserID))
		if engineer.Remark != "" {
			b.WriteString(" remark=")
			b.WriteString(engineer.Remark)
		}
		b.WriteString("\n  职责说明：")
		b.WriteString(engineer.Description)
		b.WriteString("\n")
	}
	b.WriteString("\n请选择最匹配的一位工程师。无法明确判断时返回空 engineer_user_id。")
	return b.String()
}

func parseAfterSalesDispatchAIResponse(text string) (afterSalesDispatchAIChoice, error) {
	text = strings.TrimSpace(stripJSONMarkdownFence(text))
	if text == "" {
		return afterSalesDispatchAIChoice{}, fmt.Errorf("AI 返回为空")
	}
	start := strings.Index(text, "{")
	end := strings.LastIndex(text, "}")
	if start < 0 || end < start {
		return afterSalesDispatchAIChoice{}, fmt.Errorf("AI 未返回 JSON 对象: %s", truncateText(text, 200))
	}
	var choice afterSalesDispatchAIChoice
	if err := json.Unmarshal([]byte(text[start:end+1]), &choice); err != nil {
		return afterSalesDispatchAIChoice{}, fmt.Errorf("解析派单 AI JSON 失败: %w", err)
	}
	choice.EngineerUserID = strings.TrimSpace(choice.EngineerUserID)
	choice.Reason = strings.TrimSpace(choice.Reason)
	if choice.Confidence < 0 {
		choice.Confidence = 0
	}
	if choice.Confidence > 1 {
		choice.Confidence = 1
	}
	return choice, nil
}

func dispatchEngineerExists(userID string, engineers []AfterSalesEngineer) bool {
	userID = strings.TrimSpace(userID)
	for _, engineer := range engineers {
		if strings.TrimSpace(engineer.UserID) == userID {
			return true
		}
	}
	return false
}

func dispatchRuleMatchPriority(issue AfterSalesIssue, rule AfterSalesDispatchRule) (int, string) {
	if containsAnyNormalized(rule.ConversationIDs, issue.ConversationID) || containsAnyText(rule.CustomerNames, issue.CustomerName) {
		return 300, dispatchRuleLabel(rule, "群聊/客户")
	}
	productText := strings.Join([]string{issue.RoomName, issue.IssueContent, issue.AISuggestion}, "\n")
	if containsAnyText(rule.ProductKeywords, productText) {
		return 200, dispatchRuleLabel(rule, "产品关键词")
	}
	if containsAnyText(rule.IssueKeywords, strings.Join([]string{issue.IssueContent, issue.AISuggestion}, "\n")) {
		return 100, dispatchRuleLabel(rule, "问题关键词")
	}
	return 0, ""
}

func dispatchRuleLabel(rule AfterSalesDispatchRule, kind string) string {
	name := strings.TrimSpace(rule.Name)
	if name == "" {
		name = strings.TrimSpace(rule.ID)
	}
	if name == "" {
		return kind
	}
	return kind + ": " + name
}

func containsAnyNormalized(items []string, value string) bool {
	value = strings.TrimSpace(value)
	if value == "" {
		return false
	}
	for _, item := range items {
		if strings.TrimSpace(item) == value {
			return true
		}
	}
	return false
}

func containsAnyText(needles []string, haystack string) bool {
	haystack = strings.ToLower(strings.TrimSpace(haystack))
	if haystack == "" {
		return false
	}
	for _, needle := range needles {
		needle = strings.ToLower(strings.TrimSpace(needle))
		if needle != "" && strings.Contains(haystack, needle) {
			return true
		}
	}
	return false
}

func dispatchEngineerName(userID string, fallback string, cfg AfterSalesDispatchConfig) string {
	userID = strings.TrimSpace(userID)
	for _, engineer := range cfg.Engineers {
		if strings.TrimSpace(engineer.UserID) == userID && strings.TrimSpace(engineer.Name) != "" {
			return strings.TrimSpace(engineer.Name)
		}
	}
	return strings.TrimSpace(fallback)
}

func (e *AfterSalesIssueEngine) assignEngineer(issueID string, engineerID string) error {
	cfg, err := readAfterSalesDispatchConfig()
	if err != nil {
		return err
	}
	issueID = strings.TrimSpace(issueID)
	engineerID = strings.TrimSpace(engineerID)
	if issueID == "" {
		return fmt.Errorf("issueId为空")
	}
	e.mu.Lock()
	defer e.mu.Unlock()
	for i := range e.issues {
		if e.issues[i].ID != issueID {
			continue
		}
		e.issues[i].AssignedEngineerID = engineerID
		e.issues[i].AssignedEngineerName = dispatchEngineerName(engineerID, "", cfg)
		e.issues[i].DispatchRuleID = ""
		if engineerID == "" {
			e.issues[i].DispatchStatus = afterSalesDispatchUnassigned
			e.issues[i].DispatchReason = ""
			e.issues[i].DispatchConfidence = 0
			e.issues[i].DispatchSource = ""
		} else {
			e.issues[i].DispatchStatus = afterSalesDispatchAssigned
			e.issues[i].DispatchReason = "人工指定"
			e.issues[i].DispatchConfidence = 1
			e.issues[i].DispatchSource = dispatchSourceManual
		}
		e.issues[i].UpdatedAt = time.Now().Local().Format(time.RFC3339)
		normalizeAfterSalesDispatchFields(&e.issues[i])
		return e.saveIssuesLocked()
	}
	return fmt.Errorf("问题不存在")
}

func (e *AfterSalesIssueEngine) notifyEngineer(issueID string) AfterSalesNotifyResult {
	cfg, err := readAfterSalesDispatchConfig()
	if err != nil {
		return AfterSalesNotifyResult{IssueID: issueID, Success: false, Message: err.Error()}
	}
	issueID = strings.TrimSpace(issueID)
	if issueID == "" {
		return AfterSalesNotifyResult{IssueID: issueID, Success: false, Message: "issueId为空"}
	}
	var issue AfterSalesIssue
	e.mu.Lock()
	index := -1
	for i := range e.issues {
		if e.issues[i].ID == issueID {
			index = i
			issue = e.issues[i]
			break
		}
	}
	if index < 0 {
		e.mu.Unlock()
		return AfterSalesNotifyResult{IssueID: issueID, Success: false, Message: "问题不存在"}
	}
	normalizeAfterSalesDispatchFields(&issue)
	if issue.Status != afterSalesIssueStatusPending {
		e.mu.Unlock()
		return AfterSalesNotifyResult{IssueID: issueID, Success: false, Message: "问题已处理或非待处理，不能通知"}
	}
	if strings.TrimSpace(issue.AssignedEngineerID) == "" {
		e.issues[index].NotifyStatus = afterSalesNotifyFailed
		e.issues[index].NotifyError = "未分配工程师"
		e.issues[index].UpdatedAt = time.Now().Local().Format(time.RFC3339)
		_ = e.saveIssuesLocked()
		e.mu.Unlock()
		return AfterSalesNotifyResult{IssueID: issueID, Success: false, Message: "未分配工程师"}
	}
	if issue.NotifyStatus == afterSalesNotifySent && issue.LastNotifiedAt > 0 && cfg.NotifyCooldownSeconds > 0 {
		if time.Since(time.Unix(issue.LastNotifiedAt, 0)) < time.Duration(cfg.NotifyCooldownSeconds)*time.Second {
			e.mu.Unlock()
			return AfterSalesNotifyResult{IssueID: issueID, Success: false, Message: "已通知过，冷却时间内不重复推送"}
		}
	}
	e.mu.Unlock()

	clientID, conversationID, err := resolveEngineerConversation(issue.AssignedEngineerID)
	if err == nil {
		err = sendAutoReplyText(clientID, conversationID, renderAfterSalesDispatchNotification(issue, cfg))
	}

	e.mu.Lock()
	defer e.mu.Unlock()
	for i := range e.issues {
		if e.issues[i].ID != issueID {
			continue
		}
		e.issues[i].NotifyCount++
		e.issues[i].UpdatedAt = time.Now().Local().Format(time.RFC3339)
		if err != nil {
			e.issues[i].NotifyStatus = afterSalesNotifyFailed
			e.issues[i].NotifyError = err.Error()
			_ = e.saveIssuesLocked()
			return AfterSalesNotifyResult{IssueID: issueID, Success: false, Message: err.Error()}
		}
		e.issues[i].NotifyStatus = afterSalesNotifySent
		e.issues[i].NotifyError = ""
		e.issues[i].LastNotifiedAt = time.Now().Unix()
		_ = e.saveIssuesLocked()
		return AfterSalesNotifyResult{IssueID: issueID, Success: true, Message: "sent"}
	}
	return AfterSalesNotifyResult{IssueID: issueID, Success: false, Message: "问题不存在"}
}

func (e *AfterSalesIssueEngine) batchNotifyEngineers(issueIDs []string) map[string]interface{} {
	if len(uniqueNonEmptyStrings(issueIDs)) == 0 {
		issueIDs = e.notifyAllAssignedPendingIDs()
	}
	results := make([]AfterSalesNotifyResult, 0, len(issueIDs))
	successCount := 0
	for _, issueID := range uniqueNonEmptyStrings(issueIDs) {
		result := e.notifyEngineer(issueID)
		if result.Success {
			successCount++
		}
		results = append(results, result)
	}
	return map[string]interface{}{
		"success": successCount == len(results),
		"message": fmt.Sprintf("已成功推送 %d/%d 条", successCount, len(results)),
		"data": map[string]interface{}{
			"successCount": successCount,
			"totalCount":   len(results),
			"results":      results,
		},
	}
}

func (e *AfterSalesIssueEngine) notifyAllAssignedPendingIDs() []string {
	e.mu.Lock()
	defer e.mu.Unlock()
	result := make([]string, 0)
	for _, issue := range e.issues {
		if issue.Status != afterSalesIssueStatusPending {
			continue
		}
		if strings.TrimSpace(issue.AssignedEngineerID) == "" {
			continue
		}
		if normalizeAfterSalesNotifyStatus(issue.NotifyStatus) != afterSalesNotifyNotSent {
			continue
		}
		result = append(result, issue.ID)
	}
	return result
}

func resolveEngineerConversation(engineerID string) (uint32, string, error) {
	engineerID = strings.TrimSpace(engineerID)
	if engineerID == "" {
		return 0, "", fmt.Errorf("工程师 userId 为空")
	}
	clientIDs := identityRefreshClientIDs()
	if len(clientIDs) == 0 {
		return 0, "", fmt.Errorf("没有活跃企微账号，无法发送通知")
	}
	for _, clientID := range clientIDs {
		robotID := strings.TrimSpace(getClientUserID(clientID))
		if robotID == "" {
			continue
		}
		if strings.HasPrefix(engineerID, "S:") {
			return clientID, engineerID, nil
		}
		return clientID, fmt.Sprintf("S:%s_%s", robotID, engineerID), nil
	}
	return 0, "", fmt.Errorf("无法推导工程师私信会话，缺少当前接管账号ID")
}

func renderAfterSalesDispatchNotification(issue AfterSalesIssue, cfg AfterSalesDispatchConfig) string {
	template := strings.TrimSpace(cfg.NotifyTemplate)
	if template == "" {
		template = defaultAfterSalesDispatchTemplate()
	}
	replacements := map[string]string{
		"{issueId}":        issue.ID,
		"{roomName}":       fallbackString(issue.RoomName, issue.ConversationID),
		"{customerName}":   normalizeAfterSalesDisplayName(issue.CustomerName),
		"{issueContent}":   strings.TrimSpace(issue.IssueContent),
		"{aiSuggestion}":   strings.TrimSpace(issue.AISuggestion),
		"{createdAt}":      formatDispatchIssueTime(issue.CreatedAt),
		"{engineerName}":   fallbackString(issue.AssignedEngineerName, issue.AssignedEngineerID),
		"{engineerUserId}": issue.AssignedEngineerID,
		"{imageCount}":     fmt.Sprintf("%d", len(issue.ImagePaths)+len(issue.ImageRefs)),
		"{dispatchReason}": issue.DispatchReason,
	}
	for key, value := range replacements {
		template = strings.ReplaceAll(template, key, value)
	}
	return template
}

func defaultAfterSalesDispatchTemplate() string {
	return "【售后问题待处理】\n" +
		"客户/群聊：{customerName} / {roomName}\n" +
		"提出时间：{createdAt}\n" +
		"问题ID：{issueId}\n" +
		"匹配原因：{dispatchReason}\n\n" +
		"问题描述：\n{issueContent}\n\n" +
		"AI建议：\n{aiSuggestion}\n\n" +
		"相关图片：{imageCount} 张"
}

func formatDispatchIssueTime(value string) string {
	value = strings.TrimSpace(value)
	if value == "" {
		return ""
	}
	if t, err := time.Parse(time.RFC3339, value); err == nil {
		return t.Local().Format("2006-01-02 15:04")
	}
	return value
}