package service

import (
	"errors"
	"fmt"
	"github.com/gin-gonic/gin"
	"pure-admin/global"
	"pure-admin/model"
	"pure-admin/model/request"
	"pure-admin/model/response"
	"strconv"
)

func AddBanner(q request.CreateBanner, userId string) error {

	var (
		err   error
		data  *model.Banner
		total int64
	)

	//查询数量限制
	global.MG_DB.Model(&model.Banner{}).Where("status = ?", "1").Count(&total)

	if total >= model.MAX_BANNER_LIMIT {
		return errors.New(fmt.Sprintf("最多可新建%d条banner", model.MAX_BANNER_LIMIT))
	}

	data = &model.Banner{
		Title:    q.Title,
		CoverUrl: q.CoverUrl,
		LinkType: q.LinkType,
		Status:   q.Status,
		CreateBy: userId,
		UpdateBy: userId,
	}
	if q.LinkType == "1" {
		data.Link = q.Link
	} else {
		data.Type = q.Type
		if q.Type == "0101" {
			//查询任务
			data.RelationId = q.RelationId
			data.RelationType = q.RelationType
		}
	}
	_, maxSort := GetBannerMaxSort()
	data.Sort = int(maxSort) + 1
	data.ID = 0

	err = data.New()
	if err != nil {
		return errors.New("创建banner失败")
	}

	return nil
}

func UpdateBanner(q request.UpdateBanner, uuid string) error {
	var (
		err       error
		check     model.Banner
		updateMap map[string]interface{}
	)
	err = global.MG_DB.Model(&model.Banner{}).Where("id = ?", q.ID).First(&check).Error
	if err != nil {
		return errors.New("数据不存在")
	}
	updateMap = map[string]interface{}{
		"title":         q.Title,
		"relation_id":   q.RelationId,
		"relation_type": q.RelationType,
		"cover_url":     q.CoverUrl,
		"link_type":     q.LinkType,
		"link":          q.Link,
		"status":        q.Status,
		"type":          q.Type,
		"update_by":     uuid,
	}

	err = global.MG_DB.Model(&model.Banner{}).Where("id = ?", q.ID).Updates(updateMap).Error
	if err != nil {
		return errors.New("修改失败")
	}

	return nil
}

func GetBannerMaxSort() (err error, total int64) {
	db := global.MG_DB.Model(&model.Banner{}).Select("IFNULL(MAX(sort),0)")
	err = db.Scan(&(total)).Error
	return
}

func DeleteBannerByIds(ids request.IdsReq) (err error) {
	err = global.MG_DB.Model(model.Banner{}).Where("id in (?)", ids.Ids).Unscoped().Delete(&model.Banner{}).Error
	if err != nil {
		return errors.New("删除失败")
	}

	return err
}

func BannerUpData(info request.IdReq, c *gin.Context) error {
	var (
		err    error
		idList []global.BASE_ID_SORT
	)

	err, idList = GetBannerSortList()
	if err != nil {
		return err
	}
	for i := 1; i < len(idList); i++ {
		if idList[i].ID == info.ID {
			sort := idList[i].Sort
			idList[i].Sort = idList[i-1].Sort
			var tmp = make([]global.BASE_ID_SORT, 0)
			tmp = append(tmp, global.BASE_ID_SORT{ID: idList[i].ID, Sort: idList[i].Sort})
			tmp = append(tmp, global.BASE_ID_SORT{ID: idList[i-1].ID, Sort: sort})
			err = updateBannerSort(tmp)
			if err != nil {
				return err
			}
			break
		}
	}

	return err
}

func BannerDownData(info request.IdReq, c *gin.Context) error {
	var (
		err    error
		idList []global.BASE_ID_SORT
	)

	err, idList = GetBannerSortList()
	if err != nil {
		return err
	}
	for i := 0; i < len(idList); i++ {
		if idList[i].ID == info.ID && i < len(idList)-1 {
			sort := idList[i].Sort
			idList[i].Sort = idList[i+1].Sort
			var tmp = make([]global.BASE_ID_SORT, 0)
			tmp = append(tmp, global.BASE_ID_SORT{ID: idList[i].ID, Sort: idList[i].Sort})
			tmp = append(tmp, global.BASE_ID_SORT{ID: idList[i+1].ID, Sort: sort})
			err = updateBannerSort(tmp)
			if err != nil {
				return err
			}
			break
		}
	}
	return err
}

func GetBannerSortList() (err error, list []global.BASE_ID_SORT) {
	db := global.MG_DB.Model(&model.Banner{})

	var idList []global.BASE_ID_SORT
	err = db.Select("id,sort").Order("sort desc").Find(&idList).Error
	return err, idList
}

func updateBannerSort(idList []global.BASE_ID_SORT) error {
	var err error
	for _, val := range idList {
		_ = UpdateBannerSort(val)
		//_ = global.MG_DB.Model(&model.MissionRecommend{}).Where("id=?", val.ID).Update("sort", val.Sort).Error
	}
	return err
}

func UpdateBannerSort(val global.BASE_ID_SORT) error {
	var err error
	_ = global.MG_DB.Model(&model.Banner{}).Where("id=?", val.ID).Update("sort", val.Sort).Error
	return err
}

func GetBannerList(info request.SearchBanner) (err error, list []response.BannerListResponse, total int64) {
	limit := info.PageSize
	offset := info.PageSize * (info.Page - 1)
	db := global.MG_DB.Model(&model.Banner{})

	if info.Title != "" {
		db = db.Where("title LIKE ?", "%"+info.Title+"%")
	}
	if info.Status != "" {
		db = db.Where("status = ?", info.Status)
	}

	err = db.Count(&total).Error
	var res []model.Banner
	var relationIds []int
	var relationMission []model.Mission

	err = db.Select("id,title,cover_url,relation_id,relation_type,link_type,link,type,status,sort").
		Order("sort DESC").Limit(limit).Offset(offset).Find(&res).Error

	if err != nil {
		return err, nil, 0
	}
	for i := 0; i < len(res); i++ {
		if res[i].LinkType == "0" && res[i].Type == "0101" && res[i].RelationId != "" {
			rid, _ := strconv.Atoi(res[i].RelationId)
			relationIds = append(relationIds, rid)
		}
	}

	if len(relationIds) > 0 {
		global.MG_DB.Model(&model.Mission{}).Select("id,title").Where("id in (?)", relationIds).Find(&relationMission)
	}

	for i := 0; i < len(res); i++ {
		//精简字段赋值
		vRes := response.BannerListResponse{
			RelationId:   res[i].RelationId,
			RelationType: res[i].RelationType,
			Title:        res[i].Title,
			CoverUrl:     res[i].CoverUrl,
			LinkType:     res[i].LinkType,
			Link:         res[i].Link,
			Type:         res[i].Type,
			Status:       res[i].Status,
		}

		if len(relationMission) > 0 {
			for _, r := range relationMission {
				mid := strconv.Itoa(int(r.ID))
				if mid == res[i].RelationId {
					vRes.RelationTitle = r.Title
				}
			}
		}

		vRes.ID = res[i].ID
		vRes.SortIndex = offset + i + 1
		list = append(list, vRes)
	}

	return err, list, total
}