package commentser

import (
	"91porn-server/app/service/taskser"
	"91porn-server/common"
	"91porn-server/common/log"
	"91porn-server/common/stderr"
	"91porn-server/models/commod"
	"91porn-server/models/v/cmtmod"
	"91porn-server/models/v/dailytaskmod"
	"91porn-server/models/v/locmod"
	"91porn-server/models/v/messagemod"
	"91porn-server/models/v/txnmod"
	"91porn-server/models/v/usermod"
	"91porn-server/models/v/vidmod"
	"91porn-server/models/v/walletmod"
	"91porn-server/web/service/chat_message_ser"
	"91porn-server/web/vidhelp"
	"91porn-server/web/webg"
	"errors"
	"fmt"
	"time"

	"go.mongodb.org/mongo-driver/bson/primitive"
)

// GetCommentList 后台获取评论列表
func GetCommentList(vidID string, cUID uint64, content string, isRobot, isAdvertiser *bool, status *int, page commod.Page) (data interface{}, err error) {
	cList, count, err := cmtmod.CmtFindCommentsAndCount(vidID, cUID, content, isRobot, isAdvertiser, status, page)
	if err != nil {
		log.Error("web service comment GetCommentList FindUserByUID error", log.E(err), log.Any("vidID", vidID), log.Any("cUID", cUID), log.Any("content", content))
		return
	}
	var cmtList []cmtmod.WebCmtRespList
	var uids []uint64
	for _, v := range cList {
		// 获取评论的用户是否已禁言
		usr, err := usermod.FindUserByUID(v.UserID)
		if err != nil || usr == nil {
			log.Error("web service comment GetCommentList FindUserByUID error", log.E(err), log.Any("uid", v.UserID))
			continue // 避免测试服脏数据造成无数据返回
		}
		tmp := cmtmod.WebCmtRespList{
			ID:           v.ID,
			ObjID:        v.ObjID,
			UserID:       v.UserID,
			LikeCount:    v.LikeCount,
			Content:      v.Content,
			Level:        v.Level,
			Status:       v.Status,
			IsDelete:     v.IsDelete,
			LinkStr:      v.LinkStr,
			IsBaned:      usr.HasBanned,
			IsGodComment: v.IsGodComment,
			Portrait:     usr.Portrait,
			Name:         usr.Name,
			CreatedAt:    v.CreatedAt,
			IsRobot:      v.IsRobot,
			HasLocked:    usr.HasLocked,
			IsAdvertiser: usr.IsAdvertiser,
			Image:        v.Image,
		}
		cmtList = append(cmtList, tmp)
		uids = append(uids, v.UserID)
	}
	if cmtList == nil {
		cmtList = []cmtmod.WebCmtRespList{}
	}

	resp := make(map[string]interface{})
	resp["list"] = cmtList
	resp["total"] = count
	resp["uids"] = uids
	data = resp
	return
}

// 后台评论管理屏蔽评论
func DeleteCommentsByID(ids []primitive.ObjectID, uid uint64, content string) (err error) {
	var cmtList []cmtmod.Comment
	if uid != 0 {
		// 获取评论
		if cmtList, err = cmtmod.GetCommentsByUID(uid); err != nil {
			return
		}
		if err = cmtmod.DelCommentsByUID(uid); err != nil {
			return
		}
	} else if content != "" {
		if cmtList, err = cmtmod.GetCommentsByContent(content); err != nil {
			return
		}
		if err = cmtmod.DelCommentsByContent(content); err != nil {
			return
		}
	} else {
		if ids == nil || len(ids) == 0 {
			return
		}
		if cmtList, err = cmtmod.GetCommentsByIDS(ids); err != nil {
			return
		}
		if err = cmtmod.DelCommentsByIDS(ids); err != nil {
			return
		}
	}
	// 评论数更新
	for _, v := range cmtList {
		// 视频评论数-1
		_ = vidhelp.DecCommentCount(v.ObjID)
		// 删除子评论
		if v.Level == 1 {
			var childIDS []primitive.ObjectID
			// 获取子评论
			childCmtList, _ := cmtmod.GetCommentsByCID(v.ObjID, v.ID)
			for _, v1 := range childCmtList {
				childIDS = append(childIDS, v1.ID)
				// 视频评论数-1
				_ = vidhelp.DecCommentCount(v1.ObjID)
			}
			if childIDS == nil || len(childIDS) == 0 {
				continue
			}
			// 删除评论
			_ = cmtmod.DelCommentsByIDS(childIDS)
		}
		// 评论数-1
		if v.Level == 2 && !v.CID.IsZero() {
			_ = cmtmod.CmtDecreaseCommentCountByID(v.CID)
		}
	}
	return
}

// 后台获取评论详情
func GetCommentInfo(id primitive.ObjectID) (data interface{}, err error) {
	return cmtmod.CmtFindOneByID(id)
}

