package controller

import (
	"case-api/api/dao"
	"case-api/api/dto"
	"case-api/api/model"
	"case-api/api/requests"
	"case-api/api/responses"
	"case-api/api/service"
	"case-api/global"
	"case-api/utils"
	"github.com/gin-gonic/gin"
	"strconv"
)

type CaseComment struct {
}

// GetCaseCommentPage 获取列表-分页
func (b *CaseComment) GetCaseCommentPage(c *gin.Context) {
	caseCommentRequest := requests.CaseCommentRequest{}
	req := caseCommentRequest.GetCaseCommentPage
	if err := c.ShouldBind(&req); err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 参数验证
	if err := global.Validate.Struct(req); err != nil {
		responses.FailWithMessage(utils.Translate(err), c)
		return
	}

	if req.Page == 0 {
		req.Page = 1
	}

	if req.PageSize == 0 {
		req.PageSize = 20
	}

	platformId := c.GetInt64("PlatformId") // 平台id
	if platformId == 0 {
		responses.FailWithMessage("内部错误", c)
		return
	}

	req.PlatformId = platformId

	userId := c.GetInt64("UserId") // 用户id
	if userId == 0 {
		responses.FailWithMessage("内部错误", c)
		return
	}

	req.UserId = userId

	// 将 id 转换为 int64 类型
	caseId, err := strconv.ParseInt(req.CaseId, 10, 64)
	if err != nil {
		responses.Fail(c)
		return
	}

	// 获取病例数据
	caseDao := dao.CaseDao{}
	caseResult, err := caseDao.GetCaseById(caseId)
	if err != nil {
		responses.FailWithMessage("非法病例", c)
		return
	}

	if caseResult.CaseStatus == 2 {
		responses.FailWithMessage("非法病例", c)
		return
	}

	// 检测病例是否属于平台
	casePlatformDao := dao.CasePlatformDao{}
	maps := make(map[string]interface{})
	maps["case_id"] = caseId
	maps["platform_id"] = platformId
	_, err = casePlatformDao.GetCasePlatform(maps)
	if err != nil {
		responses.FailWithMessage("非法数据", c)
		return
	}

	// 获取评论数据
	caseCommentDao := dao.CaseCommentDao{}
	caseComments, total, err := caseCommentDao.GetCaseCommentPageSearch(req, req.Page, req.PageSize)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 处理返回值
	g := dto.GetCaseCommentListDto(caseComments)

	caseCommentLikeDao := dao.CaseCommentLikeDao{}
	for _, commentDto := range g {
		// 获取是否点赞
		maps = make(map[string]interface{})
		maps["comment_id"] = commentDto.CommentId
		maps["user_id"] = userId
		isLike, _ := caseCommentLikeDao.GetCaseCommentLikeCount(maps)

		// 加载数据-点赞
		commentDto.LoadIsLike(isLike)

		// 获取次级评论
		maps = make(map[string]interface{})
		maps["root_id"] = commentDto.CommentId
		maps["status"] = 1
		subComments, _ := caseCommentDao.GetCaseCommentPreloadListLimit(maps, 5)
		if len(subComments) > 0 {
			// 加载数据-次级评论
			commentDto.LoadCaseComment(subComments)

			for _, caseCommentDto := range commentDto.CaseComment {
				// 获取是否点赞
				maps = make(map[string]interface{})
				maps["comment_id"] = caseCommentDto.CommentId
				maps["user_id"] = userId
				isLike, _ = caseCommentLikeDao.GetCaseCommentLikeCount(maps)

				// 加载数据-点赞
				commentDto.LoadIsLike(isLike)
			}

			// 处理剩余评论数量字段
			maps = make(map[string]interface{})
			maps["root_id"] = commentDto.CommentId
			maps["status"] = 1
			totalAmount, _ := caseCommentDao.GetCaseCommentCount(maps)

			// 加载数据-剩余数量
			commentDto.LoadTotalAmount(totalAmount - int64(len(subComments)))
		}
	}

	result := make(map[string]interface{})
	result["page"] = req.Page
	result["page_size"] = req.PageSize
	result["total"] = total
	result["data"] = g
	responses.OkWithData(result, c)
}

