package main

import (
	"sort"

	"mongo.games.com/goserver/core/logger"
	"mongo.games.com/goserver/core/netlib"

	"mongo.games.com/game/common"
	"mongo.games.com/game/gamesrv/base"
	"mongo.games.com/game/model"
	"mongo.games.com/game/protocol/activity"
	"mongo.games.com/game/srvdata"
)

const (
	PowerMax  = 700000
	PowerInit = 400000
)

var PushCoinItemValue = map[int32]int64{
	common.ItemIDBigCoin: 50000,
	common.ItemIDVCard:   10000,
	common.ItemIDPlum:    30000,
	30011:                100000000, // 话费卡
	common.ItemIDCoin1:   5000,
	common.ItemIDCoin2:   10000,
	common.ItemIDCoin3:   15000,
}

func init() {
	// 推币机活动信息
	common.Register(int(activity.PushCoinPacketID_PACKET_CSPushCoinInfo), activity.CSPushCoinInfo{}, CSPushCoinInfo)
	// 推币机玩家操作
	common.Register(int(activity.PushCoinPacketID_PACKET_CSPushCoinPlayerOp), activity.CSPushCoinPlayerOp{}, CSPushCoinPlayerOp)
}

func CSPushCoinInfo(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	_, ok := data.(*activity.CSPushCoinInfo)
	if !ok {
		return nil
	}

	p := PlayerMgrSington.GetOnlinePlayer(sid)
	if p == nil {
		logger.Logger.Warn("CSPushCoinInfo p == nil")
		return nil
	}

	if p.WelfData == nil {
		logger.Logger.Warn("CSPushCoinInfo p.WelfData == nil")
		return nil
	}

	if p.WelfData.PushCoin == nil {
		p.WelfData.PushCoin = &model.PushCoinData{
			Power:    PowerInit,
			Exchange: make(map[int32]int32),
			Items:    make(map[int32]int64),
		}
	}

	pack := &activity.SCPushCoinInfo{
		ShakeTimes:   p.WelfData.PushCoin.Shake,
		PowerLine:    p.WelfData.PushCoin.Power,
		PowerLineMax: PowerMax,
		RefreshTimes: p.WelfData.PushCoin.Refresh,
	}

	for _, v := range srvdata.PBDB_PropExchangeMgr.Datas.Arr {
		if v.GetGroup() == 2 {
			info := &activity.ExchangeInfo{
				Id:         v.GetId(),
				TotalTimes: int64(v.GetTimes()),
			}
			for kk, vv := range v.GetCost() {
				info.Cost = append(info.Cost, &activity.ItemInfo{
					ItemId:  int32(kk),
					ItemNum: int32(vv),
				})
			}
			sort.Slice(info.Cost, func(i, j int) bool {
				return info.Cost[i].ItemId < info.Cost[j].ItemId
			})
			for kk, vv := range v.GetGain() {
				info.Gain = append(info.Gain, &activity.ItemInfo{
					ItemId:  int32(kk),
					ItemNum: int32(vv),
				})
			}
			sort.Slice(info.Gain, func(i, j int) bool {
				return info.Gain[i].ItemId < info.Gain[j].ItemId
			})
			for kk, vv := range v.GetCustom() {
				if kk == 1 {
					info.ShakeTimes = int32(vv)
				}
			}

			info.Times = int64(v.GetTimes() - p.WelfData.PushCoin.Exchange[v.Id])
			if v.GetTimes() == 0 {
				info.Times = -1
				info.TotalTimes = -1
			}

			pack.ExchangeList = append(pack.ExchangeList, info)
		}
	}

	// 转盘
	for _, v := range srvdata.PBDB_ACTPushCoinMgr.Datas.Arr {
		for kk, vv := range v.GetGain() {
			pack.DrawList = append(pack.DrawList, &activity.DrawInfo{
				Id:      v.GetId(),
				ItemId:  int32(kk),
				ItemNum: int32(vv),
				Coin:    v.GetValue(),
			})
		}
	}

	p.SendToClient(int(activity.PushCoinPacketID_PACKET_SCPushCoinInfo), pack)
	logger.Logger.Trace("SCPushCoinInfo: ", pack)
	return nil
}

