package main

import (
	"fmt"
	"math/rand"
	"strconv"
	"time"

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

	"mongo.games.com/game/common"
	"mongo.games.com/game/model"
	"mongo.games.com/game/protocol/bag"
	"mongo.games.com/game/srvdata"
)

func CSBagInfo(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSBagInfoHandler Process recv ", data)
	if msg, ok := data.(*bag.CSBagInfo); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warn("CSBagInfoHandler p == nil")
			return nil
		}
		platform := p.GetPlatform()
		if platform == nil {
			return nil
		}
		//nowLocation := int(msg.NowLocation - 1)
		tp := msg.GetTp() // 道具类型
		bagInfo := BagMgrSingleton.GetBagInfo(p.SnId)
		pack := &bag.SCBagInfo{RetCode: bag.OpResultCode_OPRC_Sucess, BagNumMax: BagItemMax}
		if bagInfo != nil {
			for _, v := range bagInfo.BagItem {
				item := srvdata.GameItemMgr.Get(p.Platform, v.ItemId)
				if item != nil && v.ItemNum > 0 && (tp <= 0 || item.GetType() == tp) /*&& (nowLocation == -1 || (nowLocation < len(item.ShowLocation) && item.ShowLocation[nowLocation] == 1))*/ {
					pack.Infos = append(pack.Infos, &bag.ItemInfo{
						ItemId:     v.ItemId,
						ItemNum:    v.ItemNum,
						ObtainTime: v.ObtainTime,
					})
				}
			}
		}
		logger.Logger.Trace("SCBagInfo:", pack)
		p.SendToClient(int(bag.SPacketID_PACKET_ALL_BAG_INFO), pack)
	}
	return nil
}

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

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

	platform := p.GetPlatform()
	if platform == nil {
		return nil
	}

	if common.Config.IsDevMode {
		if msg.GetOpt() == -1 {
			items := []*model.Item{{
				ItemId:  msg.ItemId,
				ItemNum: int64(msg.ItemNum),
			}}
			BagMgrSingleton.AddItems(&model.AddItemParam{
				Platform: p.Platform,
				SnId:     p.SnId,
				Change:   items,
				GainWay:  common.GainWay_ItemUse,
				Operator: "system",
				Remark:   "测试",
			})
			return nil
		}
	}

	pack := &bag.SCUpBagInfo{RetCode: bag.OpResultCode_OPRC_Error, Opt: msg.GetOpt()}
	send := func() {
		p.SendToClient(int(bag.SPacketID_PACKET_ALL_BAG_USE), pack)
		logger.Logger.Tracef("SCUpBagInfo: %v", pack)
	}

	item := BagMgrSingleton.GetItem(p.SnId, msg.ItemId)
	if item == nil || msg.ItemNum <= 0 || item.ItemNum < int64(msg.ItemNum) || len(item.Effect) != ItemMax || p.SnId == msg.AcceptSnId {
		send()
		return nil
	}

	var isCanOp int32
	if msg.NowEffect == 0 { //竖版
		isCanOp = item.Effect0[msg.Opt]
	} else if msg.NowEffect == 1 { //横版
		isCanOp = item.Effect[msg.Opt]
	}

	if isCanOp == 0 {
		logger.Logger.Trace("道具没有操作权限", msg.ItemId)
		send()
		return nil
	}

	ts := time.Now().Unix()

	switch msg.Opt {
	case ItemCanUse:
		logger.Logger.Trace("道具使用", msg.ItemId)

		items := map[int32]*model.Item{}
		var useFunc func()
		saleFunc := func(gainWay int32, oper, remark string) {
			if gainWay == 0 {
				gainWay = common.GainWay_ItemUse
			}
			if oper == "" {
				oper = "player"
			}
			if remark == "" {
				remark = "道具使用"
			}
			// 使用道具，减少道具
			BagMgrSingleton.AddItems(&model.AddItemParam{
				Platform: p.Platform,
				SnId:     p.SnId,
				Change: []*model.Item{
					{
						ItemId:  item.ItemId,
						ItemNum: int64(-msg.ItemNum),
					},
				},
				GainWay:  gainWay,
				Operator: oper,
				Remark:   remark,
			})
			pack.RetCode = bag.OpResultCode_OPRC_Sucess
			pack.NowItemId = item.ItemId
			pack.NowItemNum = item.ItemNum
		}
		gainFunc := func(gainWay int32, oper, remark string) {
			for i := 0; i < int(msg.ItemNum); i++ {
				useFunc()
			}
			if gainWay == 0 {
				gainWay = common.GainWay_ItemUse
			}
			if oper == "" {
				oper = "player"
			}
			if remark == "" {
				remark = "道具使用"
			}
			if len(items) > 0 {
				var itemArr []*model.Item
				for _, v := range items {
					itemArr = append(itemArr, v)
				}
				BagMgrSingleton.AddItems(&model.AddItemParam{
					Platform: p.Platform,
					SnId:     p.SnId,
					Change:   itemArr,
					GainWay:  gainWay,
					Operator: oper,
					Remark:   remark,
				})
				for _, v := range itemArr {
					pack.Infos = append(pack.Infos, &bag.ItemInfo{
						ItemId:     v.ItemId,
						ItemNum:    v.ItemNum,
						ObtainTime: v.ObtainTime,
					})
				}
				if gainWay == common.GainWay_Collect {
					for _, v := range items {
						tp1 := int32(-1)
						if v.ItemId == common.ItemIDCoin {
							tp1 = model.SystemFreeGive_CoinType_Coin
						} else if v.ItemId == common.ItemIDDiamond {
							tp1 = model.SystemFreeGive_CoinType_Diamond
						}
						if !p.IsRob && tp1 >= 0 {
							LogChannelSingleton.WriteMQData(
								model.GenerateSystemFreeGive(p.SnId, p.Name, p.Platform, p.Channel, model.SystemFreeGive_CollectBox, tp1, v.ItemNum))
						}
					}
				}
			}
		}

		switch item.ItemId {
		case common.ItemIDGiftBox:
			saleFunc(0, "", "")
			useFunc = func() {
				sum := 0
				for _, v := range srvdata.PBDB_GiftBoxMgr.Datas.GetArr() {
					sum += int(v.GetRate())
				}
				if sum > 0 {
					n := 0
					i := rand.Intn(sum)
					for _, v := range srvdata.PBDB_GiftBoxMgr.Datas.GetArr() {
						n += int(v.GetRate())
						if i < n {
							for k, vv := range v.ItemID {
								if vv > 0 {
									item, ok := items[int32(k)]
									if !ok {
										items[int32(k)] = &model.Item{
											ItemId:     int32(k),
											ItemNum:    vv,
											ObtainTime: ts,
										}
									} else {
										item.ItemNum += vv
									}
								}
							}
							break
						}
					}
				}
			}
			gainFunc(0, "", "")

		case common.ItemIDCollectBox:
			saleFunc(0, "", "")
			useFunc = func() {
				sum := 0
				for _, v := range srvdata.PBDB_CollectBoxMgr.Datas.GetArr() {
					sum += int(v.GetRate())
				}
				if sum > 0 {
					n := 0
					i := rand.Intn(sum)
					for _, v := range srvdata.PBDB_CollectBoxMgr.Datas.GetArr() {
						n += int(v.GetRate())
						if i < n {
							for k, vv := range v.ItemID {
								if vv > 0 {
									item, ok := items[int32(k)]
									if !ok {
										items[int32(k)] = &model.Item{
											ItemId:     int32(k),
											ItemNum:    vv,
											ObtainTime: ts,
										}
									} else {
										item.ItemNum += vv
									}
								}
							}
							break
						}
					}
				}
			}
			gainFunc(common.GainWay_Collect, "player", "集卡活动")

		default:
			logger.Logger.Warnf("道具使用未定义", msg.ItemId)
		}

	case ItemCanGive:
		logger.Logger.Trace("道具赠送", msg.ItemId)
		acceptPlayer := PlayerMgrSington.GetPlatformPlayerBySnId(p.Platform, msg.AcceptSnId)
		if acceptPlayer != nil {
			logger.Logger.Trace("道具赠送成功", msg.ItemId)
			remark := fmt.Sprintf("赠送给玩家(%v)", msg.AcceptSnId)
			BagMgrSingleton.AddMailByItem(p.Platform, p.SnId, p.Name, msg.AcceptSnId, msg.ShowId, []int32{msg.ItemId, msg.ItemNum})
			BagMgrSingleton.AddItems(&model.AddItemParam{
				Platform: p.Platform,
				SnId:     p.SnId,
				Change: []*model.Item{
					{
						ItemId:  item.ItemId,
						ItemNum: int64(-msg.ItemNum),
					},
				},
				GainWay:  common.GainWay_ItemMove,
				Operator: "player",
				Remark:   remark,
			})
			pack.RetCode = bag.OpResultCode_OPRC_Sucess
			pack.NowItemId = msg.ItemId
			pack.NowItemNum = item.ItemNum
		} else {
			task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
				return model.GetPlayerBaseInfo(p.Platform, msg.AcceptSnId)
			}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
				aPlayer := data.(*model.PlayerBaseInfo)
				if data != nil && aPlayer != nil {
					logger.Logger.Trace("道具赠送成功", msg.ItemId)
					remark := fmt.Sprintf("赠送给玩家(%v)", msg.AcceptSnId)
					BagMgrSingleton.AddMailByItem(p.Platform, p.SnId, p.Name, msg.AcceptSnId, msg.ShowId, []int32{msg.ItemId, msg.ItemNum})
					BagMgrSingleton.AddItems(&model.AddItemParam{
						Platform: p.Platform,
						SnId:     p.SnId,
						Change: []*model.Item{
							{
								ItemId:  item.ItemId,
								ItemNum: int64(-msg.ItemNum),
							},
						},
						GainWay:  common.GainWay_ItemMove,
						Operator: "player",
						Remark:   remark,
					})
					pack.RetCode = bag.OpResultCode_OPRC_Sucess
					pack.NowItemId = msg.ItemId
					pack.NowItemNum = item.ItemNum
				} else {
					pack.RetCode = bag.OpResultCode_OPRC_NotPlayer
				}
				send()
			}), "GetPlayerBaseInfo").Start()
			return nil
		}

	case ItemCanSell:
		logger.Logger.Trace("道具出售", msg.ItemId)
		if msg.ItemNum > 0 {
			remark := "道具出售" + fmt.Sprintf("%v-%v", msg.ItemId, msg.ItemNum)
			_, _, isF := BagMgrSingleton.AddItems(&model.AddItemParam{
				Platform: p.Platform,
				SnId:     p.SnId,
				Change: []*model.Item{
					{
						ItemId:  item.ItemId,
						ItemNum: int64(-msg.ItemNum),
					},
				},
				GainWay:  common.GainWay_Item_Sale,
				Operator: "player",
				Remark:   remark,
			})
			if isF {
				pack.RetCode = bag.OpResultCode_OPRC_Sucess
				if item.SaleGold > 0 {
					n := int64(item.SaleGold) * int64(msg.ItemNum)
					if item.SaleType == 1 {
						p.AddCoin(n, 0, common.GainWay_Item_Sale, "sys", remark)
						pack.Coin = n
					} else if item.SaleType == 2 {
						p.AddDiamond(n, 0, common.GainWay_Item_Sale, "sys", remark)
						pack.Diamond = n
					}
				}
				pack.NowItemId = item.ItemId
				pack.NowItemNum = item.ItemNum
			}
		}

	case ItemCanExchange:
		logger.Logger.Trace("道具兑换", msg.ItemId)
		itemInfo := srvdata.GameItemMgr.Get(p.Platform, msg.ItemId)
		if itemInfo == nil || itemInfo.Type != common.ItemTypeChange {
			pack.RetCode = bag.OpResultCode_OPRC_NotChange
			send()
			return nil
		}
		bagInfo, _, isF := BagMgrSingleton.AddItems(&model.AddItemParam{
			Platform: p.Platform,
			SnId:     p.SnId,
			Change: []*model.Item{
				{
					ItemId:  msg.GetItemId(),
					ItemNum: -1,
				},
			},
			GainWay:  common.GainWayItemChange,
			Operator: "system",
			Remark:   "背包内使用兑换",
		})
		if isF {
			pack.RetCode = bag.OpResultCode_OPRC_Sucess
			pack.NowItemId = item.ItemId
			pack.NowItemNum = item.ItemNum
			//获取兑换码
			BagMgrSingleton.ItemExchangeCard(p, msg.ItemId, int32(itemInfo.Num), msg.CardType, bagInfo.LogId)
		}

	case ItemCanFen:
		logger.Logger.Trace("道具分解", msg.ItemId)
		itemInfo := srvdata.GameItemMgr.Get(p.Platform, msg.ItemId)
		if msg.ItemNum > 0 && itemInfo != nil {
			_, _, isF := BagMgrSingleton.AddItems(&model.AddItemParam{
				Platform: p.Platform,
				SnId:     p.SnId,
				Change: []*model.Item{
					{
						ItemId:  msg.GetItemId(),
						ItemNum: int64(-msg.GetItemNum()),
					},
				},
				GainWay:  common.GainWayItemFen,
				Operator: "system",
				Remark:   fmt.Sprintf("道具分解%v", msg.GetItemId()),
			})
			if isF {
				pack.RetCode = bag.OpResultCode_OPRC_Sucess
				var changeItems []*model.Item
				for k, v := range itemInfo.GetGain() {
					if v > 0 {
						changeItems = append(changeItems, &model.Item{
							ItemId:  int32(k),
							ItemNum: v * int64(msg.GetItemNum()),
						})
					}
				}
				BagMgrSingleton.AddItems(&model.AddItemParam{
					Platform: p.Platform,
					SnId:     p.SnId,
					Change:   changeItems,
					Cost: []*model.Item{
						{
							ItemId:  msg.GetItemId(),
							ItemNum: int64(msg.GetItemNum()),
						},
					},
					GainWay:  common.GainWayItemFenGain,
					Operator: "system",
					Remark:   "道具分解获得",
				})
				pack.NowItemId = item.ItemId
				pack.NowItemNum = item.ItemNum
			}
		}
	}
	send()
	return nil
}

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

	p := PlayerMgrSington.GetPlayer(sid)
	if p == nil {
		return nil
	}

	pack := &bag.SCExchangeList{
		Tp: msg.Tp,
	}

	for _, v := range srvdata.PBDB_PropExchangeMgr.Datas.GetArr() {
		if v.GetGroup() != msg.Tp {
			continue
		}
		var costItems, gainItems []*bag.PropInfo
		for k, v := range v.GetCost() {
			costItems = append(costItems, &bag.PropInfo{
				ItemId:  int32(k),
				ItemNum: v,
			})
		}
		for k, v := range v.GetGain() {
			gainItems = append(gainItems, &bag.PropInfo{
				ItemId:  int32(k),
				ItemNum: v,
			})
		}
		pack.Infos = append(pack.Infos, &bag.ExchangeInfo{
			Id:        v.Id,
			CostItems: costItems,
			GainItems: gainItems,
		})
	}

	p.SendToClient(packetid, pack)
	logger.Logger.Tracef("SCExchangeList:%v", pack)
	return nil
}

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

	p := PlayerMgrSington.GetPlayer(sid)
	if p == nil {
		return nil
	}

	pack := &bag.SCPropExchange{
		RetCode: bag.OpResultCode_OPRC_Error,
	}
	send := func(code bag.OpResultCode) {
		pack.RetCode = code
		p.SendToClient(packetid, pack)
		logger.Logger.Tracef("SCPropExchange:%v", pack)
	}

	info := srvdata.PBDB_PropExchangeMgr.GetData(msg.Id)
	if info == nil {
		send(bag.OpResultCode_OPRC_IdErr)
		return nil
	}
	// 检查背包是否足够
	var items []*model.Item
	var costItems []*model.Item
	for k, v := range info.GetCost() {
		item := BagMgrSingleton.GetItem(p.SnId, int32(k))
		if item == nil || item.ItemNum < v {
			send(bag.OpResultCode_OPRC_UseUp)
			return nil
		}
		info := srvdata.GameItemMgr.Get(p.Platform, int32(k))
		if info != nil {
			costItems = append(costItems, &model.Item{
				ItemId:  int32(k),
				ItemNum: v,
			})
		}
	}
	for k, v := range info.GetGain() {
		info := srvdata.GameItemMgr.Get(p.Platform, int32(k))
		if info != nil {
			items = append(items, &model.Item{
				ItemId:  int32(k),
				ItemNum: v,
			})
		}
	}
	// 扣除背包物品
	for _, item := range costItems {
		BagMgrSingleton.AddItems(&model.AddItemParam{
			Platform: p.Platform,
			SnId:     p.SnId,
			Change: []*model.Item{
				{
					ItemId:  item.ItemId,
					ItemNum: -item.ItemNum,
				},
			},
			GainWay:  common.GainWayItemCollectExchange,
			Operator: "system",
			Remark:   "集卡活动兑换",
		})
	}
	// 增加背包物品
	BagMgrSingleton.AddItems(&model.AddItemParam{
		Platform: p.Platform,
		SnId:     p.SnId,
		Change:   items,
		GainWay:  common.GainWayItemCollectExchange,
		Operator: "system",
		Remark:   "集卡活动兑换",
	})
	for _, v := range items {
		pack.Items = append(pack.Items, &bag.PropInfo{
			ItemId:  v.ItemId,
			ItemNum: v.ItemNum,
		})

		tp1 := int32(-1)
		if v.ItemId == common.ItemIDCoin {
			tp1 = model.SystemFreeGive_CoinType_Coin
		} else if v.ItemId == common.ItemIDDiamond {
			tp1 = model.SystemFreeGive_CoinType_Diamond
		}
		if !p.IsRob && tp1 >= 0 {
			LogChannelSingleton.WriteMQData(
				model.GenerateSystemFreeGive(p.SnId, p.Name, p.Platform, p.Channel, model.SystemFreeGive_CollectBoxSwap, tp1, v.ItemNum))
		}
	}

	send(bag.OpResultCode_OPRC_Sucess)
	return nil
}

