package service

import (
	"case-admin-api/api/dao"
	"case-admin-api/api/model"
	"case-admin-api/extend/aliyun"
	"case-admin-api/extend/app"
	"case-admin-api/extend/superKangaroo"
	"errors"
	"fmt"
	"gorm.io/gorm"
	"io"
	"math/rand"
	"net/http"
	"time"
)

type UserService struct {
}

// HandleUserImage 处理用户图片
func (r *UserService) HandleUserImage(wxAvatar string) (ossPath string, err error) {
	if wxAvatar == "" {
		return "", nil
	}

	// 发送GET请求
	resp, err := http.Get(wxAvatar)
	if err != nil {
		return "", err
	}

	defer func(Body io.ReadCloser) {
		_ = Body.Close()
	}(resp.Body)

	if resp.StatusCode != 200 {
		return "", errors.New("请求失败")
	}

	// 读取响应体
	respBody, err := io.ReadAll(resp.Body)
	if err != nil {
		return "", err
	}

	// 设置文件名字
	now := time.Now()
	dateTimeString := now.Format("20060102150405")  // 当前时间字符串
	rand.New(rand.NewSource(time.Now().UnixNano())) // 设置随机数
	ossPath = "user/avatar/" + dateTimeString + fmt.Sprintf("%d", rand.Intn(9000)+1000) + ".png"

	// 上传oss
	_, err = aliyun.PutObjectByte(ossPath, respBody)
	if err != nil {
		return "", err
	}

	ossPath = "/" + ossPath

	return ossPath, nil
}

