package biz

import (
	"ai_scheduler/internal/biz/llm_service/third_party"
	"ai_scheduler/internal/config"
	"ai_scheduler/internal/data/constants"
	"ai_scheduler/internal/data/impl"
	"ai_scheduler/internal/data/mongo_model"
	"ai_scheduler/internal/entitys"
	"ai_scheduler/internal/pkg"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"strings"
	"time"

	"github.com/sashabaranov/go-openai"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo/options"
)

// AdviceIterateBiz 对话完成自我迭代
// 销售与客户的对话结束（最后一条消息超过 dialog_idle_minutes，默认 30 分钟）后，
// 将本轮聊天记录交给 LLM 再次分析，提取新信息并新建/完善客户画像。
type AdviceIterateBiz struct {
	cfg          *config.Config
	openai       *third_party.OpenAi
	mongo        *pkg.Mongo
	clientBiz    *AdviceClientBiz
	wxMsgMongo   *mongo_model.AdvicerWxMsgMongo
	projectImpl  *impl.AdviceProjectImpl
	modelSupImpl *impl.AiAdviceModelSupImpl
	customerImpl *impl.AdviceCustomerImpl
	advicerBiz   *AdviceAdvicerBiz
	followBiz    *AdviceFollowBiz
}

func NewAdviceIterateBiz(
	cfg *config.Config,
	openai *third_party.OpenAi,
	mongo *pkg.Mongo,
	clientBiz *AdviceClientBiz,
	wxMsgMongo *mongo_model.AdvicerWxMsgMongo,
	projectImpl *impl.AdviceProjectImpl,
	modelSupImpl *impl.AiAdviceModelSupImpl,
	customerImpl *impl.AdviceCustomerImpl,
	advicerBiz *AdviceAdvicerBiz,
	followBiz *AdviceFollowBiz,
) *AdviceIterateBiz {
	return &AdviceIterateBiz{
		cfg:          cfg,
		openai:       openai,
		mongo:        mongo,
		clientBiz:    clientBiz,
		wxMsgMongo:   wxMsgMongo,
		projectImpl:  projectImpl,
		modelSupImpl: modelSupImpl,
		customerImpl: customerImpl,
		advicerBiz:   advicerBiz,
		followBiz:    followBiz,
	}
}