func CSPushCoinPlayerOp(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSPushCoinPlayerOpHandler Process recv ", data)
	msg, ok := data.(*activity.CSPushCoinPlayerOp)
	if !ok {
		return nil
	}

	p := PlayerMgrSington.GetOnlinePlayer(sid)
	if p == nil {
		logger.Logger.Warn("CSPushCoinPlayerOp p == nil")
		return nil
	}

	if p.WelfData == nil {
		logger.Logger.Warn("CSPushCoinPlayerOp p.WelfData == nil")
		return nil
	}

	if p.WelfData.PushCoin == nil {
		logger.Logger.Warn("CSPushCoinPlayerOp p.WelfData.PushCoin == nil")
		return nil
	}

	pack := &activity.SCPushCoinPlayerOp{
		OpRetCode: activity.OpResultPushCoinCode_OPRC_PushCoin_Error,
		OpCode:    msg.GetOpCode(),
	}

	switch msg.GetOpCode() {
	case activity.OpCodes_OP_Bet:
		if msg.GetOpParam() != common.ItemIDCoin1 && msg.GetOpParam() != common.ItemIDCoin2 && msg.GetOpParam() != common.ItemIDCoin3 {
			goto here
		}

		item := srvdata.GameItemMgr.Get(p.Platform, int32(msg.GetOpParam()))
		if item == nil {
			goto here
		}

		if p.GetCoin() < item.GetNum() {
			goto here
		}
		pack.BetId = int32(msg.GetOpParam())

		p.AddCoin(-item.GetNum(), common.GainWayPushCoinCost, base.SyncFlag_ToClient, "system", "推币机下注")
		// 增加桌面道具
		AddValue(p, map[int32]int64{common.ItemIDCoin: item.GetNum()})

	case activity.OpCodes_OP_Gain:

		if msg.GetOpParam() == 1 {
			// 有效区
			for _, v := range msg.GetOpItem() {
				id := v.GetItemId()
				val := int64(v.GetItemNum())
				switch v.GetItemId() {
				case common.ItemIDBigCoin, common.ItemIDCoin1, common.ItemIDCoin2, common.ItemIDCoin3:
					val *= srvdata.GameItemMgr.Get(p.Platform, id).GetNum()
					id = common.ItemIDCoin
				}

				if p.WelfData.PushCoin.Items[id] < val {
					logger.Logger.Errorf("获得道具太多: %d, %d", p.WelfData.PushCoin.Items[id], val)
					goto here
				}

				BagMgrSingleton.AddItems(&model.AddItemParam{
					Platform: p.Platform,
					SnId:     p.SnId,
					Change:   []*model.Item{{ItemId: id, ItemNum: val}},
					GainWay:  common.GainWayPushCoinGain,
					Operator: "system",
					Remark:   "推币机掉落获得",
				})
			}
		} else {
			// 无效区

		}

		for _, v := range msg.GetOpItem() {
			// 增加能量条
			AddPower(p, PushCoinItemValue[v.GetItemId()]*int64(v.GetItemNum()))
			// 减少桌面道具
			AddValue(p, map[int32]int64{v.GetItemId(): -int64(v.GetItemNum())})
		}

	case activity.OpCodes_OP_Shake:
		if p.WelfData.PushCoin.Shake < int32(msg.GetOpParam()) {
			goto here
		}
		p.WelfData.PushCoin.Shake -= int32(msg.GetOpParam())

	case activity.OpCodes_OP_Refresh:
		p.WelfData.PushCoin.Refresh++
		// 1个v卡，50个金币，大梅花1个
		p.WelfData.PushCoin.Items = map[int32]int64{
			common.ItemIDVCard: 1,
			common.ItemIDCoin:  50 * 5000,
			common.ItemIDPlum:  1,
		}

	case activity.OpCodes_OP_Exchange:
		d := srvdata.PBDB_PropExchangeMgr.GetData(int32(msg.GetOpParam()))
		if d == nil {
			goto here
		}
		// 兑换次数
		if d.GetTimes() > 0 && p.WelfData.PushCoin.Exchange[d.Id] >= d.GetTimes() {
			goto here
		}

		pack.Exchange = &activity.ExchangeInfo{
			Id: d.Id,
		}
		var cost, gain []*model.Item
		for k, v := range d.GetCost() {
			pack.Exchange.Cost = append(pack.Exchange.Cost, &activity.ItemInfo{
				ItemId:  int32(k),
				ItemNum: int32(v),
			})
			if k == common.ItemIDCoin && p.GetCoin() < v {
				goto here
			}
			cost = append(cost, &model.Item{
				ItemId:  int32(k),
				ItemNum: -v,
			})
		}

		_, _, ok := BagMgrSingleton.AddItems(&model.AddItemParam{
			Platform: p.Platform,
			SnId:     p.SnId,
			Change:   cost,
			Add:      0,
			GainWay:  common.GainWayPushCoinExchangeCost,
			Operator: "system",
			Remark:   "推币机活动兑换消耗",
		})
		if !ok {
			goto here
		}

		for k, v := range d.GetGain() {
			pack.Exchange.Gain = append(pack.Exchange.Gain, &activity.ItemInfo{
				ItemId:  int32(k),
				ItemNum: int32(v),
			})
			gain = append(gain, &model.Item{
				ItemId:  int32(k),
				ItemNum: v,
			})
		}
		BagMgrSingleton.AddItems(&model.AddItemParam{
			Platform: p.Platform,
			SnId:     p.SnId,
			Change:   gain,
			Cost:     cost,
			Add:      0,
			GainWay:  common.GainWatPushCoinExchangeGain,
			Operator: "system",
			Remark:   "推币机活动兑换获得",
		})
		for k, v := range d.GetCustom() {
			if k == 1 {
				pack.Exchange.ShakeTimes = int32(v)
				p.WelfData.PushCoin.Shake += int32(v)
			}
		}

		if p.WelfData.PushCoin.Exchange == nil {
			p.WelfData.PushCoin.Exchange = make(map[int32]int32)
		}
		p.WelfData.PushCoin.Exchange[d.Id]++

	default:
		return nil
	}

	pack.OpRetCode = activity.OpResultPushCoinCode_OPRC_PushCoin_Success

here:
	p.SendToClient(int(activity.PushCoinPacketID_PACKET_SCPushCoinPlayerOp), pack)
	logger.Logger.Trace("SCPushCoinPlayerOp: ", pack)

	return nil
}