// AccessComment 后台评论通过审核
func AccessComment(id primitive.ObjectID) (err error) {
	cmt, err := cmtmod.CmtFindOneByID(id)
	if err != nil || cmt.ID.IsZero() {
		log.Error("web service comment AccessComment CmtFindOneByID error", log.E(err), log.Any("id", id))
		return
	}
	err = cmtmod.CmtUpdateCommentStatusByID(id, 1)
	if err != nil {
		log.Error("web service comment GetCommentList CmtUpdateCommentStatusByID error", log.E(err), log.Any("uid", id))
		return
	}
	// 审核通过增加评论数
	err = vidmod.IncCommentCount(cmt.ObjID)
	if err != nil {
		log.Error("web service comment GetCommentList IncCommentCount error", log.E(err), log.Any("uid", id))
		return
	}
	return
}

// BatchAccessComment 批量后台评论通过审核
func BatchAccessComment(ids []primitive.ObjectID, status int) (err error) {
	cmt, err := cmtmod.CmtFindOneByIds(ids)
	if err != nil || len(cmt) <= 0 {
		log.Error("web service comment AccessComment CmtFindOneByIds error", log.E(err), log.Any("ids", ids))
		return
	}
	err = cmtmod.PassCommentStatusByIds(ids, status)
	if err != nil {
		log.Error("web service BatchAccessComment PassCommentStatusByIds error", log.E(err))
		return
	}
	return
}

// PublishComment 发表评论 统一以作者身份回复
func PublishComment(param cmtmod.PublishReqInfo) (code stderr.Code, err error) {
	videoInfo, err := vidmod.GetVideoInfo(param.ObjID.Hex())
	if err != nil || videoInfo.ID.IsZero() {
		code = stderr.CommentErrSendFail
		code.SetMsg("current video is not exist or find error")
		return code, err
	}
	var cmtMod cmtmod.Comment
	isAuthor := false
	if videoInfo.PublisherID == param.ToUserID {
		isAuthor = true
	}
	if code, cmtMod, err = getTrackInfo(videoInfo, "", isAuthor, param); code != stderr.Success || err != nil {
		return code, err
	}
	// 保存到数据库
	id, err := cmtmod.CmtInsertOne(&cmtMod)
	if err != nil {
		code = stderr.CommentErrSendFail
		return code, err
	}
	if err = setGid(param.CID, param.RID, id); err != nil {
		code = stderr.CommentErrSendFail
		return code, err
	}
	// 增加评论数
	incCommentCount(param.CID, param.ObjID)
	// 获取该评论
	return
}

// 获取相关信息
func getTrackInfo(videoInfo vidmod.VideoModel, ip string, isAuthor bool, param cmtmod.PublishReqInfo) (code stderr.Code, data cmtmod.Comment, err error) {
	var cid primitive.ObjectID
	var publiserID = videoInfo.PublisherID
	if param.CID != "" {
		if cid, err = primitive.ObjectIDFromHex(param.CID); err != nil {
			code = stderr.CommentErrSendFail
			return code, data, err
		}
	}

	loc, _ := locmod.GetLocationInfoByID(videoInfo.Location)
	now := time.Now()
	data = cmtmod.Comment{
		ObjID:        param.ObjID,
		CID:          cid,
		PublisherID:  publiserID,
		SortCnt:      0,
		ToUserID:     param.ToUserID,
		Content:      param.Content,
		OrgContent:   param.Content,
		UserID:       param.ToUserID,
		Status:       1,
		Level:        param.Level,
		AuthorMark:   isAuthor,
		IsAuthor:     isAuthor,
		IsDelete:     false,
		CommentCount: 0,
		LikeCount:    0,
		IPAddr:       ip,
		City:         loc.City,
		IsRobot:      true,
		CreatedAt:    now,
	}

	if param.ToUserID != 0 {
		if param.Level == 1 {
			user, err := usermod.FindUserByUID(param.ToUserID)
			if err != nil {
				code = stderr.CommentErrSendFail
				return code, data, err
			}
			data.UserID = user.UID
		} else {
			rCmt, err := cmtmod.CmtFindOneByID(cid)
			if err != nil {
				code = stderr.CommentErrSendFail
				return code, data, err
			}
			user, err := usermod.FindUserByUID(rCmt.UserID)
			if err != nil {
				code = stderr.CommentErrSendFail
				return code, data, err
			}
			data.UserID = param.ToUserID
			data.ToUserID = rCmt.UserID
			data.ToUserName = user.Name
		}
	}
	if param.RID != "" {
		rid, err := primitive.ObjectIDFromHex(param.RID)
		if err != nil {
			code = stderr.CommentErrSendFail
			return code, data, err
		}
		rCmt, err := cmtmod.CmtFindOneByID(rid)
		if err != nil {
			code = stderr.CommentErrSendFail
			return code, data, err
		}
		user, err := usermod.FindUserByUID(rCmt.UserID)
		if err != nil {
			code = stderr.CommentErrSendFail
			return code, data, err
		}
		if rCmt.Level != 1 {
			// 如果回复的不是1级，则需要写入rid
			data.RID = rid
		}
		data.GID = rCmt.GID
		data.AuthorMark = rCmt.AuthorMark
		data.SortCnt = rCmt.SortCnt
		data.Type = cmtmod.CmtTypeReply
		data.PublisherID = rCmt.UserID
		data.ToUserName = user.Name
		data.ToUserID = rCmt.UserID
		if !rCmt.CID.IsZero() {
			data.CID = rCmt.CID
		}
	} else if param.RID == "" && !cid.IsZero() {
		data.Type = cmtmod.CmtTypeComment
		cCmt, err := cmtmod.CmtFindOneByID(cid)
		if err != nil {
			code = stderr.CommentErrSendFail
			return code, data, err
		}
		data.PublisherID = cCmt.UserID
	} else {
		data.PublisherID = videoInfo.PublisherID
		data.Type = cmtmod.CmtTypeVideo
	}
	code = stderr.Success
	return
}

