package message

import (
	"context"

	"gitlab.fjmaimaimai.com/allied-creation/sumifcc-discuss/cmd/discuss/api/internal/svc"
	"gitlab.fjmaimaimai.com/allied-creation/sumifcc-discuss/cmd/discuss/api/internal/types"
	"gitlab.fjmaimaimai.com/allied-creation/sumifcc-discuss/cmd/discuss/interanl/pkg/db/transaction"
	"gitlab.fjmaimaimai.com/allied-creation/sumifcc-discuss/cmd/discuss/interanl/pkg/domain"
	"gitlab.fjmaimaimai.com/allied-creation/sumifcc-discuss/pkg/contextdata"

	"github.com/zeromicro/go-zero/core/logx"
)

type MiniBusinessLogic struct {
	logx.Logger
	ctx    context.Context
	svcCtx *svc.ServiceContext
}

func NewMiniBusinessLogic(ctx context.Context, svcCtx *svc.ServiceContext) *MiniBusinessLogic {
	return &MiniBusinessLogic{
		Logger: logx.WithContext(ctx),
		ctx:    ctx,
		svcCtx: svcCtx,
	}
}

func (l *MiniBusinessLogic) MiniBusiness(req *types.MessageBusinessRequest) (resp *types.MessageBusinessResponse, err error) {
	var msgType = req.Type

	total, list, err := l.svcCtx.MessageBusinessRepository.Find(l.ctx, l.svcCtx.DefaultDBConn(), domain.NewQueryOptions().
		WithOffsetLimit(req.Page, req.Size).
		WithKV("type", msgType))
	if err != nil {
		return nil, err
	}
	// 输出
	resp = &types.MessageBusinessResponse{}
	resp.Total = total
	resp.List = make([]types.MessageBusinessItem, 0)
	if total == 0 {
		return resp, nil
	}

	var companyIdMap = map[int64]*domain.Company{}
	var userIdMap = map[int64]*domain.User{}
	var articleIdMap = map[int64]*domain.Article{}
	var commentIdMap = map[int64]*domain.Comment{}
	//var discussionIdMap = map[int64]int{}
	//var discussionOpinionIdMap = map[int64]int{}
	for _, item := range list {
		if item.CompanyId != 0 {
			companyIdMap[item.CompanyId] = nil
		}
		if item.UserId != 0 {
			userIdMap[item.UserId] = nil
		}
		if item.ArticleId != 0 {
			articleIdMap[item.ArticleId] = nil
		}
		if item.CommentId != 0 {
			commentIdMap[item.CommentId] = nil
		}
		//if item.DiscussionId != 0 {
		//	discussionIdMap[item.DiscussionId] = 0
		//}
		//if item.DiscussionOpinionId != 0 {
		//	discussionOpinionIdMap[item.DiscussionOpinionId] = 0
		//}
	}
	var companyIds = make([]int64, 0) // 公司ID
	var userIds = make([]int64, 0)    // 用户ID
	var articleIds = make([]int64, 0) // 文章ID
	var commentIds = make([]int64, 0) // 评论ID
	//var discussionIds = make([]int64, 0)        // 讨论ID 暂时搁置
	//var discussionOpinionIds = make([]int64, 0) // 观点ID
	for k, _ := range companyIdMap {
		companyIds = append(companyIds, k)
	}
	for k, _ := range userIdMap {
		userIds = append(userIds, k)
	}
	for k, _ := range articleIdMap {
		articleIds = append(articleIds, k)
	}
	for k, _ := range commentIdMap {
		commentIds = append(commentIds, k)
	}
	//for k, _ := range discussionIdMap {
	//	discussionIds = append(discussionIds, k)
	//}
	//for k, _ := range discussionOpinionIdMap {
	//	discussionOpinionIds = append(discussionOpinionIds, k)
	//}

	// 获取公司
	if len(companyIds) > 0 {
		_, companyList, err := l.svcCtx.CompanyRepository.Find(l.ctx, l.svcCtx.DefaultDBConn(),
			domain.NewQueryOptions().
				WithFindOnly().
				WithKV("ids", userIds).
				WithKV("limit", len(userIds)))
		if err != nil {
			return nil, err
		}
		for i := range companyList {
			companyIdMap[companyList[i].Id] = companyList[i]
		}
	}

	// 获取用户
	if len(userIds) > 0 {
		_, userList, err := l.svcCtx.UserRepository.Find(l.ctx, l.svcCtx.DefaultDBConn(),
			domain.NewQueryOptions().
				WithFindOnly().
				WithKV("ids", userIds).
				WithKV("limit", len(userIds)))
		if err != nil {
			return nil, err
		}
		for i := range userList {
			userIdMap[userList[i].Id] = userList[i]
		}
	}

	// 获取评论
	if len(commentIds) > 0 {
		_, commentList, err := l.svcCtx.CommentRepository.Find(l.ctx, l.svcCtx.DefaultDBConn(),
			domain.NewQueryOptions().
				WithFindOnly().
				WithKV("ids", commentIds).
				WithKV("limit", len(commentIds)))
		if err != nil {
			return nil, err
		}
		for i := range commentList {
			commentIdMap[commentList[i].Id] = commentList[i]
		}
	}

	// 获取文章数据
	if len(articleIds) > 0 {
		_, articleList, err := l.svcCtx.ArticleRepository.Find(l.ctx, l.svcCtx.DefaultDBConn(), 0,
			domain.NewQueryOptions().
				WithFindOnly().
				WithKV("ids", articleIds).
				WithKV("limit", len(articleIds)))
		if err != nil {
			return nil, err
		}
		for i := range articleList {
			articleIdMap[articleList[i].Id] = articleList[i]
		}
	}

	for _, item := range list {
		to := types.MessageBusinessItem{
			Id:                  item.Id,
			Type:                int(item.Type),
			OptType:             int(item.OptType),
			CompanyId:           item.CompanyId,
			UserId:              item.UserId,
			RecipientId:         item.RecipientId,
			ArticleId:           item.ArticleId,
			CommentId:           item.CommentId,
			DiscussionId:        item.DiscussionId,
			DiscussionOpinionId: item.DiscussionOpinionId,
			Content:             item.Content,
			CreatedAt:           item.CreatedAt,
		}

		if v, ok := userIdMap[item.UserId]; ok {
			to.User = &types.User{
				Id:        v.Id,
				CompanyId: v.CompanyId,
				Position:  v.Position,
				Name:      v.Name,
				Avatar:    v.Avatar,
			}

			if v, ok := companyIdMap[item.CompanyId]; ok {
				to.User.CompanyName = v.Name
			}
		}

		if v, ok := articleIdMap[item.ArticleId]; ok {
			to.Article = &types.SimpleArticle{
				Id:           v.Id,
				Title:        v.Title,
				CountLove:    v.CountLove,
				CountComment: v.CountComment,
			}
		}

		if _, ok := commentIdMap[item.CommentId]; ok {
			to.Comment = &types.Comment{
				//Id:           v.Id,
				//Title:        v.Title,
				//CountLove:    v.CountLove,
				//CountComment: v.CountComment,
			}
		}

		resp.List = append(resp.List, to)
	}
	return resp, nil
}

