package service

import (
	"blazing/common/data"
	"blazing/cool"
	"blazing/modules/player/model"
	"context"
	"strings"

	dictservice "blazing/modules/dict/service"

	"github.com/gogf/gf/v2/database/gdb"
	"github.com/gogf/gf/v2/errors/gerror"
	"github.com/gogf/gf/v2/frame/g"
)

func (s *ItemService) Exist(itemid uint32) bool {

	var ttt *model.Item
	s.dbm(s.Model).Where("item_id", itemid).Scan(&ttt)

	return ttt != nil

}
func (s *ItemService) Get(min, max uint32) []model.Item {

	var ttt []model.Item
	s.dbm(s.Model).WhereBetween("item_id", min, max).Where("item_cnt >", 0).Scan(&ttt)

	return ttt

}

func (s *ItemService) GetUserItemList(min, max, leftTime uint32) []model.SingleItemInfo {
	var items []model.SingleItemInfo
	s.dbm(s.Model).
		Fields("item_id,item_cnt").
		WhereBetween("item_id", min, max).
		Where("item_cnt >", 0).
		Scan(&items)

	for i := range items {
		items[i].LeftTime = leftTime
	}

	return items
}
func (s *ItemService) UPDATE(id uint32, count int) error {
	if cool.Config.ServerInfo.IsVip != 0 && count < 0 {

		return nil
	}
	if id == 0 {
		return nil
	}
	m := s.dbm(s.Model)
	ok, err := m.Where("item_id", id).Exist()
	if err != nil {
		return err
	}
	if ok {
		updateModel := s.dbm(s.Model).Where("item_id", id)
		if count < 0 {
			updateModel = updateModel.Where("item_cnt + ? >= 0", count)
		}

		result, err := updateModel.Increment("item_cnt", count)
		if err != nil {
			return err
		}

		affected, err := result.RowsAffected()
		if err != nil {
			return err
		}
		if affected == 0 {
			return gerror.New("item update failed: no rows affected")
		}

	} else {
		if count <= 0 {
			return gerror.New("item update failed: cannot insert non-positive item count")
		}
		m := s.dbm(s.Model)
		data := g.Map{
			"player_id": s.userid,
			"item_id":   id,
			"item_cnt":  count,
			"is_vip":    cool.Config.ServerInfo.IsVip,
		}

		_, err := m.Data(data).Insert()
		return err
	}
	return nil
}

// AddItems 批量添加道具，返回本次实际成功添加的奖励明细（保留原始顺序）。
// AddItemsChecked 写入已完成上限校验的批量道具。
func (s *ItemService) AddItemsChecked(items []data.ItemInfo, currentMap map[uint32]int64) ([]data.ItemInfo, error) {
	if len(items) == 0 {
		return nil, nil
	}

	updateCounts := make(map[uint32]int64, len(items))
	insertData := g.List{}
	successItems := make([]data.ItemInfo, 0, len(items))

	for _, item := range items {
		if item.ItemId <= 0 || item.ItemCnt <= 0 {
			continue
		}

		itemID := uint32(item.ItemId)
		successItems = append(successItems, item)
		if _, ok := currentMap[itemID]; ok {
			updateCounts[itemID] += item.ItemCnt
			continue
		}

		currentMap[itemID] = item.ItemCnt
		insertData = append(insertData, g.Map{
			"player_id": s.userid,
			"item_id":   itemID,
			"item_cnt":  item.ItemCnt,
			"is_vip":    cool.Config.ServerInfo.IsVip,
		})
	}

	err := g.DB().Transaction(context.TODO(), func(ctx context.Context, tx gdb.TX) error {
		if len(updateCounts) > 0 {
			if err := s.batchIncrementItems(tx, updateCounts); err != nil {
				return err
			}
		}

		if len(insertData) > 0 {
			if _, err := tx.Model(s.Model).Data(insertData).Insert(); err != nil {
				return err
			}
		}
		return nil
	})
	if err != nil {
		return nil, err
	}

	return successItems, nil
}

func (s *ItemService) AddItems(items []data.ItemInfo) ([]data.ItemInfo, error) {
	if len(items) == 0 {
		return nil, nil
	}

	var (
		itemIDs = make([]uint32, 0, len(items))
		seenIDs = make(map[uint32]struct{}, len(items))
	)

	for _, item := range items {
		if item.ItemId <= 0 || item.ItemCnt <= 0 {
			continue
		}

		itemID := uint32(item.ItemId)
		if _, ok := seenIDs[itemID]; ok {
			continue
		}

		seenIDs[itemID] = struct{}{}
		itemIDs = append(itemIDs, itemID)
	}

	if len(itemIDs) == 0 {
		return nil, nil
	}

	currentItems := s.CheakItemM(itemIDs...)
	currentMap := make(map[uint32]int64, len(currentItems))
	for _, item := range currentItems {
		currentMap[item.ItemId] = item.ItemCnt
	}
	maxMap := dictservice.NewDictInfoService().GetMaxMap(itemIDs...)

	pendingMap := make(map[uint32]int64, len(itemIDs))
	checkedItems := make([]data.ItemInfo, 0, len(items))

	for _, item := range items {
		if item.ItemId <= 0 || item.ItemCnt <= 0 {
			continue
		}

		itemID := uint32(item.ItemId)
		itemMax := maxMap[itemID]
		if itemMax == 0 {
			continue
		}
		if currentMap[itemID]+pendingMap[itemID]+item.ItemCnt > int64(itemMax) {
			continue
		}

		pendingMap[itemID] += item.ItemCnt
		checkedItems = append(checkedItems, item)
	}

	return s.AddItemsChecked(checkedItems, currentMap)
}