// Run 执行画像迭代：扫描未分析消息 → 按客户分组 → 对话完成判定 → LLM 提取增量 → 合并画像 → 标记已分析。
// Force=true 忽略对话完成（闲置时长）等待，立即迭代（手动触发用）。
func (a *AdviceIterateBiz) Run(ctx context.Context, param *entitys.AdvicerIterateRunReq) (res *entitys.AdvicerIterateRunRes, err error) {
	res = &entitys.AdvicerIterateRunRes{Details: []string{}}
	if param == nil {
		param = &entitys.AdvicerIterateRunReq{}
	}

	// 1. 扫描未分析消息（时间正序，单轮上限 500 条）
	filter := bson.M{"analyzed": false}
	if len(param.ClientId) != 0 {
		client, e := a.clientBiz.Info(ctx, &entitys.AdvicerClientInfoReq{Id: param.ClientId})
		if e != nil {
			return res, fmt.Errorf("客户不存在: %w", e)
		}
		if len(client.Wxid) == 0 {
			return res, errors.New("该客户未绑定微信 wxid，无聊天记录可迭代")
		}
		filter["wxid"] = client.Wxid
	}
	cursor, e := a.mongo.Co(a.wxMsgMongo).Find(ctx, filter,
		options.Find().SetSort(bson.D{{Key: "createAt", Value: 1}}).SetLimit(500))
	if e != nil {
		return res, e
	}
	var msgs []mongo_model.AdvicerWxMsgItem
	for cursor.Next(ctx) {
		var item mongo_model.AdvicerWxMsgItem
		if e = cursor.Decode(&item); e != nil {
			return res, e
		}
		msgs = append(msgs, item)
	}
	if e = cursor.Err(); e != nil {
		return res, e
	}
	res.Scanned = len(msgs)
	if len(msgs) == 0 {
		return res, nil
	}

	// 2. 按客户 wxid 分组（保持时间顺序）
	group := map[string][]mongo_model.AdvicerWxMsgItem{}
	var order []string
	for _, m := range msgs {
		if len(m.Wxid) == 0 {
			continue
		}
		if _, ok := group[m.Wxid]; !ok {
			order = append(order, m.Wxid)
		}
		group[m.Wxid] = append(group[m.Wxid], m)
	}

	idle := time.Duration(a.idleMinutes()) * time.Minute
	for _, wxid := range order {
		items := group[wxid]
		// 2.1 客户绑定校验（未绑定客户不标记，待绑定后再迭代）
		client, found, e := a.clientBiz.FindByWxid(ctx, wxid)
		if e != nil || !found {
			continue
		}
		// 2.2 对话完成判定：最新一条消息（任意方向）距现在超过闲置时长
		if !param.Force {
			latest := a.latestMsgTime(ctx, wxid)
			if latest.IsZero() || time.Since(latest) < idle {
				res.Idle++
				continue
			}
		}
		// 2.3 LLM 分析并合并画像
		summary, updated, e := a.iterateClient(ctx, &client, items)
		// 2.4 标记本轮消息已分析（无论画像是否有增量，避免重复分析）
		ids := make([]primitive.ObjectID, 0, len(items))
		for _, m := range items {
			ids = append(ids, m.Id)
		}
		_, _ = a.mongo.Co(a.wxMsgMongo).UpdateMany(ctx,
			bson.M{"_id": bson.M{"$in": ids}},
			bson.M{"$set": bson.M{"analyzed": true}})

		if e != nil {
			res.Details = append(res.Details, fmt.Sprintf("%s：迭代失败 %v", clientName(&client), e))
			continue
		}
		if updated {
			res.Updated++
			text := clientName(&client) + "：画像已更新"
			if strings.TrimSpace(summary) != "" {
				text += "（" + strings.TrimSpace(summary) + "）"
			}
			res.Details = append(res.Details, text)
		} else {
			res.Details = append(res.Details, clientName(&client)+"：本轮无新增画像信息")
		}
	}
	return res, nil
}

// iterateClient 对单客户执行画像迭代：LLM 提取增量 → 合并画像 → 更新 lastIterateAt
func (a *AdviceIterateBiz) iterateClient(ctx context.Context, c *mongo_model.AdvicerClientItem, newMsgs []mongo_model.AdvicerWxMsgItem) (summary string, updated bool, err error) {
	_, model := projectModelOf(ctx, a.projectImpl, a.modelSupImpl, c.ProjectId)
	if model == nil {
		return "", false, errors.New("项目未配置可用模型（请检查 modelSupId）")
	}
	history := a.recentMsgs(ctx, c.Wxid, 30)
	manual, wxRemark := a.fetchRemarks(ctx, c)
	content := buildIterateUserContent(c, history, newMsgs, manual, wxRemark)
	messages := []openai.ResponseInputMessage{
		{Role: openai.ChatMessageRoleSystem, Content: constants.ClientIteratePrompt},
		{Role: openai.ChatMessageRoleUser, Content: content},
	}
	resp, err := a.openai.CreateResponseMessages(ctx, model.Key, model.URL, model.ChatModel, messages, "")
	if err != nil {
		return "", false, fmt.Errorf("分析聊天记录失败: %w", err)
	}
	var patch iteratePatch
	if err = json.Unmarshal([]byte(extractJsonObject(resp.GetOutputText())), &patch); err != nil {
		return "", false, fmt.Errorf("解析迭代结果失败: %w", err)
	}

	// 合并动态栏目（增量：以现有画像为基底，LLM 输出逐个覆盖非空栏目）
	updated, err = a.applyIterateSections(ctx, c, patch.Sections, false)
	if err != nil {
		return "", false, err
	}
	return strings.TrimSpace(patch.Summary), updated, nil
}

