package game

import (
	"fmt"
	"server/GoUtil"
	cardCfg "server/conf/card"
	limitedTimeEventCfg "server/conf/limitedTimeEvent"
	mergeDataCfg "server/conf/mergeData"
	"server/game/mod/item"
	"server/game/mod/order"
	"server/game/mod/sevenLogin"
	"server/msg"
)

func UnitEndlessReward(p *Player) error {
	EndlessMod := p.PlayMod.getEndlessMod()
	if EndlessMod == nil {
		return fmt.Errorf("EndlessMod is nil")
	}
	Item, err := EndlessMod.GetReward()
	if err != nil {
		return err
	}
	if Item == nil {
		return fmt.Errorf("item is nil")
	}
	err = p.HandleItem(Item, msg.ITEM_POP_LABEL_Endless.String())
	if err != nil {
		return err
	}
	return nil
}

func UnitChessShop(p *Player) error {
	ChessMod := p.PlayMod.getChessMod()
	if ChessMod == nil {
		return fmt.Errorf("ChessMod is nil")
	}
	ChessMod.EmitList = make(map[int]int)
	ChessMod.EmitList[83] = 1
	ChessMod.EmitList[125] = 1
	ChargeMod := p.PlayMod.getChargeMod()
	if ChargeMod == nil {
		return fmt.Errorf("ChargeMod is nil")
	}
	p.PlayMod.save()
	p.PlayMod.ClearData(p)
	ChargeMod.TriggerChargeUnlock(4, ChessMod.GetEmitList())
	b := ChargeMod.BackData()
	fmt.Println(b)
	return nil
}

func UnitOrder(p *Player) error {
	OrderMod := p.PlayMod.getOrderMod()
	ChessMod := p.PlayMod.getChessMod()
	BaseMod := p.PlayMod.getBaseMod()
	OrderMod.OrderList = make(map[int]order.Order)
	for i := 0; i < 1000; i++ {
		err := OrderMod.CreateNormalOrder(BaseMod.GetLevel(), ChessMod.GetEmitList(), BaseMod.EnergyMul)
		if err != nil {
			return err
		}
	}
	return nil
}

func UnitChess(p *Player) error {
	ChessMod := p.PlayMod.getChessMod()
	Emit := ChessMod.GetEmitList()
	ChargeMod := p.PlayMod.getChargeMod()
	ChargeMod.InitChessShop(Emit)
	return nil
}

func UnitDecorate(p *Player) error {
	PlayerBaseMod := p.GetPlayerBaseMod()
	PlayerBaseMod.Data.Level = 6
	PlayerBaseMod.Data.Exp = 50
	PlayerBaseMod.AddExp(p, 100)
	return nil
}

func UnitSevenMonthReward(p *Player) error {
	i := sevenLogin.F()
	fmt.Print(i)
	return nil
}

func UnitAllCard(p *Player) error {
	CardMod := p.PlayMod.getCardMod()
	Item, err := CardMod.OpenCardPack(5)
	if err != nil {
		return err
	}
	fmt.Print(Item)
	return nil
}

func UnitLimitProgress(p *Player) error {
	LimitedTimeEventMod := p.PlayMod.getLimitedTimeEventMod()
	LimitedTimeEventMod.Progress = 5
	LimitedTimeEventMod.ZeroUpdate(7)
	LimitedTimeEventMod.AddProgress(6)
	return nil
}

func UnitLimitedTimeEvent(p *Player) error {
	LimitedTimeEventMod := p.PlayMod.getLimitedTimeEventMod()
	CardMod := p.PlayMod.getCardMod()
	ChessMod := p.PlayMod.getChessMod()
	mergeList := []int{1, 2, 30}
	ChestRainItems := make([]*item.Item, 0)
	AddItem, CardLv, ProductLv, Jackpot := LimitedTimeEventMod.GetChestReward(mergeList)
	if len(AddItem) > 0 {
		ChestRainItems = AddItem
	}
	JackpotId := 0
	if CardLv > 0 {
		CardId := CardMod.RandCard(CardLv)
		ItemId := cardCfg.GetItemIdByCardId(CardId)
		ChestRainItems = []*item.Item{{Id: ItemId, Num: 1}}
	}
	if ProductLv > 0 {
		Color := order.RandChessColor(ChessMod.GetOrderEmit())
		ChessId := mergeDataCfg.GetChessIdByLvAndColor(ProductLv, Color)
		ChestRainItems = append(ChestRainItems, &item.Item{Id: ChessId, Num: 1})
	}
	if Jackpot > 0 {
		ProbList := limitedTimeEventCfg.GetSenceJackpotProb()
		JackpotId = GoUtil.RandMap(ProbList)
		ChestRainItems = limitedTimeEventCfg.GetSenceJackpotReward(JackpotId)
	}
	fmt.Print(ChestRainItems, JackpotId)
	return nil
}