package controller

import (
	"blazing/common/data"
	"blazing/common/socket/errorcode"
	"blazing/logic/service/common"
	"blazing/logic/service/player"
	"blazing/logic/service/task"
	"blazing/modules/player/model"

	"github.com/pointernil/bitset32"
)

const (
	masterCupTaskID        uint32 = 111
	masterCupRewardItemMin uint32 = 80000000
	masterCupRewardItemMax uint32 = 80000015
)

var masterCupRewardElementOrder = [...]uint32{1, 2, 3, 5, 11, 4, 6, 7, 9}

var masterCupRequiredItems = map[uint32][]ItemS{
	8: {
		{ItemId: 80000001, ItemCnt: 100},
		{ItemId: 80000002, ItemCnt: 20},
		{ItemId: 80000003, ItemCnt: 20},
		{ItemId: 80000005, ItemCnt: 20},
		{ItemId: 80000011, ItemCnt: 20},
	},
	7: {
		{ItemId: 80000001, ItemCnt: 20},
		{ItemId: 80000002, ItemCnt: 20},
		{ItemId: 80000003, ItemCnt: 100},
		{ItemId: 80000005, ItemCnt: 20},
		{ItemId: 80000011, ItemCnt: 20},
	},
	1: {
		{ItemId: 80000001, ItemCnt: 20},
		{ItemId: 80000002, ItemCnt: 100},
		{ItemId: 80000003, ItemCnt: 20},
		{ItemId: 80000005, ItemCnt: 20},
		{ItemId: 80000011, ItemCnt: 20},
	},
}

// DASHIbei 处理控制器请求。
func (h Controller) DASHIbei(req *C2s_MASTER_REWARDS, c *player.Player) (result *S2C_MASTER_REWARDS, err errorcode.ErrorCode) {
	_ = req
	result = &S2C_MASTER_REWARDS{}
	items := c.Service.Item.Get(masterCupRewardItemMin, masterCupRewardItemMax)
	result.Reward = buildMasterCupRewards(items)

	return
}

// DASHIbeiR 处理控制器请求。
func (h Controller) DASHIbeiR(req *C2s_MASTER_REWARDSR, c *player.Player) (result *S2C_MASTER_REWARDSR, err errorcode.ErrorCode) {
	result = &S2C_MASTER_REWARDSR{}

	requiredItems, ok := masterCupRequiredItems[req.ElementType]
	if !ok {
		return nil, errorcode.ErrorCode(errorcode.ErrorCodes.ErrSystemError)
	}

	taskInfo := task.GetTaskInfo(int(masterCupTaskID), int(req.ElementType))
	if taskInfo == nil {
		return nil, errorcode.ErrorCodes.ErrNeedCompleteTaskForPrize
	}

	if !hasEnoughMasterCupItems(c, requiredItems) {
		return nil, errorcode.ErrorCode(errorcode.ErrorCodes.ErrInsufficientItems)
	}

	result.ItemList = make([]data.ItemInfo, 0, len(taskInfo.ItemList))
	taskData, taskErr := c.Service.Task.GetTask(masterCupTaskID)
	if taskErr != nil {
		return nil, errorcode.ErrorCode(errorcode.ErrorCodes.ErrSystemError)
	}

	progress := bitset32.From(taskData.Data)
	if progress.Test(uint(req.ElementType)) {
		return nil, errorcode.ErrorCode(errorcode.ErrorCodes.ErrAwardAlreadyClaimed)
	}

	if err := consumeMasterCupItems(c, requiredItems); err != nil {
		return nil, errorcode.ErrorCode(errorcode.ErrorCodes.ErrInsufficientItems)
	}
	progress.Set(uint(req.ElementType))
	taskData.Data = progress.Bytes()
	if taskErr = c.Service.Task.SetTask(taskData); taskErr != nil {
		return nil, errorcode.ErrorCode(errorcode.ErrorCodes.ErrSystemError)
	}

	if taskInfo.Pet != nil {
		c.Service.Pet.PetAdd(taskInfo.Pet, 0)
		result.CaptureTime = taskInfo.Pet.CatchTime
		result.PetTypeId = taskInfo.Pet.ID
	}

	appendMasterCupRewardItems(c, result, taskInfo.ItemList)

	return
}

// ItemS 定义请求或响应数据结构。
type ItemS struct {
	ItemId  uint32
	ItemCnt uint32
}

func buildMasterCupRewards(items []model.Item) []uint32 {
	itemCounts := make(map[uint32]uint32, len(items))
	for _, item := range items {
		itemCounts[item.ItemId] = uint32(item.ItemCnt)
	}

	rewards := make([]uint32, len(masterCupRewardElementOrder))
	for i, elementType := range masterCupRewardElementOrder {
		rewards[i] = itemCounts[masterCupRewardItemMin+elementType]
	}

	return rewards
}

func hasEnoughMasterCupItems(c *player.Player, requiredItems []ItemS) bool {
	for _, item := range requiredItems {
		if c.Service.Item.CheakItem(item.ItemId) < int64(item.ItemCnt) {
			return false
		}
	}

	return true
}

func consumeMasterCupItems(c *player.Player, requiredItems []ItemS) error {
	for _, item := range requiredItems {
		if err := c.Service.Item.UPDATE(item.ItemId, -int(item.ItemCnt)); err != nil {
			return err
		}
	}
	return nil
}

func appendMasterCupRewardItems(c *player.Player, result *S2C_MASTER_REWARDSR, itemList []data.ItemInfo) {
	for _, item := range itemList {
		if c.ItemAdd(item.ItemId, item.ItemCnt) {
			result.ItemList = append(result.ItemList, item)
		}
	}
}

// C2s_MASTER_REWARDS 定义请求或响应数据结构。
type C2s_MASTER_REWARDS struct {
	Head common.TomeeHeader `cmd:"2611" struc:"skip"` //玩家登录
}

// OutInfo 表示地图热度的出站消息
type S2C_MASTER_REWARDS struct {
	ReLen  uint32   `struc:"sizeof=Reward"`
	Reward []uint32 `json:"Reward"`
}

// C2s_MASTER_REWARDSR 定义请求或响应数据结构。
type C2s_MASTER_REWARDSR struct {
	Head        common.TomeeHeader `cmd:"2612" struc:"skip"` //玩家登录
	ElementType uint32
}

// OutInfo 表示地图热度的出站消息
type S2C_MASTER_REWARDSR struct {
	BounsID     uint32
	PetTypeId   uint32
	CaptureTime uint32

	ItemListLen uint32          `struc:"sizeof=ItemList"`
	ItemList    []data.ItemInfo `json:"Reward"`
}