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/global"
	"case-api/utils"
	"fmt"
	"github.com/gin-gonic/gin"
	"strconv"
	"strings"
	"time"
)

type User struct {
}

// GetUserScore 获取用户积分获取情况
func (b *User) GetUserScore(c *gin.Context) {
	userRequest := requests.UserRequest{}
	req := userRequest.GetUserScore
	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
	}

	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
	}

	// 检测病例是否属于平台
	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
	}

	// 获取病例详情
	caseDao := dao.CaseDao{}
	result, err := caseDao.GetCaseById(caseId)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	if result.CaseStatus == 2 {
		responses.FailWithMessage("数据异常", c)
		return
	}

	// 获取用户总积分
	caseUserDao := dao.CaseUserDao{}
	maps = make(map[string]interface{})
	maps["case_id"] = caseId
	maps["platform_id"] = platformId
	maps["user_id"] = userId
	caseUser, _ := caseUserDao.GetCaseUser(maps)
	if caseUser == nil {
		responses.OkWithData(nil, c)
		return
	}

	// 处理返回值
	g := dto.GetCaseUserDto(caseUser)

	// 获取用户获取积分记录
	recordScoreDao := dao.RecordScoreDao{}
	maps = make(map[string]interface{})
	maps["case_id"] = caseId
	maps["platform_id"] = platformId
	maps["user_id"] = userId
	recordScores, err := recordScoreDao.GetRecordScoreList(maps)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	mergedScore := 0
	for _, score := range recordScores {
		if score.Type == 3 || score.Type == 4 {
			mergedScore += score.Score
		}
	}

	// 优质留言
	var describe []string
	for _, score := range recordScores {
		d := score.NodeName + ":"

		if score.Type == 4 {
			continue
		}

		if score.Type == 3 && mergedScore != 0 {
			score.Score = mergedScore
		}

		if platformId == 2 {
			d = d + fmt.Sprintf("%d", score.Score*10)
		} else {
			d = d + fmt.Sprintf("%d", score.Score)
		}

		describe = append(describe, d)
	}

	g.Describe = strings.Join(describe, ",")

	if platformId == 2 {
		g.TotalScore = g.TotalScore * 10
	}

	responses.OkWithData(g, c)
}

// AddUserBehavior 上报用户行为
func (b *User) AddUserBehavior(c *gin.Context) {
	userRequest := requests.UserRequest{}
	req := userRequest.AddUserBehavior
	if err := c.ShouldBind(&req); err != nil {
		responses.Ok(c)
		return
	}

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

	platformId := c.GetInt64("PlatformId") // 平台id
	if platformId == 0 {
		responses.Ok(c)
		return
	}

	userId := c.GetInt64("UserId") // 用户id
	if userId == 0 {
		responses.Ok(c)
		return
	}

	req.PlatformId = platformId
	req.UserId = userId

	// 将 id 转换为 int64 类型
	caseId, err := strconv.ParseInt(req.CaseId, 10, 64)
	if err != nil {
		responses.Ok(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.Ok(c)
		return
	}

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

	// 增加用户行为记录
	startTime, err := time.Parse("2006-01-02 15:04:05", req.StartTime)
	if err != nil {
		tx.Rollback()
		responses.Ok(c)
		return
	}

	endTime, err := time.Parse("2006-01-02 15:04:05", req.EndTime)
	if err != nil {
		tx.Rollback()
		responses.Ok(c)
		return
	}

	userBehaviorRecord := &model.UserBehaviorRecord{
		CaseId:     caseId,
		PlatformId: platformId,
		UserId:     userId,
		Step:       req.Step,
		StartTime:  model.LocalTime(startTime),
		EndTime:    model.LocalTime(endTime),
	}

	userBehaviorRecordDao := dao.UserBehaviorRecordDao{}
	_, err = userBehaviorRecordDao.AddUserBehaviorRecord(tx, userBehaviorRecord)
	if err != nil {
		tx.Rollback()
		responses.Ok(c)
		return
	}

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