func AddPower(p *Player, value int64) {
	if value < 0 {
		return
	}
	p.WelfData.PushCoin.Power += value
	if p.WelfData.PushCoin.Power > PowerMax {
		p.WelfData.PushCoin.Power = PowerMax
	}
	p.SendToClient(int(activity.PushCoinPacketID_PACKET_NotifyPowerLine), &activity.NotifyPowerLine{
		PowerLine:    p.WelfData.PushCoin.Power,
		PowerLineMax: PowerMax,
	})
	if value <= 0 {
		return
	}
	// 抽奖
	Draw(p)
}

func Draw(p *Player) {
	if p.WelfData.PushCoin.Power < PowerMax {
		return
	}
	p.WelfData.PushCoin.Power = 0
	var index int32 = -1
	switch p.WelfData.PushCoin.Dram {
	case 0:
		// 必中大金币
		for _, v := range srvdata.PBDB_ACTPushCoinMgr.Datas.Arr {
			for kk := range v.GetGain() {
				if kk == common.ItemIDBigCoin {
					index = v.GetId()
					break
				}
			}
		}

	case 1:
		// 必中v卡
		for _, v := range srvdata.PBDB_ACTPushCoinMgr.Datas.Arr {
			for kk := range v.GetGain() {
				if kk == common.ItemIDVCard {
					index = v.GetId()
					break
				}
			}
		}

	default:
		var n int32
		rand := common.RandInt(10000)
		for _, v := range srvdata.PBDB_ACTPushCoinMgr.Datas.Arr {
			if rand < int(n+v.GetRate()) {
				index = v.GetId()
				break
			}
			n += v.GetRate()
		}
	}
	p.WelfData.PushCoin.Dram++

	if index >= 0 {
		d := srvdata.PBDB_ACTPushCoinMgr.GetData(index)
		if d != nil {
			pack := &activity.DrawInfo{
				Id:   d.GetId(),
				Coin: d.GetValue(),
			}
			for k, v := range d.GetGain() {
				pack.ItemId = int32(k)
				pack.ItemNum = int32(v)
			}
			if pack.Coin > 0 || pack.ItemId > 0 {
				p.SendToClient(int(activity.PushCoinPacketID_PACKET_NotifyDrawInfo), pack)
				// 增加能量条
				AddPower(p, 0)
			}
		}
	}
}

func AddValue(p *Player, item map[int32]int64) {
	if item == nil {
		return
	}
	if p.WelfData != nil && p.WelfData.PushCoin != nil {
		if p.WelfData.PushCoin.Items == nil {
			p.WelfData.PushCoin.Items = make(map[int32]int64)
		}
		for k, v := range item {
			if v > 0 {
				switch k {
				case common.ItemIDCoin1, common.ItemIDCoin2, common.ItemIDCoin3, common.ItemIDBigCoin:
					p.WelfData.PushCoin.Items[common.ItemIDCoin] += v * srvdata.GameItemMgr.Get(p.Platform, k).GetNum()
				default:
					p.WelfData.PushCoin.Items[k] += v
				}
			}
		}
	}
}