package checkinctrl

import (
	"91porn-server/app/service/checkinser"
	"91porn-server/common"
	"91porn-server/common/stderr"
	"91porn-server/models/v/checkinconfigmod"
	"91porn-server/models/v/checkinprizemod"
	"strings"
	"time"

	"github.com/gin-gonic/gin"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
)

// ========== 签到配置 ==========

// GetCheckinConfig 获取签到配置
func GetCheckinConfig(c *gin.Context) {
	cfg, err := checkinser.GetCheckinConfig()
	if err != nil {
		common.ServeJSON(c, stderr.ErrDbQueryError, nil)
		return
	}
	common.ServeJSON(c, stderr.Success, cfg)
}

type checkinConfigUpdateReq struct {
	Enable              *bool               `json:"enable" bson:"enable,omitempty"`
	Description         *string             `json:"description" bson:"description,omitempty"`
	BackgroundImage     *string             `json:"backgroundImage" bson:"backgroundImage,omitempty"`
	RewardBgVideos      *[]rewardBgVideoReq `json:"rewardBgVideos" bson:"rewardBgVideos,omitempty"`
	IntegerExchangeList *[]giftItemReq      `json:"integerExchangeList" bson:"integerExchangeList,omitempty"`
}

type rewardBgVideoReq struct {
	PrizeType        int    `json:"prizeType" bson:"prizeType"`
	BgMediaUrl       string `json:"bgMediaUrl" bson:"bgMediaUrl"`
	FsResourceId     string `json:"fsResourceId" bson:"fsResourceId"`
	FsResourceStatus string `json:"-" bson:"fsResourceStatus"`
}

type giftItemReq struct {
	Name string `json:"name" bson:"name"`
	Icon string `json:"icon" bson:"icon"`
}

// UpdateCheckinConfig 修改签到配置
func UpdateCheckinConfig(c *gin.Context) {
	var req checkinConfigUpdateReq
	if err := c.ShouldBindJSON(&req); err != nil {
		common.ServeJSON(c, stderr.ErrParamError, err.Error())
		return
	}
	// BgMediaUrl 不以 .m3u8 结尾时自动追加
	// fsResourceId 变更时重置 fsResourceStatus
	if req.RewardBgVideos != nil {
		// 查询当前配置，用于比对 fsResourceId 是否变更
		oldCfg, _ := checkinconfigmod.FindOne(bson.M{})
		oldIdMap := make(map[int]string)     // prizeType -> fsResourceId
		oldStatusMap := make(map[int]string) // prizeType -> fsResourceStatus
		if oldCfg != nil {
			for _, v := range oldCfg.RewardBgVideos {
				oldIdMap[int(v.PrizeType)] = v.FsResourceId
				oldStatusMap[int(v.PrizeType)] = v.FsResourceStatus
			}
		}
		for i := range *req.RewardBgVideos {
			item := &(*req.RewardBgVideos)[i]
			if item.BgMediaUrl != "" && !strings.HasSuffix(item.BgMediaUrl, ".m3u8") {
				item.BgMediaUrl = item.BgMediaUrl + ".m3u8"
			}
			// fsResourceId 不为空且与旧值不同，重置状态让定时任务重新检查
			if item.FsResourceId != "" && item.FsResourceId != oldIdMap[item.PrizeType] {
				item.FsResourceStatus = ""
			} else {
				item.FsResourceStatus = oldStatusMap[item.PrizeType]
			}
		}
	}
	update := bson.M{"$set": req}
	if err := checkinser.UpdateCheckinConfig(update); err != nil {
		common.ServeJSON(c, stderr.ErrDbUpdateError, nil)
		return
	}
	common.ServeJSON(c, stderr.Success, nil)
}

// ========== 签到奖品管理 ==========

type checkinPrizeListReq struct {
	PageNumber int64 `json:"pageNumber" form:"pageNumber"`
	PageSize   int64 `json:"pageSize" form:"pageSize"`
}

// GetCheckinPrizeList 获取签到奖品列表
func GetCheckinPrizeList(c *gin.Context) {
	var req checkinPrizeListReq
	if err := c.ShouldBind(&req); err != nil {
		common.ServeJSON(c, stderr.ErrParamError, nil)
		return
	}
	if req.PageNumber <= 0 {
		req.PageNumber = 1
	}
	if req.PageSize <= 0 {
		req.PageSize = 20
	}
	list, total, err := checkinser.GetCheckinPrizeList(req.PageNumber, req.PageSize)
	if err != nil {
		common.ServeJSON(c, stderr.ErrDbQueryError, nil)
		return
	}
	common.ServeJSON(c, stderr.Success, gin.H{
		"list":  list,
		"total": total,
	})
}

// AddOneCheckinPrize 添加签到奖品
func AddOneCheckinPrize(c *gin.Context) {
	var req checkinprizemod.CheckinPrize
	if err := c.ShouldBindJSON(&req); err != nil {
		common.ServeJSON(c, stderr.ErrParamError, err.Error())
		return
	}
	if err := checkinser.AddCheckinPrize(&req); err != nil {
		common.ServeJSON(c, stderr.ErrDbInsertError, nil)
		return
	}
	common.ServeJSON(c, stderr.Success, nil)
}