func (s *ItemService) batchIncrementItems(tx gdb.TX, itemCounts map[uint32]int64) error {
	var (
		builder strings.Builder
		args    = make([]any, 0, len(itemCounts)*3+2)
		itemIDs = make([]any, 0, len(itemCounts))
	)

	builder.WriteString("UPDATE ")
	builder.WriteString(s.Model.TableName())
	builder.WriteString(" SET item_cnt = CASE item_id ")

	for itemID, itemCnt := range itemCounts {
		builder.WriteString("WHEN ? THEN item_cnt + ? ")
		args = append(args, itemID, itemCnt)
		itemIDs = append(itemIDs, itemID)
	}

	builder.WriteString("ELSE item_cnt END WHERE player_id = ? AND is_vip = ? AND item_id IN (")
	for i := range itemIDs {
		if i > 0 {
			builder.WriteString(",")
		}
		builder.WriteString("?")
	}
	builder.WriteString(")")

	args = append(args, s.userid, cool.Config.ServerInfo.IsVip)
	args = append(args, itemIDs...)

	_, err := tx.Exec(builder.String(), args...)
	return err
}

func (s *ItemService) AddUniqueItems(ids []uint32) ([]uint32, error) {
	if len(ids) == 0 {
		return nil, nil
	}

	currentItems := s.CheakItemM(ids...)
	currentMap := make(map[uint32]int64, len(currentItems))
	for _, item := range currentItems {
		currentMap[item.ItemId] = item.ItemCnt
	}

	updateIDs := make([]uint32, 0, len(ids))
	insertData := g.List{}
	successIDs := make([]uint32, 0, len(ids))

	for _, id := range ids {
		if id == 0 {
			continue
		}

		itemmax := dictservice.NewDictInfoService().GetMax(int64(id))
		if itemmax == 0 {
			continue
		}
		if currentMap[id]+1 > int64(itemmax) {
			continue
		}

		successIDs = append(successIDs, id)
		if _, ok := currentMap[id]; ok {
			updateIDs = append(updateIDs, id)
			continue
		}

		insertData = append(insertData, g.Map{
			"player_id": s.userid,
			"item_id":   id,
			"item_cnt":  1,
			"is_vip":    cool.Config.ServerInfo.IsVip,
		})
	}

	if len(updateIDs) > 0 {
		if _, err := s.dbm(s.Model).WhereIn("item_id", updateIDs).Increment("item_cnt", 1); err != nil {
			return nil, err
		}
	}

	if len(insertData) > 0 {
		if _, err := s.dbm(s.Model).Data(insertData).Insert(); err != nil {
			return nil, err
		}
	}

	return successIDs, nil
}

// func (s *ItemService) UPDATEM(ids map[uint32]int) {
// 	if cool.Config.ServerInfo.IsVip != 0 {

// 		return
// 	}

// 	m := s.dbm(s.Model)
// 	data := g.List{}
// 	for k, v := range ids {
// 		data = append(data, g.Map{
// 			"player_id": s.userid,
// 			"item_id":   k,
// 			"item_cnt":  v,
// 			"is_vip":    cool.Config.ServerInfo.IsVip,
// 		})
// 	}

// 	m.Data(data).Insert()

// }
func (s *ItemService) CheakItem(id uint32) int64 {
	var ttt model.Item
	m := s.dbm(s.Model)

	m.Where("item_id", id).Scan(&ttt)
	return ttt.ItemCnt
}
func (s *ItemService) CheakItemM(id ...uint32) []model.Item {
	var ttt []model.Item
	m := s.dbm(s.Model)

	m.WhereIn("item_id", id).Scan(&ttt)
	return ttt
}

// /添加进来的物品一定是保证存在的
type ItemService struct {
	BaseService
}

func NewItemService(id uint32) *ItemService {
	return &ItemService{

		BaseService: BaseService{userid: id,

			Service: &cool.Service{Model: model.NewPlayerBag(), UniqueKey: map[string]string{
				"player_id": "角色名称不能重复",
			}, PageQueryOp: &cool.QueryOp{
				KeyWordField: []string{"player_id"},
				FieldEQ:      []string{"player_id"},
				Where: func(ctx context.Context) [][]interface{} {
					var (
					//admin = cool.GetAdmin(ctx)
					//userId = admin.UserId
					)
					return [][]interface{}{
						//	{"player_id", userId, true},
						// {"free", 0, true},
					}
				},
			}},
		},
	}

}