package model

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

// 俱乐部创建的玩法信息
type ClubPlayInfo struct {
	ID        int    `gorm:"column:id" json:"id"`
	ClubId    int    `gorm:"column:club_id" json:"club_id"`
	Name      string `gorm:"column:name" json:"name"` // Truco, Buraco, Cacheta
	PlayType  int    `gorm:"column:play_type" json:"play_type"`
	Blind     int64  `gorm:"column:blind" json:"blind"`
	PlayerNum int    `gorm:"column:player_num" json:"player_num"`
	GameNum   int    `gorm:"column:game_num" json:"game_num"`
	Fee       int    `gorm:"column:fee" json:"fee"`
	State     int    `gorm:"column:state" json:"state"`       // 0:删除 1:未删除
	IsValid   int    `gorm:"column:is_valid" json:"is_valid"` // 0:失效 1:生效
	Top       int    `gorm:"column:top" json:"top"`           // 置顶 0:没有置顶 1:置顶
	//CreateTime time.Time `gorm:"column:create_time" json:"create_time"`
}

func (t *ClubPlayInfo) TableName() string {
	return "t_club_play_info"
}

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

func NewClubPlayInfoOp() *ClubPlayInfoOp {
	return &ClubPlayInfoOp{rdb: rdbConfig, db: configDB}
}

func (op *ClubPlayInfoOp) loadPlayInfos(clubId int) ([]*ClubPlayInfo, error) {
	var clubs []*ClubPlayInfo
	result := op.db.Where("club_id = ? And state = 1", clubId).First(&clubs)
	if result.Error != nil && !errors.Is(result.Error, gorm.ErrRecordNotFound) {
		return clubs, result.Error
	}
	return clubs, nil
}

func (op *ClubPlayInfoOp) Create(playInfo *ClubPlayInfo) error {
	playInfo.State = 1
	err := op.db.Create(playInfo).Error
	if err != nil {
		log.Error(fmt.Sprintf("insert sql err:%v, clubPlayInfo:%+v ", err, playInfo))
		return err
	}
	bData, err := json.Marshal(playInfo)
	if err != nil {
		log.Error(fmt.Sprintf("marshal clubPlayInfo err:%v", err))
		return err
	}
	_, err = op.rdb.HSet(context.Background(), rdbkey.ClubPlayInfoKey(playInfo.ClubId), playInfo.ID, string(bData)).Result()
	return err
}

func (op *ClubPlayInfoOp) Delete(playInfo *ClubPlayInfo) error {
	err := op.db.Model(&ClubPlayInfo{}).Where("id = ?", playInfo.ID).Updates(map[string]interface{}{"state": 0}).Error
	if err != nil {
		log.Error(fmt.Sprintf("update sql err:%v, playInfo:%+v ", err, playInfo))
		return err
	}
	err = op.rdb.HDel(context.Background(), rdbkey.ClubPlayInfoKey(playInfo.ClubId), fmt.Sprintf("%v", playInfo.ID)).Err()
	if err != nil {
		log.Error(fmt.Sprintf("del redis key:%v subKey:%v err:%v", rdbkey.ClubPlayInfoKey(playInfo.ClubId), playInfo.ID, err))
		return err
	}
	return nil
}

// 设置是否生效
func (op *ClubPlayInfoOp) SetValid(playInfo *ClubPlayInfo) error {
	err := op.db.Model(&ClubPlayInfo{}).Where("id = ?", playInfo.ID).Updates(map[string]interface{}{"is_valid": playInfo.IsValid}).Error
	if err != nil {
		log.Error(fmt.Sprintf("update sql err:%v, t_club_play_info.id:%v ", err, playInfo.ID))
		return err
	}
	bData, err := json.Marshal(playInfo)
	if err != nil {
		log.Error(fmt.Sprintf("marshal clubPlayInfo err:%v", err))
		return err
	}
	err = op.rdb.HSet(context.Background(), rdbkey.ClubPlayInfoKey(playInfo.ClubId), fmt.Sprintf("%v", playInfo.ID), string(bData)).Err()
	if err != nil {
		log.Error(fmt.Sprintf("del redis key:%v subKey:%v err:%v", rdbkey.ClubPlayInfoKey(playInfo.ClubId), playInfo.ID, err))
		return err
	}
	return nil
}