// 兑换娃娃
func CSDollChange(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	msg, ok := data.(*bag.CSDollChange)
	if !ok {
		return nil
	}
	p := PlayerMgrSington.GetPlayer(sid)
	if p == nil {
		return nil
	}
	pack := &bag.SCDollChange{}
	for _, item := range msg.Items {
		if item.ItemId == 0 {
			continue
		}
		info := srvdata.GameItemMgr.Get(p.Platform, item.ItemId)
		if info == nil {
			continue
		}
		if info.Type != common.ItemTypeDoll {
			continue
		}

		bagInfo, rest, isF := BagMgrSingleton.AddItems(&model.AddItemParam{
			Platform: p.Platform,
			SnId:     p.SnId,
			Change: []*model.Item{
				{
					ItemId:  item.GetItemId(),
					ItemNum: 1,
				},
			},
			GainWay:  common.GainWayItemBagChangeDoll,
			Operator: "system",
			Remark:   "背包内使用兑换娃娃卡",
		})
		logger.Logger.Trace("背包内使用兑换娃娃卡 bagInfo = ", bagInfo)
		pack.RetCode = rest
		if isF {
			task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
				dollLog := model.NewDbBagChangeDoll(p.Platform, p.SnId, item.ItemId, 1, 0, "", msg.Addr, msg.UserName, msg.UserTel)
				return model.InsertDbBagChangeDollLog(dollLog)
			}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
				if data != nil {
					logger.Logger.Errorf("CSDollChange err: %v", data)
				}
			}), "CSDollChange").Start()

		}
	}
	p.SendToClient(int(bag.SPacketID_PACKET_SC_DollChange), pack)
	return nil
}