// ReportUserScore 发放积分
// scoreType : 积分类型（1:完成阅读 2:阅读时间满足 3:优质留言 4:再次优质留言 ）
func (r *UserService) ReportUserScore(tx *gorm.DB, projectId, caseId, platformId int64, scoreType int, user *model.User) (reportUser *model.User, err error) {
	maps := make(map[string]interface{})
	// // 获取项目关联平台
	// projectPlatformDao := dao.ProjectPlatformDao{}
	// maps["project_id"] = projectId
	// maps["platform_id"] = platformId
	// projectPlatform, err := projectPlatformDao.GetProjectPlatform(maps)
	// if err != nil {
	// 	return err
	// }

	// // 检测福利开关
	// if projectPlatform.IsWelfare == 0 {
	// 	// 福利未开
	// 	return nil
	// }

	// // 获取需发放积分
	// score := 0
	// appScoreTypeStr := ""   // 积分发放原因-app
	// superScoreTypeStr := "" // 积分发放原因-超级袋鼠
	// nodeName := ""          // 获取积分节点名称
	// if scoreType == 1 {
	// 	// 完成阅读
	// 	score = projectPlatform.CompleteRead
	// 	appScoreTypeStr = "互动病例-完成阅读"
	// 	superScoreTypeStr = "调研奖励(完成阅读)"
	// 	nodeName = "学习"
	// } else if scoreType == 2 {
	// 	// 阅读时间满足
	// 	score = projectPlatform.CompleteReadTime
	// 	appScoreTypeStr = "互动病例-阅读时间满足"
	// 	superScoreTypeStr = "调研奖励(阅读质量)"
	// 	nodeName = "阅读达标"
	// } else if scoreType == 3 {
	// 	// 优质留言
	// 	score = projectPlatform.FirstHighQuality
	// 	appScoreTypeStr = "互动病例-优质留言"
	// 	superScoreTypeStr = "调研奖励(社区贡献)"
	// 	nodeName = "优质留言"
	// } else if scoreType == 4 {
	// 	// 再次优质留言
	// 	score = projectPlatform.OnceMoreHighQuality
	// 	appScoreTypeStr = "互动病例-优质留言"
	// 	superScoreTypeStr = "调研奖励(社区贡献)"
	// 	nodeName = "优质留言"
	// }

	recordScoreDao := dao.RecordScoreDao{}

	// 检测是否有相同手机号用户
	userDao := dao.UserDao{}
	maps = make(map[string]interface{})
	maps["mobile_encryption"] = user.MobileEncryption
	users, err := userDao.GetUserList(maps)
	if err != nil {
		return user,nil
	}
	for _, m := range users {
		// 检测积分是否已在其他平台发放过
		maps = make(map[string]interface{})
		maps["project_id"] = projectId
		maps["case_id"] = caseId
		maps["user_id"] = m.UserId
		recordScore, _ := recordScoreDao.GetRecordScoreUseTx(tx, maps)
		if recordScore != nil {
			if recordScore.PlatformId != platformId {
				// 由其他平台进行发放积分 修改平台id为其他平台id
				platformId = recordScore.PlatformId

				user = m
			}
		}

		// 检测该类型积分是否已经发放(其他平台也算)
		maps = make(map[string]interface{})
		maps["project_id"] = projectId
		maps["case_id"] = caseId
		maps["platform_id"] = platformId
		maps["user_id"] = m.UserId
		maps["type"] = scoreType
		recordScore, _ = recordScoreDao.GetRecordScore(maps)
		if recordScore != nil {
			// 积分已发放过
			return user,nil
		}
	}


	// 获取项目关联平台
	projectPlatformDao := dao.ProjectPlatformDao{}
	maps = make(map[string]interface{})
	maps["project_id"] = projectId
	maps["platform_id"] = platformId
	projectPlatform, err := projectPlatformDao.GetProjectPlatform(maps)
	if err != nil {
		return user,err
	}

	// 检测福利开关
	if projectPlatform.IsWelfare == 0 {
		// 福利未开
		return user,nil
	}

	// 获取需发放积分
	score := 0
	appScoreTypeStr := ""   // 积分发放原因-app
	superScoreTypeStr := "" // 积分发放原因-超级袋鼠
	nodeName := ""          // 获取积分节点名称
	if scoreType == 1 {
		// 完成阅读
		score = projectPlatform.CompleteRead
		appScoreTypeStr = "互动病例-完成阅读"
		superScoreTypeStr = "调研奖励(完成阅读)"
		nodeName = "学习"
	} else if scoreType == 2 {
		// 阅读时间满足
		score = projectPlatform.CompleteReadTime
		appScoreTypeStr = "互动病例-阅读时间满足"
		superScoreTypeStr = "调研奖励(阅读质量)"
		nodeName = "阅读达标"
	} else if scoreType == 3 {
		// 优质留言
		score = projectPlatform.FirstHighQuality
		appScoreTypeStr = "互动病例-优质留言"
		superScoreTypeStr = "调研奖励(社区贡献)"
		nodeName = "优质留言"
	} else if scoreType == 4 {
		// 再次优质留言
		score = projectPlatform.OnceMoreHighQuality
		appScoreTypeStr = "互动病例-优质留言"
		superScoreTypeStr = "调研奖励(社区贡献)"
		nodeName = "优质留言"
	}

	
	// 默认为白名单用户
	isWhite := true
	if projectPlatform.IsWhite == 1 {
		projectPlatformWhiteService := ProjectPlatformWhiteService{}
		isWhite, err = projectPlatformWhiteService.CheckProjectPlatformWhiteByUser(user, projectId, platformId)
		if err != nil {
			return user,err
		}
	}

	// 佳动力需求：非白名单用户也需要请求积分记录
	// 当用户为非白名单时，重置积分数
	if isWhite == false {
		score = 0
	}

	// 获取病例关联平台数据
	casePlatformDao := dao.CasePlatformDao{}
	maps = make(map[string]interface{})
	maps["case_id"] = caseId
	maps["platform_id"] = platformId
	casePlatform, err := casePlatformDao.GetCasePlatform(maps)
	if err != nil {
		return user,err
	}

	// 检测全部积分是否已发放完毕
	remainingScore := projectPlatform.SingleCaseScore - casePlatform.IssuedScore
	if remainingScore <= 0 {
		// 积分已发放完毕
		return user,nil
	}

	// 新增发放记录-每发一次记录一次
	recordScore := &model.RecordScore{
		ProjectId:  projectId,
		CaseId:     caseId,
		PlatformId: platformId,
		UserId:     user.UserId,
		UserName:   user.UserName,
		Type:       scoreType,
		NodeName:   nodeName,
		Score:      score,
	}

	recordScore, err = recordScoreDao.AddRecordScore(tx, recordScore)
	if err != nil {
		return user,err
	}

	// 获取用户参与记录
	caseUserDao := dao.CaseUserDao{}
	maps = make(map[string]interface{})
	maps["case_id"] = caseId
	maps["platform_id"] = platformId
	maps["user_id"] = user.UserId
	caseUser, _ := caseUserDao.GetCaseUserUseTx(tx, maps)
	if caseUser == nil {
		return user,errors.New("用户还未完成该病例阅读，请稍后再试")
	}

	// 累计用户领取积分数据
	err = caseUserDao.Inc(tx, caseUser.CaseUserId, "total_score", score)
	if err != nil {
		return user,err
	}

	// 累计平台发放积分数据
	err = casePlatformDao.Inc(tx, casePlatform.CasePlatformId, "issued_score", score)
	if err != nil {
		return user,err
	}

	// 累计发放积分数据
	caseDao := dao.CaseDao{}
	err = caseDao.Inc(tx, caseId, "issued_score", score)
	if err != nil {
		return user,err
	}

	// 发放积分-
	if platformId != 1 && platformId != 2 {
		return user,errors.New("积分发放失败")
	}

	// 肝胆相照
	if platformId == 1 && score > 0 {
		_, err = app.ReportUserScore(appScoreTypeStr, user.UserIden, score)
		if err != nil {
			return user,err
		}
	}

	// 超级袋鼠
	if platformId == 2 {
		// 获取病例数据
		caseDao := dao.CaseDao{}
		result, err := caseDao.GetCaseById(caseId)
		if err != nil {
			return user,err
		}

		_, err = superKangaroo.ReportUserScore(caseId, user.UserIden, superScoreTypeStr, recordScore, result)
		if err != nil {
			return user,err
		}
	}

	return user,nil
}

