package controller

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

type ArticleScience struct{}

// GetArticleSciencePage 获取科普文章列表-分页
func (b *ArticleScience) GetArticleSciencePage(c *gin.Context) {
	ArticleScienceRequest := requests.ArticleScienceRequest{}
	req := ArticleScienceRequest.GetArticleSciencePage
	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
	}

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

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

	// 获取分类数据
	articleScienceDao := dao.ArticleScienceDao{}
	articleScience, total, err := articleScienceDao.GetArticleSciencePageSearch(req, req.Page, req.PageSize)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 处理返回值
	g := dto.GetArticleScienceListDto(articleScience)

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

// GetArticleScience 获取科普文章详情
func (b *ArticleScience) GetArticleScience(c *gin.Context) {
	id := c.Param("article_id")
	if id == "" {
		responses.FailWithMessage("缺少参数", c)
		return
	}

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

	// 获取科普文章数据
	articleScienceDao := dao.ArticleScienceDao{}
	articleScience, err := articleScienceDao.GetArticleScienceById(articleId)
	if err != nil {
		responses.FailWithMessage("异常", c)
		return
	}

	// 处理返回值
	g := dto.GetArticleScienceDto(articleScience)

	// 加载文章来源
	articleScienceSourceDao := dao.ArticleScienceSourceDao{}
	articleScienceSource, err := articleScienceSourceDao.GetArticleScienceSourceById(articleScience.SourceId)
	if err != nil {
		responses.FailWithMessage("异常", c)
		return
	}
	g.LoadArticleScienceSource(articleScienceSource)

	// 加载文章分类
	articleScienceClassDao := dao.ArticleScienceClassDao{}
	maps := make(map[string]interface{})
	maps["article_id"] = articleScience.ArticleId
	articleScienceClass, err := articleScienceClassDao.GetArticleScienceClassList(maps)
	if len(articleScienceClass) > 0 {
		basicArticleClassDao := dao.BasicArticleClassDao{}
		for _, class := range articleScienceClass {
			basicArticleClass, err := basicArticleClassDao.GetBasicArticleClassById(class.BasicClassId)
			if err != nil {
				responses.FailWithMessage("异常", c)
				return
			}

			// 加载文章分类
			g.LoadArticleScienceClass(basicArticleClass)
		}

	}

	responses.OkWithData(g, c)
}