type checkinPrizeUpdateReq struct {
	ID string `json:"id"`
	checkinPrizeParams
}

type checkinPrizeParams struct {
	Title       *string                      `json:"title" bson:"title,omitempty"`
	Image       *string                      `json:"image" bson:"image,omitempty"`
	CheckinDays *int64                       `json:"checkinDays" bson:"checkinDays,omitempty"`
	CheckinType *checkinprizemod.CheckinType `json:"checkinType" bson:"checkinType,omitempty"`
	PrizeId     *string                      `json:"prizeId" bson:"prizeId,omitempty"`
	PrizeName   *string                      `json:"prizeName" bson:"prizeName,omitempty"`
	Status      *bool                        `json:"status" bson:"status,omitempty"`
	BigPrize    *bool                        `json:"bigPrize" bson:"bigPrize,omitempty"`
}

// UpdateOneCheckinPrize 更新签到奖品
func UpdateOneCheckinPrize(c *gin.Context) {
	var req checkinPrizeUpdateReq
	if err := c.ShouldBindJSON(&req); err != nil {
		common.ServeJSON(c, stderr.ErrParamError, nil)
		return
	}
	id, err := primitive.ObjectIDFromHex(req.ID)
	if err != nil {
		common.ServeJSON(c, stderr.ErrParamError, "无效的ID")
		return
	}
	now := time.Now()
	updateFields := bson.M{"updatedAt": now}
	if req.Title != nil {
		updateFields["title"] = *req.Title
	}
	if req.Image != nil {
		updateFields["image"] = *req.Image
	}
	if req.CheckinDays != nil {
		updateFields["checkinDays"] = *req.CheckinDays
	}
	if req.CheckinType != nil {
		updateFields["checkinType"] = *req.CheckinType
	}
	if req.PrizeId != nil {
		pid, err := primitive.ObjectIDFromHex(*req.PrizeId)
		if err == nil {
			updateFields["prizeId"] = pid
		}
	}
	if req.PrizeName != nil {
		updateFields["prizeName"] = *req.PrizeName
	}
	if req.Status != nil {
		updateFields["status"] = *req.Status
	}
	if req.BigPrize != nil {
		updateFields["bigPrize"] = *req.BigPrize
	}
	if err := checkinser.UpdateCheckinPrize(id, updateFields); err != nil {
		common.ServeJSON(c, stderr.ErrDbUpdateError, nil)
		return
	}
	common.ServeJSON(c, stderr.Success, nil)
}

type delReq struct {
	ID string `json:"id"`
}

// DelOneCheckinPrize 删除签到奖品
func DelOneCheckinPrize(c *gin.Context) {
	var req delReq
	if err := c.ShouldBindJSON(&req); err != nil {
		common.ServeJSON(c, stderr.ErrParamError, nil)
		return
	}
	id, err := primitive.ObjectIDFromHex(req.ID)
	if err != nil {
		common.ServeJSON(c, stderr.ErrParamError, "无效的ID")
		return
	}
	if err := checkinser.DeleteCheckinPrize(id); err != nil {
		common.ServeJSON(c, stderr.ErrDbDeleteError, nil)
		return
	}
	common.ServeJSON(c, stderr.Success, nil)
}

// ========== 签到历史记录 ==========

type userCheckinsReq struct {
	PageNumber int64     `json:"pageNumber" form:"pageNumber"`
	PageSize   int64     `json:"pageSize" form:"pageSize"`
	UserId     uint64    `json:"userId" form:"userId"`
	Start      time.Time `json:"start" form:"start"`
	End        time.Time `json:"end" form:"end"`
}

// GetUserCheckins 获取用户签到记录列表
func GetUserCheckins(c *gin.Context) {
	var req userCheckinsReq
	if err := c.ShouldBind(&req); err != nil {
		common.ServeJSON(c, stderr.ErrParamError, nil)
		return
	}
	if req.PageNumber <= 0 {
		req.PageNumber = 1
	}
	if req.PageSize <= 0 {
		req.PageSize = 20
	}
	filter := bson.M{}
	if req.UserId != 0 {
		filter["userId"] = req.UserId
	}
	if !req.Start.IsZero() && !req.End.IsZero() {
		filter["createdAt"] = bson.M{"$gte": req.Start, "$lte": req.End}

	}
	list, total, err := checkinser.GetUserCheckinList(filter, req.PageNumber, req.PageSize)
	if err != nil {
		common.ServeJSON(c, stderr.ErrDbQueryError, nil)
		return
	}
	common.ServeJSON(c, stderr.Success, gin.H{
		"list":  list,
		"total": total,
	})
}

// DelOneUserCheckin 删除用户签到记录
func DelOneUserCheckin(c *gin.Context) {
	var req delReq
	if err := c.ShouldBindJSON(&req); err != nil {
		common.ServeJSON(c, stderr.ErrParamError, nil)
		return
	}
	id, err := primitive.ObjectIDFromHex(req.ID)
	if err != nil {
		common.ServeJSON(c, stderr.ErrParamError, "无效的ID")
		return
	}
	if err := checkinser.DeleteUserCheckin(id); err != nil {
		common.ServeJSON(c, stderr.ErrDbDeleteError, nil)
		return
	}
	common.ServeJSON(c, stderr.Success, nil)
}