// applyIterateSections 把 LLM 输出的栏目合并/替换进画像并落库。
// replace=true 为全量替换（「画像更新」按钮），false 为增量合并（定时迭代）。
func (a *AdviceIterateBiz) applyIterateSections(ctx context.Context, c *mongo_model.AdvicerClientItem, sections map[string]interface{}, replace bool) (updated bool, err error) {
	merged := map[string]interface{}{}
	if !replace {
		for k, v := range c.Profile {
			merged[k] = v
		}
	}
	for k, v := range sections {
		name := strings.TrimSpace(k)
		if name == "" || isEmptySection(v) {
			continue
		}
		merged[name] = v
	}
	now := time.Now()
	set := bson.M{"lastIterateAt": now}
	if pkg.JsonStringIgonErr(merged) != pkg.JsonStringIgonErr(c.Profile) {
		set["profile"] = merged
		set["lastUpdateTime"] = now
		updated = true
	}
	_, err = a.mongo.Co(a.clientBiz.AdvicerClientMongo).UpdateOne(ctx, bson.M{"_id": c.Id}, bson.M{"$set": set})
	return
}

// isEmptySection 判断栏目值是否为空（空串/空数组/空对象/nil）。
func isEmptySection(v interface{}) bool {
	switch x := v.(type) {
	case nil:
		return true
	case string:
		return strings.TrimSpace(x) == ""
	case []interface{}:
		return len(x) == 0
	case map[string]interface{}:
		return len(x) == 0
	}
	return false
}

// fetchRemarks 取客户备注：人工备注(description) + 微信备注名(remark)，均存于 MySQL ai_advice_customer。
// 靠 appId 反查销售 self_wxid，再按 (self_wxid, 客户wxid) 定位客户记录；查不到返回空串不报错。
func (a *AdviceIterateBiz) fetchRemarks(ctx context.Context, c *mongo_model.AdvicerClientItem) (manual, wxRemark string) {
	if a.customerImpl == nil || a.advicerBiz == nil || c == nil || len(c.AppId) == 0 || len(c.Wxid) == 0 {
		return "", ""
	}
	adv, e := a.advicerBiz.FindByWxDeviceId(ctx, c.AppId)
	if e != nil || len(adv.WxId) == 0 {
		return "", ""
	}
	cust, e := a.customerImpl.FindBySelfWxidAndUserName(ctx, adv.WxId, c.Wxid)
	if e != nil {
		return "", ""
	}
	return strings.TrimSpace(cust.Description), strings.TrimSpace(cust.Remark)
}

// idleMinutes 对话完成闲置时长（分钟，默认 30）
func (a *AdviceIterateBiz) idleMinutes() int {
	d := a.cfg.Advicer.DialogIdleMinutes
	if d <= 0 {
		d = 30
	}
	return d
}

// latestMsgTime 客户最新一条消息时间（任意方向）
func (a *AdviceIterateBiz) latestMsgTime(ctx context.Context, wxid string) time.Time {
	res := a.mongo.Co(a.wxMsgMongo).FindOne(ctx, bson.M{"wxid": wxid},
		options.FindOne().SetSort(bson.D{{Key: "createAt", Value: -1}}))
	if res.Err() != nil {
		return time.Time{}
	}
	var m mongo_model.AdvicerWxMsgMongo
	if err := res.Decode(&m); err != nil {
		return time.Time{}
	}
	return m.CreateAt
}

// recentMsgs 拉取客户最近聊天记录（时间正序返回）
func (a *AdviceIterateBiz) recentMsgs(ctx context.Context, wxid string, limit int64) (list []mongo_model.AdvicerWxMsgMongo) {
	if len(wxid) == 0 {
		return nil
	}
	cursor, err := a.mongo.Co(a.wxMsgMongo).Find(ctx, bson.M{"wxid": wxid},
		options.Find().SetSort(bson.D{{Key: "createAt", Value: -1}}).SetLimit(limit))
	if err != nil {
		return nil
	}
	for cursor.Next(ctx) {
		var m mongo_model.AdvicerWxMsgMongo
		if err := cursor.Decode(&m); err != nil {
			return nil
		}
		list = append(list, m)
	}
	for i, j := 0, len(list)-1; i < j; i, j = i+1, j-1 {
		list[i], list[j] = list[j], list[i]
	}
	return list
}

