package service

import (
	"blazing/cool"
	"blazing/modules/base/service"
	"blazing/modules/player/model"
	"context"
	"fmt"
)

// 获取精灵信息   0是仓库,1是放生
func (s *PetService) PetInfo(flag int) []model.Pet {
	var tt []model.Pet
	err := s.dbm(s.Model).Where("free", flag).Scan(&tt)
	if err != nil {
		return []model.Pet{}
	}

	for i := 0; i < len(tt); i++ {
		tt[i].Data.CatchTime = tt[i].CatchTime

	}

	return tt

}
func (s *PetService) PetCount(flag int) int {

	ret, err := s.dbm(s.Model).Where("free", flag).Count()

	if err != nil {
		return 0
	}

	return ret

}

func (s *PetService) UPdateFree(ctime uint32, free uint32) {

	s.dbm(s.Model).Where("catch_time", ctime).Data(

		"free", free,
	).Update()

}
func (s *PetService) UPdate(t model.PetInfo) {

	m := s.dbm(s.Model).Where("catch_time", t.CatchTime)
	var tt *model.Pet
	m.Scan(&tt)
	if tt == nil {
		return
	}
	tt.Data = t
	_, err := m.OnConflict("catch_time").Update(tt)
	if err != nil {
		panic(err)
	}
}
func (s *PetService) PetInfo_One(cachetime uint32) *model.Pet {

	m := s.dbm(s.Model).Where("catch_time", cachetime)
	var tt *model.Pet

	m.Scan(&tt)
	if tt == nil {
		return nil
	}

	tt.Data.CatchTime = tt.CatchTime
	return tt
}
func (s *PetService) PetInfo_One_ohter(userid, cachetime uint32) model.Pet {

	m := s.dbm(s.Model).Where("catch_time", cachetime)
	var tt model.Pet

	m.Scan(&tt)
	tt.Data.CatchTime = tt.CatchTime
	return tt
}
func (s *PetService) PetInfo_One_Unscoped(cachetime uint32) *model.Pet {

	m := s.dbm(s.Model).Where("catch_time", cachetime).Unscoped()
	var tt *model.Pet

	m.Scan(&tt)
	if tt == nil {
		return nil

	}
	tt.Data.CatchTime = tt.CatchTime
	return tt
}
func (s *PetService) Pet_del(cachetime uint32) {

	s.dbm(s.Model).Where("catch_time", cachetime).Delete()

}
func (s *PetService) Pet_LEVEL_all() []model.Pet {
	var tt []model.Pet

	s.dbm(s.Model).Fields().Wheref(`(pp.data->>'Level')::INT > 100`, "array").OrderDesc("(pp.data->>'Level')::INT").Scan(&tt)
	return tt
}

// 精灵真正添加后的捕捉时间才是真正的时间
func (s *PetService) PetAdd(y *model.PetInfo) uint32 {
	if y == nil {
		return 0
	}
	sql := fmt.Sprintf(`
UPDATE %s 
SET max_ts = CASE
    WHEN max_ts < EXTRACT(EPOCH FROM NOW())::INT THEN EXTRACT(EPOCH FROM NOW())::INT
    ELSE max_ts + 1
END
WHERE id = ? AND deleted_at IS NULL
RETURNING max_ts;
`, service.NewBaseSysUserService().Model.TableName())

	// 执行 Raw SQL 并扫描返回值
	ret, _ := cool.DBM(service.NewBaseSysUserService().Model).Raw(sql, s.userid).All()
	//fmt.Println(ret, err)
	y.CatchTime = ret.Array()[0].Uint32()
	m1 := cool.DBM(s.Model).Where("player_id", s.userid)
	var player model.Pet
	player.PlayerID = s.userid
	player.Data = *y
	player.CatchTime = y.CatchTime
	player.Free = 0
	player.IsVip = cool.Config.ServerInfo.IsVip

	_, err := m1.Insert(player)
	if err != nil {
		panic(err)
	}
	return y.CatchTime
}

// func (s *PetService) ModifyBefore(ctx context.Context, method string, param map[string]interface{}) (err error) {
// 	admin := cool.GetAdmin(ctx)
// 	userId := admin.UserId
// 	s.userid = uint32(userId)
// 	// if method == "Update" {

// 	// 	if gconv.Uint(param["free"]) != 0 {
// 	// 		err = fmt.Errorf("修改失败")
// 	// 	}
// 	// 	if userId != gconv.Uint(param["player_id"]) {
// 	// 		err = fmt.Errorf("修改失败")
// 	// 	}

// 	// }

// 	return
// }

type PetService struct {
	BaseService
}

func NewPetService(userid uint32) *PetService {
	return &PetService{
		BaseService: BaseService{
			userid: userid,
			Service: &cool.Service{
				Model: model.NewPet(),
				PageQueryOp: &cool.QueryOp{
					FieldEQ: []string{"player_id", "free"},
					Where: func(ctx context.Context) [][]interface{} {
						var (
							admin  = cool.GetAdmin(ctx)
							userId = admin.UserId
						)
						if userId != 10001 {
							return [][]interface{}{
								{"player_id", userId, true},
								{"free", 1, true},
							}
						} else {
							return [][]interface{}{
								// {"player_id", userId, true},
								// {"free", 1, true},
							}
						}

					},
				},
			},
		},
	}
}