// 设置分组id
func setGid(cid string, rid string, id primitive.ObjectID) (err error) {
	if cid != "" && rid == "" {
		return cmtmod.SetGid(id)
	}
	return
}

// 增加评论数
func incCommentCount(cid string, objID primitive.ObjectID) {
	if cid != "" {
		var objCid primitive.ObjectID
		objCid, err := primitive.ObjectIDFromHex(cid)
		if err != nil {
			return
		}
		// 根据cid获取评论信息
		if toComment, err := cmtmod.CmtFindOneByID(objCid); err != nil || (toComment.Level != 1 && toComment.Level != 2) {
			return
		}
		if err := cmtmod.CmtIncreaseCommentCountByID(objCid); err != nil {
			return
		}
	}
	// 增加视频评论数
	if err := vidhelp.IncCommentCount(objID); err != nil {
		return
	}
}

// UpdateComment 后台评论设置
func UpdateComment(in *cmtmod.EditCond) (err error) {
	cmt, err := cmtmod.CmtFindOneByID(in.ID)
	if err != nil || cmt.ID.IsZero() {
		log.Error("web service comment AccessComment CmtFindOneByID error", log.E(err), log.Any("id", in.ID))
		return errors.New("comment is err or null")
	}
	if in.LinkStr == nil && cmt.Level != 1 && in.LikeCount == nil {
		return errors.New("comment level is not 1")
	}

	if in.LinkStr == nil && cmt.IsAuthor && in.LikeCount == nil {
		return errors.New("author not allow godComment")
	}

	if in.LinkStr == nil && in.IsGodComment == nil && in.LikeCount == nil {
		return errors.New("update params is null")
	}
	// 如果设置为神评论
	// 判断是否已经发送过该评论的神评论奖励(避免修改为普通评论后又修改为神评论，奖励多次发放的情况)
	if in.IsGodComment != nil && *in.IsGodComment == true && !cmt.GodCommentAward {
		in.GodCommentAward = true
	}
	err = cmtmod.Update(in.Filter(), in.Update())
	if err != nil {
		log.Error("web service comment GetCommentList CmtUpdateCommentStatusByID error", log.E(err), log.Any("id", in.ID))
		return
	}
	/********************* 以下是神评相关逻辑 **********************/
	// 完成任务，评论被设置为神评
	if in.IsGodComment != nil && *in.IsGodComment == true {
		// 完成评论被设置为神评
		common.Go(func() {
			err = taskser.CompleteDailyTask(nil, cmt.UserID, dailytaskmod.CommentSetGod)
			if err != nil {
				log.Error("web 设置神评，完成每日任务【评论被设置为神评】失败", log.E(err), log.Any("id", in.ID))
				return
			}
		})
	}
	// 获取神评论奖励积分配置
	if webg.Conf.GodCommentAward <= 0 {
		return stderr.Success
	}

	// 查询出评论的帖子信息
	video, err := vidmod.GetVideoByID(cmt.ObjID)
	if err != nil || video == nil {
		return
	}
	objName := fmt.Sprintf("[%v]", video.Title)
	content := fmt.Sprintf("恭喜您在%v中评论获得神评，获得%v积分", objName, webg.Conf.GodCommentAward)
	// 发放积分
	walletInfo, err := walletmod.CreditIntegral(nil, webg.Conf.GodCommentAward, cmt.UserID)
	if err != nil {
		return err
	}

	log := &txnmod.TransactionLog{
		TransNo:        primitive.NewObjectID(),
		UID:            cmt.UserID,
		Integral:       webg.Conf.GodCommentAward,
		ActualIntegral: float64(webg.Conf.GodCommentAward),
		TranType:       txnmod.GodCommentAward.Key(),
		TranTypeInt:    int64(txnmod.GodCommentAward),
		Desc:           fmt.Sprintf("%s-积分[%d个]", txnmod.GodCommentAward.Key(), webg.Conf.GodCommentAward),
		RealIntegral:   walletInfo.RealIntegral(),
	}
	txnmod.InsertTransactionLog(nil, log)

	// 发放私信告诉用户获得了积分
	code := chat_message_ser.AddPrivateLetter(&messagemod.SendMsg{
		Sender:   100001,
		Receiver: cmt.UserID,
		Content:  content,
		MsgType:  messagemod.OfficialPrivateLetterMsg,
		ObjId:    video.ID,
		ObjName:  objName,
	})

	return code
}