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.MessageRequest, msgType domain.MsgBusinessType) (resp *types.MessageBusinessResponse, err error) {
	var userToken = contextdata.GetUserTokenFromCtx(l.ctx)
	var conn = l.svcCtx.DefaultDBConn()

	total, list, err := l.svcCtx.MessageBusinessRepository.Find(l.ctx, conn, domain.NewQueryOptions().
		WithOffsetLimit(req.Page, req.Size).
		WithKV("type", msgType).
		WithKV("companyId", userToken.CompanyId).
		WithKV("recipientId", userToken.UserId))
	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.ArticleComment{}
	//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, conn, domain.NewQueryOptions().
			WithFindOnly().
			WithKV("ids", companyIds).
			WithKV("limit", len(companyIds)))
		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, conn, 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.ArticleCommentRepository.Find(l.ctx, conn, 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, conn, userToken.CompanyId, 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.SimpleUser{
				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,
				Show:         int(v.Show),
			}
		}

		if v, ok := commentIdMap[item.CommentId]; ok {
			to.Comment = &types.SimpleComment{
				Id:           v.Id,
				Content:      v.Content,
				CountLove:    v.CountUserLove,
				CountComment: v.CountReply,
				Show:         int(v.Show),
			}
		}

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

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

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

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

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

// UnLikeArticle 取消点赞文章
func (l *MiniBusinessLogic) UnLikeArticle(conn transaction.Conn, articleId int64) (err error) {
	return l.deleteMessage(conn, domain.OptTypeArticle, articleId, 0)
}

// UnLikeComment 取消点赞评论
func (l *MiniBusinessLogic) UnLikeComment(conn transaction.Conn, articleId int64, commentId int64) (err error) {
	return l.deleteMessage(conn, domain.OptTypeComment, articleId, commentId)
}

func (l *MiniBusinessLogic) createMessage(
	conn transaction.Conn,
	msgType domain.MsgBusinessType,
	optType domain.MsgBusinessOpt,
	articleId int64,
	sectionId 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,
			SectionId:   sectionId,
			CommentId:   commentId,
			Content:     content,
		}
		msg, err = l.svcCtx.MessageBusinessRepository.Insert(l.ctx, conn, msg)
		if err != nil {
			return err
		}
	}
	return nil
}

func (l *MiniBusinessLogic) deleteMessage(conn transaction.Conn, optType domain.MsgBusinessOpt, articleId int64, commentId int64) (err error) {
	var userToken = contextdata.GetUserTokenFromCtx(l.ctx)

	queryOption := domain.NewQueryOptions().WithFindOnly().WithOffsetLimit(1, 1).
		MustWithKV("type", domain.MsgTypeLike).
		MustWithKV("optType", optType).
		MustWithKV("companyId", userToken.CompanyId).
		MustWithKV("recipientId", userToken.UserId).
		MustWithKV("articleId", articleId).
		MustWithKV("commentId", commentId)

	_, list, err := l.svcCtx.MessageBusinessRepository.Find(l.ctx, conn, queryOption)
	if err != nil {
		return err
	}
	for i := range list {
		_, err = l.svcCtx.MessageBusinessRepository.Delete(l.ctx, conn, list[i])
		if err != nil {
			return err
		}
	}
	return nil
}