package controller

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

type CaseItem struct{}

// AddCaseItem 新增
func (b *CaseItem) AddCaseItem(c *gin.Context) {
	caseItemRequest := requests.CaseItemRequest{}
	req := caseItemRequest.AddCaseItem
	if err := c.ShouldBindJSON(&req); err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

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

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

		if item.QuestionType != 3 {
			if item.QuestionAnswer == "" {
				responses.FailWithMessage("缺少答案", c)
				return
			}
		}

		if item.QuestionType != 3 {
			if len(item.CaseItemQuestionOption) > 0 {
				for _, question := range item.CaseItemQuestionOption {
					if err := global.Validate.Struct(question); err != nil {
						responses.FailWithMessage(utils.Translate(err), c)
						return
					}
				}
			}
		}
	}

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

	// 检测项目
	// 将 id 转换为 int64 类型
	projectId, err := strconv.ParseInt(req.ProjectId, 10, 64)
	if err != nil {
		responses.Fail(c)
		return
	}

	projectDao := dao.ProjectDao{}
	project, err := projectDao.GetProjectById(projectId)
	if err != nil {
		responses.FailWithMessage("项目数据异常", c)
		return
	}

	// 检测状态
	if project.ProjectStatus == 0 {
		responses.FailWithMessage("项目无效，无法添加", c)
		return
	}

	caseId, err := strconv.ParseInt(req.CaseId, 10, 64)
	if err != nil {
		responses.Fail(c)
		return
	}

	caseDao := dao.CaseDao{}
	result, err := caseDao.GetCaseById(caseId)
	if err != nil {
		responses.FailWithMessage("病例数据异常", c)
		return
	}

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

	caseItemDao := dao.CaseItemDao{}
	caseItemQuestionDao := dao.CaseItemQuestionDao{}
	caseItemModelDao := dao.CaseItemModelDao{}
	caseItemQuestionOptionDao := dao.CaseItemQuestionOptionDao{}

	// 新增病例明细
	caseItem := &model.CaseItem{
		CaseId: result.CaseId,
		Page:   req.Page,
	}

	caseItem, err = caseItemDao.AddCaseItem(tx, caseItem)
	if err != nil {
		tx.Rollback()
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 新增病例题目
	if len(req.CaseItemQuestion) > 0 {
		for _, question := range req.CaseItemQuestion {
			caseItemQuestion := &model.CaseItemQuestion{
				CaseId:         result.CaseId,
				CaseItemId:     caseItem.CaseItemId,
				QuestionName:   question.QuestionName,
				QuestionType:   question.QuestionType,
				QuestionAnswer: question.QuestionAnswer,
				IsRightNext:    question.IsRightNext,
				ErrorTips:      question.ErrorTips,
			}

			caseItemQuestion, err = caseItemQuestionDao.AddCaseItemQuestion(tx, caseItemQuestion)
			if err != nil {
				tx.Rollback()
				responses.FailWithMessage(err.Error(), c)
				return
			}

			if question.QuestionType == 1 || question.QuestionType == 2 || question.QuestionType == 4 {
				if len(question.CaseItemQuestionOption) <= 0 {
					tx.Rollback()
					responses.FailWithMessage("缺少题目选项", c)
					return
				}

				for _, option := range question.CaseItemQuestionOption {
					caseItemQuestionOption := &model.CaseItemQuestionOption{
						QuestionId:  caseItemQuestion.QuestionId,
						OptionValue: option.OptionValue,
					}

					caseItemQuestionOption, err = caseItemQuestionOptionDao.AddCaseItemQuestionOption(tx, caseItemQuestionOption)
					if err != nil {
						tx.Rollback()
						responses.FailWithMessage(err.Error(), c)
						return
					}
				}
			}
		}
	}

	// 新增病例模块
	if len(req.CaseItemModel) > 0 {
		for _, v := range req.CaseItemModel {
			caseItemModel := &model.CaseItemModel{
				CaseItemId: caseItem.CaseItemId,
				ModelName:  v.ModelName,
				Content:    v.Content,
			}

			caseItemModel, err = caseItemModelDao.AddCaseItemModel(tx, caseItemModel)
			if err != nil {
				tx.Rollback()
				responses.FailWithMessage(err.Error(), c)
				return
			}
		}
	}

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

// PutCaseItem 修改
func (b *CaseItem) PutCaseItem(c *gin.Context) {
	caseItemRequest := requests.CaseItemRequest{}
	req := caseItemRequest.PutCaseItem
	if err := c.ShouldBindJSON(&req); err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

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

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

		if item.QuestionType != 3 {
			if item.QuestionAnswer == "" {
				responses.FailWithMessage("缺少答案", c)
				return
			}
		}

		if len(item.CaseItemQuestionOption) > 0 {
			for _, question := range item.CaseItemQuestionOption {
				if item.QuestionType != 3 {
					if err := global.Validate.Struct(question); err != nil {
						responses.FailWithMessage(utils.Translate(err), c)
						return
					}
				}
			}
		}
	}

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

	id := c.Param("case_item_id")
	if id == "" {
		responses.FailWithMessage("缺少参数", c)
		return
	}

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

	caseItemDao := dao.CaseItemDao{}
	caseItem, err := caseItemDao.GetCaseItemById(caseItemId)
	if err != nil {
		responses.FailWithMessage("数据异常", c)
		return
	}

	// 检测项目
	// 将 id 转换为 int64 类型
	projectId, err := strconv.ParseInt(req.ProjectId, 10, 64)
	if err != nil {
		responses.Fail(c)
		return
	}

	projectDao := dao.ProjectDao{}
	project, err := projectDao.GetProjectById(projectId)
	if err != nil {
		responses.FailWithMessage("项目数据异常", c)
		return
	}

	// 检测状态
	if project.ProjectStatus == 0 {
		responses.FailWithMessage("项目无效，无法添加", c)
		return
	}

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

	caseItemQuestionOptionDao := dao.CaseItemQuestionOptionDao{}
	caseItemQuestionDao := dao.CaseItemQuestionDao{}
	caseItemModelDao := dao.CaseItemModelDao{}

	// 获取问题
	maps := make(map[string]interface{})
	maps["case_item_id"] = caseItemId
	caseItemQuestions, err := caseItemQuestionDao.GetCaseItemQuestionList(maps)
	if err != nil {
		tx.Rollback()
		responses.FailWithMessage("操作失败", c)
		return
	}

	statCaseQuestionDao := dao.StatCaseQuestionDao{}
	caseUserAnswerDao := dao.CaseUserAnswerDao{}
	for _, question := range caseItemQuestions {
		if question.QuestionType == 1 || question.QuestionType == 2 || question.QuestionType == 4 {
			// 删除对应答题记录
			maps = make(map[string]interface{})
			maps["question_id"] = question.QuestionId
			err := statCaseQuestionDao.DeleteStatCaseQuestion(tx, maps)
			if err != nil {
				tx.Rollback()
				responses.FailWithMessage("操作失败", c)
				return
			}

			// 删除问题选项
			maps = make(map[string]interface{})
			maps["question_id"] = question.QuestionId
			err = caseItemQuestionOptionDao.DeleteCaseItemQuestionOption(tx, maps)
			if err != nil {
				tx.Rollback()
				responses.FailWithMessage("操作失败", c)
				return
			}
		}

		// 删除用户答题记录
		maps = make(map[string]interface{})
		maps["question_id"] = question.QuestionId
		err := caseUserAnswerDao.DeleteCaseUserAnswer(tx, maps)
		if err != nil {
			tx.Rollback()
			responses.FailWithMessage("操作失败", c)
			return
		}

		// 删除问题
		err = caseItemQuestionDao.DeleteCaseItemQuestionById(tx, question.QuestionId)
		if err != nil {
			tx.Rollback()
			responses.FailWithMessage("操作失败", c)
			return
		}
	}

	// 新增病例题目
	if len(req.CaseItemQuestion) > 0 {
		for _, question := range req.CaseItemQuestion {
			caseItemQuestion := &model.CaseItemQuestion{
				CaseId:         caseItem.CaseId,
				CaseItemId:     caseItem.CaseItemId,
				QuestionName:   question.QuestionName,
				QuestionType:   question.QuestionType,
				QuestionAnswer: question.QuestionAnswer,
				IsRightNext:    question.IsRightNext,
				ErrorTips:      question.ErrorTips,
			}

			caseItemQuestion, err = caseItemQuestionDao.AddCaseItemQuestion(tx, caseItemQuestion)
			if err != nil {
				tx.Rollback()
				responses.FailWithMessage(err.Error(), c)
				return
			}

			if question.QuestionType == 1 || question.QuestionType == 2 || question.QuestionType == 4 {
				if len(question.CaseItemQuestionOption) <= 0 {
					tx.Rollback()
					responses.FailWithMessage("缺少题目选项", c)
					return
				}

				for _, option := range question.CaseItemQuestionOption {
					caseItemQuestionOption := &model.CaseItemQuestionOption{
						QuestionId:  caseItemQuestion.QuestionId,
						OptionValue: option.OptionValue,
					}

					caseItemQuestionOption, err = caseItemQuestionOptionDao.AddCaseItemQuestionOption(tx, caseItemQuestionOption)
					if err != nil {
						tx.Rollback()
						responses.FailWithMessage(err.Error(), c)
						return
					}
				}
			}
		}
	}

	// 获取模块
	maps = make(map[string]interface{})
	maps["case_item_id"] = caseItemId
	caseItemModels, err := caseItemModelDao.GetCaseItemModelList(maps)
	if err != nil {
		tx.Rollback()
		responses.FailWithMessage("操作失败", c)
		return
	}

	if len(caseItemModels) > 0 {
		// 删除该页全部模块
		maps = make(map[string]interface{})
		maps["case_item_id"] = caseItemId
		err = caseItemModelDao.DeleteCaseItemModel(tx, maps)
		if err != nil {
			tx.Rollback()
			responses.FailWithMessage("操作失败", c)
			return
		}
	}

	// 新增模块
	if len(req.CaseItemModel) > 0 {
		for _, v := range req.CaseItemModel {
			caseItemModel := &model.CaseItemModel{
				CaseItemId: caseItem.CaseItemId,
				ModelName:  v.ModelName,
				Content:    v.Content,
			}

			caseItemModel, err = caseItemModelDao.AddCaseItemModel(tx, caseItemModel)
			if err != nil {
				tx.Rollback()
				responses.FailWithMessage(err.Error(), c)
				return
			}
		}
	}

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

// DeleteCaseItem 删除
func (b *CaseItem) DeleteCaseItem(c *gin.Context) {
	id := c.Param("case_item_id")
	if id == "" {
		responses.FailWithMessage("缺少参数", c)
		return
	}

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

	caseItemDao := dao.CaseItemDao{}
	_, err = caseItemDao.GetCaseItemById(caseItemId)
	if err != nil {
		responses.FailWithMessage("数据异常", c)
		return
	}

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

	caseItemQuestionOptionDao := dao.CaseItemQuestionOptionDao{}
	caseItemQuestionDao := dao.CaseItemQuestionDao{}
	caseItemModelDao := dao.CaseItemModelDao{}

	// 获取问题
	maps := make(map[string]interface{})
	maps["case_item_id"] = caseItemId
	caseItemQuestions, err := caseItemQuestionDao.GetCaseItemQuestionList(maps)
	if err != nil {
		tx.Rollback()
		responses.FailWithMessage("操作失败", c)
		return
	}

	statCaseQuestionDao := dao.StatCaseQuestionDao{}
	caseUserAnswerDao := dao.CaseUserAnswerDao{}
	for _, question := range caseItemQuestions {
		if question.QuestionType == 1 || question.QuestionType == 2 || question.QuestionType == 4 {
			// 删除对应答题记录
			maps = make(map[string]interface{})
			maps["question_id"] = question.QuestionId
			err := statCaseQuestionDao.DeleteStatCaseQuestion(tx, maps)
			if err != nil {
				tx.Rollback()
				responses.FailWithMessage("操作失败", c)
				return
			}

			maps = make(map[string]interface{})
			maps["question_id"] = question.QuestionId
			err = caseItemQuestionOptionDao.DeleteCaseItemQuestionOption(tx, maps)
			if err != nil {
				tx.Rollback()
				responses.FailWithMessage("操作失败", c)
				return
			}
		}

		// 删除问题
		err = caseItemQuestionDao.DeleteCaseItemQuestionById(tx, question.QuestionId)
		if err != nil {
			tx.Rollback()
			responses.FailWithMessage("操作失败", c)
			return
		}

		// 删除用户答题记录
		maps = make(map[string]interface{})
		maps["question_id"] = question.QuestionId
		err := caseUserAnswerDao.DeleteCaseUserAnswer(tx, maps)
		if err != nil {
			tx.Rollback()
			responses.FailWithMessage("操作失败", c)
			return
		}
	}

	// 获取模块
	maps = make(map[string]interface{})
	maps["case_item_id"] = caseItemId
	caseItemModels, err := caseItemModelDao.GetCaseItemModelList(maps)
	if err != nil {
		tx.Rollback()
		responses.FailWithMessage("操作失败", c)
		return
	}

	if len(caseItemModels) > 0 {
		// 删除该页全部模块
		maps = make(map[string]interface{})
		maps["case_item_id"] = caseItemId
		err = caseItemModelDao.DeleteCaseItemModel(tx, maps)
		if err != nil {
			tx.Rollback()
			responses.FailWithMessage("操作失败", c)
			return
		}
	}

	// 删除病例明细
	err = caseItemDao.DeleteCaseItemById(tx, caseItemId)
	if err != nil {
		tx.Rollback()
		responses.FailWithMessage("操作失败", c)
		return
	}

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