package model

import (
	"errors"
	"fmt"
	"github.com/go-redis/redis/v8"
	"gorm.io/gorm"
	"samba/pkg/log"
	"samba/stub"
	"samba/util/rdbkey"
	"samba/util/util"
)

const (
	// 最小幸运值
	minLuckyPoint = -100
	// 最大幸运值
	maxLuckyPoint = 100
)

type UserLuckyPoint struct {
	Uid int64 `json:"uid" gorm:"column:uid"`
	// 是否是幸运用户
	LuckyUser bool `json:"lucky_user" gorm:"column:lucky_user"`
	// 玩家基础幸运值
	LuckyPoint int `json:"lucky_point" gorm:"column:lucky_point"`
	// truco的幸运值
	TrucoLP int `json:"truco_lp" gorm:"column:truco_lp"`
	// cacheta幸运值
	CachetaLP int `json:"cacheta_lp" gorm:"column:cacheta_lp"`
}

func (u *UserLuckyPoint) GetLuckyPoint(name string) (point int) {
	defer func() {
		if point > maxLuckyPoint {
			point = maxLuckyPoint
		}
		if point < minLuckyPoint {
			point = minLuckyPoint
		}
	}()

	switch name {
	case stub.Truco:
		return u.TrucoLP + u.LuckyPoint
	case stub.Cacheta:
		return u.CachetaLP + u.LuckyPoint
	default:
		return u.LuckyPoint
	}
}

func (u *UserLuckyPoint) SetLuckyPoint(name string, point int) {
	switch name {
	case stub.Truco:
		u.TrucoLP = point
	case stub.Cacheta:
		u.CachetaLP = point
	default:
		u.LuckyPoint = point
	}
}

func (u *UserLuckyPoint) IsLuckyUser() bool {
	return u.LuckyUser
}

func (u *UserLuckyPoint) TableName() string {
	return "t_user_lucky_point"
}

type UserLuckyPointOp struct {
	db  *gorm.DB
	rdb *redis.Client
}

func NewUserLuckyPointOp() *UserLuckyPointOp {
	return &UserLuckyPointOp{
		db:  userDB,
		rdb: rdbBaseInfo,
	}
}

// AddByGameType 根据游戏类型增加幸运值
func (op *UserLuckyPointOp) AddByGameType(uid int64, name string, inc int) (updated int, err error) {
	var column string
	switch name {
	case stub.Truco:
		column = "truco_lp"
	case stub.Cacheta:
		column = "cacheta_lp"
	case "base":
		column = "lucky_point"
	default:
		return 0, fmt.Errorf("game type %s not support", name)
	}
	model := &UserLuckyPoint{Uid: uid}
	err = op.db.Model(model).
		Where("uid = ?", uid).
		Update(column, gorm.Expr(`
        CASE 
            WHEN `+column+` + ? > ? THEN ? 
            WHEN `+column+` + ? < ? THEN ? 
            ELSE `+column+` + ? 
        END`, inc, maxLuckyPoint, maxLuckyPoint,
			inc, minLuckyPoint, minLuckyPoint,
			inc)).Error
	if err != nil {
		return 0, err
	}
	err = op.db.Where("uid = ?", uid).First(model).Error
	if err != nil {
		return 0, err
	}
	op.insertRedis(model)
	switch name {
	case stub.Truco:
		return model.TrucoLP, nil
	case stub.Cacheta:
		return model.CachetaLP, nil
	default:
		return model.LuckyPoint, nil
	}

}

// Add 增加用户的基础幸运值
func (op *UserLuckyPointOp) Add(uid int64, inc int) (updated int, err error) {
	return op.AddByGameType(uid, "base", inc)
}

// Load 加载用户幸运值
func (op *UserLuckyPointOp) Load(uid int64) (*UserLuckyPoint, error) {
	lp, err := util.Redis2Struct[UserLuckyPoint](op.rdb, rdbkey.UserLuckyPointKey(uid))
	if err == nil {
		return lp, err
	}

	lp = &UserLuckyPoint{Uid: uid}
	err = op.db.Where("uid = ?", uid).First(lp).Error
	if err != nil {
		if !errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, fmt.Errorf("load user lucky point err:%v", err)
		}
		if err := op.db.Where("uid = ?", uid).Create(lp).Error; err != nil {
			return nil, fmt.Errorf("create user lucky point err:%v", err)
		}
	}
	op.insertRedis(lp)
	return lp, nil
}

func (op *UserLuckyPointOp) insertRedis(p *UserLuckyPoint) {
	err := util.Struct2Redis(op.rdb, rdbkey.UserLuckyPointKey(p.Uid), p)
	if err != nil {
		log.Error(fmt.Sprintf("insert redis error: %s", err))
		return
	}
}