// AddArticleScience 新增科普文章
func (b *ArticleScience) AddArticleScience(c *gin.Context) {
	articleScienceRequest := requests.ArticleScienceRequest{}
	req := articleScienceRequest.AddArticleScience
	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.ArticleScienceClass {
		if err := global.Validate.Struct(item); err != nil {
			responses.FailWithMessage(utils.Translate(err), c)
			return
		}
	}

	// 检测来源是否正确
	sourceId, err := strconv.ParseInt(req.SourceId, 10, 64)
	if err != nil {
		responses.FailWithMessage("来源错误", c)
		return
	}

	articleScienceSourceDao := dao.ArticleScienceSourceDao{}
	articleScienceSource, err := articleScienceSourceDao.GetArticleScienceSourceById(sourceId)
	if err != nil {
		responses.FailWithMessage("来源错误", c)
		return
	}

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

	articleScience := &model.ArticleScience{
		ArticleTitle:  req.ArticleTitle,
		ArticleStatus: req.ArticleStatus,
		IsTop:         req.IsTop,
		ArticleImage:  utils.RemoveOssDomain(req.ArticleImage),
		SourceId:      articleScienceSource.SourceId,
		ArticleUrl:    req.ArticleUrl,
	}

	articleScienceDao := dao.ArticleScienceDao{}
	articleScience, err = articleScienceDao.AddArticleScience(tx, articleScience)
	if err != nil {
		tx.Rollback()
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 新增文章分类
	articleScienceClassDao := dao.ArticleScienceClassDao{}
	for _, i2 := range req.ArticleScienceClass {
		basicClassId, err := strconv.ParseInt(i2.BasicClassId, 10, 64)
		if err != nil {
			responses.FailWithMessage("分类错误", c)
			return
		}

		articleScienceClass := &model.ArticleScienceClass{
			ArticleId:    articleScience.ArticleId,
			BasicClassId: basicClassId,
		}
		articleScienceClass, err = articleScienceClassDao.AddArticleScienceClass(tx, articleScienceClass)
		if err != nil {
			tx.Rollback()
			responses.FailWithMessage(err.Error(), c)
			return
		}
	}

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

// PutArticleScience 修改科普文章
func (b *ArticleScience) PutArticleScience(c *gin.Context) {
	articleScienceRequest := requests.ArticleScienceRequest{}
	req := articleScienceRequest.PutArticleScience
	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
	}

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

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

	// 获取科普分类数据
	articleScienceDao := dao.ArticleScienceDao{}
	articleScience, err := articleScienceDao.GetArticleScienceById(articleId)
	if err != nil {
		responses.FailWithMessage("分类异常", c)
		return
	}

	// 修改值
	articleScienceData := make(map[string]interface{})

	// 文章标题
	if req.ArticleTitle != articleScience.ArticleTitle {
		articleScienceData["article_title"] = req.ArticleTitle
	}

	// 文章状态
	if req.ArticleStatus != articleScience.ArticleStatus {
		articleScienceData["article_status"] = req.ArticleStatus
	}

	// 是否置顶
	if req.IsTop != articleScience.IsTop {
		articleScienceData["is_top"] = req.IsTop
	}

	// 文章图片
	articleImage := utils.RemoveOssDomain(req.ArticleImage)
	if articleImage != articleScience.ArticleImage {
		articleScienceData["article_image"] = req.ArticleImage
	}

	// 文章来源
	sourceId, err := strconv.ParseInt(req.SourceId, 10, 64)
	if err != nil {
		responses.Fail(c)
		return
	}

	if sourceId != articleScience.SourceId {
		articleScienceData["source_id"] = req.SourceId
	}

	// 文章地址
	if req.ArticleUrl != articleScience.ArticleUrl {
		articleScienceData["article_url"] = req.ArticleUrl
	}

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

	if len(articleScienceData) > 0 {
		err = articleScienceDao.EditArticleScienceById(tx, articleId, articleScienceData)
		if err != nil {
			tx.Rollback()
			responses.FailWithMessage("操作失败", c)
			return
		}

		tx.Commit()
	}

	// 删除文章分类
	articleScienceClassDao := dao.ArticleScienceClassDao{}
	maps := make(map[string]interface{})
	maps["article_id"] = articleScience.ArticleId
	err = articleScienceClassDao.DeleteArticleScienceClass(tx, maps)
	if err != nil {
		tx.Rollback()
		responses.FailWithMessage("操作失败", c)
		return
	}

	// 新增文章分类
	for _, i2 := range req.ArticleScienceClass {
		basicClassId, err := strconv.ParseInt(i2.BasicClassId, 10, 64)
		if err != nil {
			tx.Rollback()
			responses.FailWithMessage("分类错误", c)
			return
		}

		articleScienceClass := &model.ArticleScienceClass{
			ArticleId:    articleScience.ArticleId,
			BasicClassId: basicClassId,
		}
		articleScienceClass, err = articleScienceClassDao.AddArticleScienceClass(tx, articleScienceClass)
		if err != nil {
			tx.Rollback()
			responses.FailWithMessage(err.Error(), c)
			return
		}
	}

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

// PutArticleScienceStatus 操作科普文章状态
func (b *ArticleScience) PutArticleScienceStatus(c *gin.Context) {
	articleScienceRequest := requests.ArticleScienceRequest{}
	req := articleScienceRequest.PutArticleScienceStatus
	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
	}

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

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

	// 获取科普分类数据
	articleScienceDao := dao.ArticleScienceDao{}
	articleScience, err := articleScienceDao.GetArticleScienceById(articleId)
	if err != nil {
		responses.FailWithMessage("分类异常", c)
		return
	}

	// 检测状态
	if articleScience.ArticleStatus == req.ArticleStatus {
		responses.Ok(c)
		return
	}

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

	articleScienceData := make(map[string]interface{})
	articleScienceData["article_status"] = req.ArticleStatus
	err = articleScienceDao.EditArticleScienceById(tx, articleId, articleScienceData)
	if err != nil {
		tx.Rollback()
		responses.FailWithMessage("操作失败", c)
		return
	}

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

// PutArticleScienceTop 操作科普文章置顶状态
func (b *ArticleScience) PutArticleScienceTop(c *gin.Context) {
	articleScienceRequest := requests.ArticleScienceRequest{}
	req := articleScienceRequest.PutArticleScienceTop
	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
	}

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

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

	// 获取科普分类数据
	articleScienceDao := dao.ArticleScienceDao{}
	articleScience, err := articleScienceDao.GetArticleScienceById(articleId)
	if err != nil {
		responses.FailWithMessage("分类异常", c)
		return
	}

	// 检测置顶状态
	if articleScience.IsTop == req.IsTop {
		responses.Ok(c)
		return
	}

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

	articleScienceData := make(map[string]interface{})
	articleScienceData["is_top"] = req.IsTop
	err = articleScienceDao.EditArticleScienceById(tx, articleId, articleScienceData)
	if err != nil {
		tx.Rollback()
		responses.FailWithMessage("操作失败", c)
		return
	}

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