// 设置是否置顶
func (op *ClubPlayInfoOp) SetTop(playInfo *ClubPlayInfo) error {
	err := op.db.Model(&ClubPlayInfo{}).Where("id = ?", playInfo.ID).Updates(map[string]interface{}{"top": playInfo.Top}).Error
	if err != nil {
		log.Error(fmt.Sprintf("update sql err:%v, t_club_play_info.id:%v ", err, playInfo.ID))
		return err
	}
	bData, err := json.Marshal(playInfo)
	if err != nil {
		log.Error(fmt.Sprintf("marshal clubPlayInfo err:%v", err))
		return err
	}
	err = op.rdb.HSet(context.Background(), rdbkey.ClubPlayInfoKey(playInfo.ClubId), fmt.Sprintf("%v", playInfo.ID), string(bData)).Err()
	if err != nil {
		log.Error(fmt.Sprintf("del redis key:%v subKey:%v err:%v", rdbkey.ClubPlayInfoKey(playInfo.ClubId), playInfo.ID, err))
		return err
	}
	return nil
}

func (op *ClubPlayInfoOp) Update(playInfo *ClubPlayInfo) error {
	if err := op.Delete(playInfo); err != nil {
		return err
	}
	playInfo.ID = 0
	return op.Create(playInfo)
}

func (op *ClubPlayInfoOp) LoadAPlayInfo(clubId int, playGameId int) *ClubPlayInfo {
	str, err := op.rdb.HGet(context.Background(), rdbkey.ClubPlayInfoKey(clubId), fmt.Sprintf("%v", playGameId)).Result()
	if str != "" {
		var playInfo ClubPlayInfo
		if err = json.Unmarshal([]byte(str), &playInfo); err != nil {
			log.Error(fmt.Sprintf("unmarshal ClubPlayInfo error:%v json:%v", err, str))
			return nil
		}
		if playInfo.IsValid == 1 {
			return &playInfo
		} else {
			//log.Debug(fmt.Sprintf("ClubPlayInfo not valid.clubId:%v playGameId:%v redis key:%v", clubId, playGameId, rdbkey.ClubPlayInfoKey(clubId)))
			return &playInfo
		}
	}
	log.Error(fmt.Sprintf("ClubPlayInfo not exist.clubId:%v playGameId:%v redis key:%v", clubId, playGameId, rdbkey.ClubPlayInfoKey(clubId)))

	return nil
}

func (op *ClubPlayInfoOp) Load(clubId int) ([]*ClubPlayInfo, error) {
	var playInfos []*ClubPlayInfo
	maps, err := op.rdb.HGetAll(context.Background(), rdbkey.ClubPlayInfoKey(clubId)).Result()
	if len(maps) > 0 {
		for _, v := range maps {
			var playInfo ClubPlayInfo
			if err = json.Unmarshal([]byte(v), &playInfo); err != nil {
				log.Error(fmt.Sprintf("unmarshal ClubPlayInfo error:%v json:%v", err, v))
			} else {
				playInfos = append(playInfos, &playInfo)
			}
		}
		if len(playInfos) > 0 {
			return playInfos, nil
		}
	}
	playInfos, err = op.loadPlayInfos(clubId)
	if err != nil {
		log.Error(fmt.Sprintf("loadPlayInfos error:%v club:%v", err, clubId))
		return nil, err
	}

	// 回写redis
	var bytesUser []byte
	for _, playInfo := range playInfos {
		bytesUser, err = json.Marshal(playInfo)
		if err != nil {
			return nil, err
		}
		//log.Debug(string(bytesUser))
		err = op.rdb.HSet(context.Background(), rdbkey.ClubPlayInfoKey(clubId), playInfo.ID, bytesUser).Err()
		if err != nil {
			return nil, err
		}
	}

	return playInfos, err
}