// ==================== 迭代辅助类型与函数 ====================

// iteratePatch 画像迭代/生成结果（sections = 栏目名→内容；summary = 本次说明）
type iteratePatch struct {
	Sections map[string]interface{} `json:"sections"`
	Summary  string                 `json:"summary"`
}

// RegenerateProfile 画像更新：基于客户旧画像（可能没有）+ 聊天记录重新生成全量动态栏目。
// clientId 优先；否则按 wxid（托管客户）定位/自动建档。忽略 analyzed 标记、不回写，与定时迭代互不干扰。
func (a *AdviceIterateBiz) RegenerateProfile(ctx context.Context, param *entitys.AdvicerProfileRegenerateReq) (res *entitys.AdvicerIterateRunRes, err error) {
	res = &entitys.AdvicerIterateRunRes{Details: []string{}}
	if param == nil || (len(param.ClientId) == 0 && len(param.Wxid) == 0) {
		return res, errors.New("请指定客户（clientId 或 wxid）")
	}

	var c *mongo_model.AdvicerClientItem
	if len(param.ClientId) != 0 {
		info, e := a.clientBiz.Info(ctx, &entitys.AdvicerClientInfoReq{Id: param.ClientId})
		if e != nil {
			return res, fmt.Errorf("客户不存在: %w", e)
		}
		objID, e := primitive.ObjectIDFromHex(param.ClientId)
		if e != nil {
			return res, e
		}
		c = &mongo_model.AdvicerClientItem{Id: objID, AdvicerClientMongo: info}
	} else {
		advicerId := int32(0)
		if len(param.AppId) != 0 {
			if adv, e := a.advicerBiz.FindByWxDeviceId(ctx, param.AppId); e == nil {
				advicerId = adv.AdvicerID
			}
		}
		item, _, e := a.clientBiz.EnsureByWxid(ctx, param.Wxid, param.ProjectId, advicerId, param.AppId)
		if e != nil {
			return res, fmt.Errorf("客户解析失败: %w", e)
		}
		c = item
	}
	if len(c.Wxid) == 0 {
		return res, errors.New("该客户未绑定微信 wxid，无聊天记录可生成画像")
	}

	msgs := a.recentMsgs(ctx, c.Wxid, 200)
	if len(msgs) == 0 {
		res.Details = append(res.Details, clientNameOf(c)+"：暂无聊天记录，未生成画像")
		return res, nil
	}
	res.Scanned = len(msgs)

	_, model := projectModelOf(ctx, a.projectImpl, a.modelSupImpl, c.ProjectId)
	if model == nil {
		return res, errors.New("项目未配置可用模型（请检查 modelSupId）")
	}
	manual, wxRemark := a.fetchRemarks(ctx, c)
	content := buildRegenerateUserContent(c, msgs, manual, wxRemark)
	messages := []openai.ResponseInputMessage{
		{Role: openai.ChatMessageRoleSystem, Content: constants.ClientIteratePrompt},
		{Role: openai.ChatMessageRoleUser, Content: content},
	}
	resp, err := a.openai.CreateResponseMessages(ctx, model.Key, model.URL, model.ChatModel, messages, "")
	if err != nil {
		return res, fmt.Errorf("分析聊天记录失败: %w", err)
	}
	var patch iteratePatch
	if err = json.Unmarshal([]byte(extractJsonObject(resp.GetOutputText())), &patch); err != nil {
		return res, fmt.Errorf("解析画像结果失败: %w", err)
	}
	updated, err := a.applyIterateSections(ctx, c, patch.Sections, true)
	if err != nil {
		return res, err
	}
	if updated {
		res.Updated++
		text := clientNameOf(c) + "：画像已更新"
		if s := strings.TrimSpace(patch.Summary); s != "" {
			text += "（" + s + "）"
		}
		res.Details = append(res.Details, text)
	} else {
		res.Details = append(res.Details, clientNameOf(c)+"：未能从聊天记录中提取到画像信息")
	}
	return res, nil
}