// 兑换娃娃记录
func CSDollChangeLog(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	p := PlayerMgrSington.GetPlayer(sid)
	if p == nil {
		return nil
	}
	task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
		return model.GetDbBagChangeDollLog(p.Platform, p.SnId)
	}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
		pack := &bag.SCDillChangeLog{}
		if data != nil {
			for _, log := range data.([]*model.BagChangeDollLog) {
				info := &bag.DillChangeLogInfo{}
				info.ItemId = log.ItemId
				info.ItemNum = log.ItemNum
				info.State = log.State
				info.UserName = log.UserName
				info.UserTel = log.UserTel
				info.Addr = log.Addr
				info.CreateTs = strconv.FormatInt(log.CreateTs, 10)
				info.OpTs = strconv.FormatInt(log.OpTs, 10)
				info.Remark = log.Remark
				pack.Info = append(pack.Info, info)
			}
		}
		p.SendToClient(int(bag.SPacketID_PACKET_SC_DollChangeLog), pack)

	}), "CSDollChangeLog").Start()
	return nil
}

func init() {
	// 查看背包
	common.Register(int(bag.SPacketID_PACKET_ALL_BAG_INFO), &bag.CSBagInfo{}, CSBagInfo)
	// 道具操作
	common.Register(int(bag.SPacketID_PACKET_ALL_BAG_USE), &bag.CSUpBagInfo{}, CSUpBagInfo)
	// 兑换列表
	common.Register(int(bag.SPacketID_PACKET_ExchangeList), &bag.CSExchangeList{}, CSExchangeList)
	// 道具兑换
	common.Register(int(bag.SPacketID_PACKET_PropExchange), &bag.CSPropExchange{}, CSPropExchange)
	//兑换娃娃
	common.Register(int(bag.SPacketID_PACKET_CS_DollChange), &bag.CSDollChange{}, CSDollChange)
	//兑换娃娃记录
	common.Register(int(bag.SPacketID_PACKET_CS_DollChangeLog), &bag.CSDollChangeLog{}, CSDollChangeLog)
}