// CommentArticle 评论文章
func (l *MiniBusinessLogic) CommentArticle(conn transaction.Conn, articleId int64, content string, at []int64) (err error) {
	return l.submit(conn, domain.MsgTypeReply, domain.OptTypeArticle, articleId, 0, content, at)
}

// CommentReply 评论回复
func (l *MiniBusinessLogic) CommentReply(conn transaction.Conn, articleId int64, commentId int64, content string, at []int64) (err error) {
	return l.submit(conn, domain.MsgTypeReply, domain.OptTypeComment, articleId, commentId, content, at)
}

// LikeArticle 点赞文章
func (l *MiniBusinessLogic) LikeArticle(conn transaction.Conn, articleId int64, at int64) (err error) {
	return l.submit(conn, domain.MsgTypeLike, domain.OptTypeArticle, articleId, 0, "", []int64{at})
}

// LikeComment 点赞评论
func (l *MiniBusinessLogic) LikeComment(conn transaction.Conn, articleId int64, commentId int64, at int64) (err error) {
	return l.submit(conn, domain.MsgTypeLike, domain.OptTypeComment, articleId, commentId, "", []int64{at})
}

func (l *MiniBusinessLogic) submit(
	conn transaction.Conn,
	msgType domain.MsgBusinessType,
	optType domain.MsgBusinessOpt,
	articleId int64,
	commentId int64,
	content string,
	at []int64) (err error) {

	var userToken = contextdata.GetUserTokenFromCtx(l.ctx)
	// 评论中携带了 @其他用户
	for i := range at {
		var msg = &domain.MessageBusiness{
			Type:        msgType,
			OptType:     optType,
			CompanyId:   userToken.CompanyId,
			UserId:      userToken.UserId,
			RecipientId: at[i],
			ArticleId:   articleId,
			CommentId:   commentId,
			Content:     content,
		}
		msg, err = l.svcCtx.MessageBusinessRepository.Insert(l.ctx, conn, msg)
		if err != nil {
			return err
		}
	}
	return nil
}