// ReportCaseRecord 上报用户参与情况-只上报优质留言
func (r *UserService) ReportCaseRecord(tx *gorm.DB, projectId, caseId int64, user *model.User) (err error) {
	caseUserDao := dao.CaseUserDao{}
	maps := make(map[string]interface{})
	maps["case_id"] = caseId
	maps["user_id"] = user.UserId
	caseUser, err := caseUserDao.GetCaseUser(maps)
	if err != nil {
		return err
	}

	recordScoreDao := dao.RecordScoreDao{}
	caseCommentDao := dao.CaseCommentDao{}

	// 获取积分发放记录
	maps = make(map[string]interface{})
	maps["project_id"] = projectId
	maps["case_id"] = caseId
	maps["platform_id"] = caseUser.PlatformId
	maps["user_id"] = user.UserId
	recordScores, _ := recordScoreDao.GetRecordScoreListUseTx(tx, maps)

	// 获取用户评论
	maps = make(map[string]interface{})
	maps["case_id"] = caseId
	maps["platform_id"] = caseUser.PlatformId
	maps["user_id"] = user.UserId
	maps["status"] = 1
	caseComments, _ := caseCommentDao.GetCaseCommentList(maps)

	// 组装请求数据
	requestData := superKangaroo.ReportCaseRecordRequest{
		CaseUserId: fmt.Sprintf("%d", caseUser.CaseUserId),
		Sid:        fmt.Sprintf("%d", caseUser.CaseId),
		TslUid:     user.UserIden,
		Credit1:    0,
		Credit2:    0,
		Credit3:    0,
		Credit4:    0,
		HasRemark:  0,
		Remark:     nil,
	}

	// 积分
	for _, v3 := range recordScores {
		if v3.Type == 1 {
			requestData.Credit1 = v3.Score
		}

		if v3.Type == 2 {
			requestData.Credit2 = v3.Score
		}

		if v3.Type == 3 {
			requestData.Credit4 = v3.Score
		}
	}

	// 评论
	if len(caseComments) > 0 {
		requestData.Remark = make([]*superKangaroo.RemarkRequest, len(caseComments))

		requestData.HasRemark = 1
		for i2, comment := range caseComments {
			remarkDto := &superKangaroo.RemarkRequest{
				Remark:     comment.Content,
				CreateTime: time.Time(comment.CreatedAt).Format("2006-01-02 15:04:05"),
			}

			requestData.Remark[i2] = remarkDto
		}
	}

	_, err = superKangaroo.ReportCaseRecord(requestData)
	if err != nil {
		return err
	}

	return nil
}