// clientNameOf 客户显示名（画像「姓名」栏目优先，其次截断 wxid），供迭代/生成结果描述使用。
func clientNameOf(c *mongo_model.AdvicerClientItem) string {
	if n := strings.TrimSpace(c.SectionString(mongo_model.SectionKeyClientName)); n != "" {
		return n
	}
	if len(c.Wxid) > 10 {
		return c.Wxid[:10] + "..."
	}
	return c.Wxid
}

// buildRegenerateUserContent 组装画像更新输入（现有画像 + 客户备注 + 全量聊天记录）
func buildRegenerateUserContent(c *mongo_model.AdvicerClientItem, msgs []mongo_model.AdvicerWxMsgMongo, manual, wxRemark string) string {
	var b strings.Builder
	b.WriteString("[客户现有画像]\n")
	b.WriteString(pkg.JsonStringIgonErr(c.Entity()))
	if manual != "" {
		b.WriteString("\n[人工备注]" + manual)
	}
	if wxRemark != "" {
		b.WriteString("\n[微信备注名]" + wxRemark)
	}
	b.WriteString("\n\n[需要分析的聊天记录（按时间先后）]\n")
	for i := range msgs {
		b.WriteString(formatIterateMsg(&msgs[i]))
	}
	return b.String()
}

// buildIterateUserContent 组装迭代输入（现有画像 + 客户备注 + 本轮新增对话 + 更早上下文）
func buildIterateUserContent(c *mongo_model.AdvicerClientItem, history []mongo_model.AdvicerWxMsgMongo, newMsgs []mongo_model.AdvicerWxMsgItem, manual, wxRemark string) string {
	var b strings.Builder
	b.WriteString("[客户现有画像]\n")
	b.WriteString(pkg.JsonStringIgonErr(c.Entity()))
	if manual != "" {
		b.WriteString("\n[人工备注]" + manual)
	}
	if wxRemark != "" {
		b.WriteString("\n[微信备注名]" + wxRemark)
	}
	b.WriteString("\n\n[本轮需要分析的聊天记录（按时间先后）]\n")
	if len(newMsgs) == 0 {
		b.WriteString("（无）\n")
	}
	for i := range newMsgs {
		b.WriteString(formatIterateMsg(&newMsgs[i].AdvicerWxMsgMongo))
	}
	// 更早的上下文（仅帮助理解语境）
	if len(newMsgs) > 0 {
		earliest := newMsgs[0].CreateAt
		var ctxBuilder strings.Builder
		for i := range history {
			if history[i].CreateAt.Before(earliest) {
				ctxBuilder.WriteString(formatIterateMsg(&history[i]))
			}
		}
		if ctxBuilder.Len() > 0 {
			b.WriteString("\n[更早的聊天记录（仅供理解上下文，无需重复提取）]\n")
			b.WriteString(ctxBuilder.String())
		}
	}
	return b.String()
}

// formatIterateMsg 单条消息格式化（带时间）
func formatIterateMsg(m *mongo_model.AdvicerWxMsgMongo) string {
	who := "客户"
	if m.Direction != mongo_model.WxMsgDirectionCustomer {
		who = "我"
	}
	content := m.Content
	if m.MsgType != mongo_model.WxMsgTypeText {
		content = "[" + m.MsgType + "消息] " + content
	}
	return fmt.Sprintf("[%s] %s：%s\n", m.CreateAt.Format("01-02 15:04"), who, content)
}

// mergeUnique 追加去重（保留原有顺序）
func mergeUnique(old []string, add []string) []string {
	seen := map[string]bool{}
	for _, s := range old {
		seen[strings.TrimSpace(s)] = true
	}
	merged := append([]string{}, old...)
	for _, s := range add {
		s = strings.TrimSpace(s)
		if s == "" || seen[s] {
			continue
		}
		seen[s] = true
		merged = append(merged, s)
	}
	return merged
}