// AddCaseComment 新增
func (b *CaseComment) AddCaseComment(c *gin.Context) {
	caseCommentRequest := requests.CaseCommentRequest{}
	req := caseCommentRequest.AddCaseComment
	if err := c.ShouldBind(&req); err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 参数验证
	if err := global.Validate.Struct(req); err != nil {
		responses.FailWithMessage(utils.Translate(err), c)
		return
	}

	// 参数判断
	if req.Comment.Level == 2 || req.Comment.Level == 3 {
		if req.Comment.ParentId == "" || req.Comment.RootId == "" {
			responses.FailWithMessage("参数错误", c)
			return
		}
	}

	platformId := c.GetInt64("PlatformId") // 平台id
	if platformId == 0 {
		responses.FailWithMessage("内部错误", c)
		return
	}

	userId := c.GetInt64("UserId") // 用户id
	if userId == 0 {
		responses.FailWithMessage("内部错误", c)
		return
	}

	req.PlatformId = platformId
	req.UserId = userId

	// 将 id 转换为 int64 类型
	caseId, err := strconv.ParseInt(req.CaseId, 10, 64)
	if err != nil {
		responses.Fail(c)
		return
	}

	// 获取病例数据
	caseDao := dao.CaseDao{}
	caseResult, err := caseDao.GetCaseById(caseId)
	if err != nil {
		responses.FailWithMessage("非法病例", c)
		return
	}

	if caseResult.CaseStatus == 2 {
		responses.FailWithMessage("非法病例", c)
		return
	}

	// 检测病例是否属于平台
	casePlatformDao := dao.CasePlatformDao{}
	maps := make(map[string]interface{})
	maps["case_id"] = caseId
	maps["platform_id"] = platformId
	casePlatform, err := casePlatformDao.GetCasePlatform(maps)
	if err != nil {
		responses.FailWithMessage("非法数据", c)
		return
	}

	// 处理评论内容
	basicSensitiveWordService := service.BasicSensitiveWordService{}
	content, isSensitive := basicSensitiveWordService.Filter(req.Comment.Content)

	// 开始事务
	tx := global.Db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	// 新增评论
	caseCommentDao := dao.CaseCommentDao{}
	caseComment := &model.CaseComment{
		CaseId:             caseId,
		PlatformId:         platformId,
		Level:              req.Comment.Level,
		UserId:             userId,
		Status:             1,
		IsSensitive:        isSensitive,
		IsHighQuality:      0,
		IsGrantHighQuality: 0,
		LikeNum:            0,
		Content:            content,
	}

	if isSensitive == 1 {
		caseComment.ContentWord = req.Comment.Content
	}

	// 评论根id
	if req.Comment.RootId != "" {
		rootId, err := strconv.ParseInt(req.Comment.RootId, 10, 64)
		if err != nil {
			tx.Rollback()
			responses.FailWithMessage("评论失败", c)
			return
		}

		caseComment.RootId = rootId
	}

	// 评论父级id
	if req.Comment.ParentId != "" {
		parentId, err := strconv.ParseInt(req.Comment.ParentId, 10, 64)
		if err != nil {
			tx.Rollback()
			responses.FailWithMessage("评论失败", c)
			return
		}

		caseComment.ParentId = parentId
	}

	caseComment, err = caseCommentDao.AddCaseComment(tx, caseComment)
	if err != nil {
		tx.Rollback()
		responses.FailWithMessage("评论失败", c)
		return
	}
	// 增加病例留言人数
	caseService := service.CaseService{}
	err = caseService.AddCaseMessageNum(tx, caseId, casePlatform.CasePlatformId)
	if err != nil {
		tx.Rollback()
		responses.FailWithMessage("评论失败", c)
		return
	}

	tx.Commit()
	responses.Ok(c)
}

// AddCaseCommentLike 新增点赞
func (b *CaseComment) AddCaseCommentLike(c *gin.Context) {
	id := c.Param("comment_id")
	if id == "" {
		responses.FailWithMessage("缺少参数", c)
		return
	}

	// 将 id 转换为 int64 类型
	commentId, err := strconv.ParseInt(id, 10, 64)
	if err != nil {
		responses.Fail(c)
		return
	}

	userId := c.GetInt64("UserId") // 用户id
	if userId == 0 {
		responses.FailWithMessage("内部错误", c)
		return
	}

	// 检测用户是否已点赞
	caseCommentLikeDao := dao.CaseCommentLikeDao{}
	maps := make(map[string]interface{})
	maps["comment_id"] = commentId
	maps["user_id"] = userId
	caseCommentLike, _ := caseCommentLikeDao.GetCaseCommentLike(maps)
	if caseCommentLike != nil {
		// 已点赞
		responses.Ok(c)
		return
	}

	// 开始事务
	tx := global.Db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	// 新增点赞
	caseCommentLike = &model.CaseCommentLike{
		CommentId: commentId,
		UserId:    userId,
	}
	_, err = caseCommentLikeDao.AddCaseCommentLike(tx, caseCommentLike)
	if err != nil {
		tx.Rollback()
		responses.FailWithMessage("操作失败", c)
		return
	}

	// 新增点赞数
	caseCommentDao := dao.CaseCommentDao{}
	err = caseCommentDao.Inc(tx, commentId, "like_num", 1)
	if err != nil {
		tx.Rollback()
		responses.FailWithMessage("操作失败", c)
		return
	}

	tx.Commit()
	responses.Ok(c)
}

// DeleteCaseCommentLike 取消点赞
func (b *CaseComment) DeleteCaseCommentLike(c *gin.Context) {
	id := c.Param("comment_id")
	if id == "" {
		responses.FailWithMessage("缺少参数", c)
		return
	}

	// 将 id 转换为 int64 类型
	commentId, err := strconv.ParseInt(id, 10, 64)
	if err != nil {
		responses.Fail(c)
		return
	}

	// 获取评论数据
	caseCommentDao := dao.CaseCommentDao{}
	caseComment, _ := caseCommentDao.GetCaseCommentById(commentId)
	if caseComment == nil {
		responses.FailWithMessage("操作失败", c)
		return
	}

	userId := c.GetInt64("UserId") // 用户id
	if userId == 0 {
		responses.FailWithMessage("内部错误", c)
		return
	}

	// 检测用户是否已点赞
	caseCommentLikeDao := dao.CaseCommentLikeDao{}
	maps := make(map[string]interface{})
	maps["comment_id"] = commentId
	maps["user_id"] = userId
	caseCommentLike, _ := caseCommentLikeDao.GetCaseCommentLike(maps)
	if caseCommentLike == nil {
		// 未点赞
		responses.Ok(c)
		return
	}

	// 开始事务
	tx := global.Db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	// 删除点赞
	err = caseCommentLikeDao.DeleteCaseCommentLikeById(tx, caseCommentLike.LikeId)
	if err != nil {
		tx.Rollback()
		responses.FailWithMessage("操作失败", c)
		return
	}

	// 去除点赞数
	if caseComment.LikeNum > 0 {
		err = caseCommentDao.Dec(tx, commentId, "like_num", 1)
		if err != nil {
			tx.Rollback()
			responses.FailWithMessage("操作失败", c)
			return
		}
	}

	tx.Commit()
	responses.Ok(c)
}