package logic

import (
	"strings"

	csv "gitee.com/liuxuezhan/mylib/GameServer/CSV"
	"gitee.com/liuxuezhan/mylib/GameServer/cache"
	"gitee.com/liuxuezhan/mylib/GameServer/observer"
	"gitee.com/liuxuezhan/mylib/GameServer/oss"
	proto "gitee.com/liuxuezhan/mylib/Protocol"
	"gitee.com/liuxuezhan/mylib/Utils/common"
)

func checkCanSupply(userData *cache.Info, cashType, supplyType uint32) bool {
	if userData == nil {
		return false
	}
	mainCityLevel := userData.GetMainCityLevel()
	supplyAsset := userData.GetSupplyAsset()
	if supplyAsset == nil {
		return false
	}
	csvConfig := csv.Mgr.CSV_Logistics.GetEntryPtr(int64(mainCityLevel))
	if csvConfig == nil {
		return false
	}
	if supplyType == 1 && supplyAsset.GetFreeTimes() <= 0 {
		return false
	}
	totalNum := csv.GetGameConfigValueUint32("SupplyLimit")
	var tmpNum uint32
	for _, v := range supplyAsset.GetTotleTimes() {
		tmpNum += uint32(v.GetY())
	}

	if tmpNum >= totalNum {
		return false
	}
	supplyOn := csv.GetGameConfigValueString("SupplyOn")
	for _, v := range strings.Split(supplyOn, "|") {
		list := strings.Split(v, " ")
		if len(list) != 2 {
			continue
		}
		tmpType := common.StringToUint32(list[0])
		tmpLevel := common.StringToUint32(list[1])
		if tmpType == cashType && mainCityLevel >= tmpLevel {
			return true
		}
	}
	return false
}
func getSupplyCost(supplyAsset *proto.ST_Asset_Supply_PB, cashType uint32, csvConfig *csv.CF_Logistics_DataEntry) uint32 {
	if cashType-1 >= uint32(len(supplyAsset.GetBuyTimes())) {
		return 0
	}
	var (
		base, inc, supplyNum uint32
	)
	base = uint32(csvConfig.GemBase)
	inc = uint32(csvConfig.GemIncrement)
	supplyNum = uint32(supplyAsset.BuyTimes[cashType-1].GetY())
	count := base + inc*supplyNum
	if count > uint32(csvConfig.GemMaximum) {
		count = uint32(csvConfig.GemMaximum)
	}
	return count
}
func getSupplyNum(supplyAsset *proto.ST_Asset_Supply_PB, cashType uint32, csvConfig *csv.CF_Logistics_DataEntry) uint32 {
	if cashType-1 >= uint32(len(supplyAsset.GetTotleTimes())) {
		return 0
	}
	var (
		base, inc, supplyNum uint32
	)
	switch cashType {
	case uint32(proto.CashType_CASH_TYPE_1):
		base = uint32(csvConfig.MetalBase)
		inc = uint32(csvConfig.MetalIncrement)
	case uint32(proto.CashType_CASH_TYPE_2):
		base = uint32(csvConfig.CrystalBase)
		inc = uint32(csvConfig.CrystalIncrement)
	case uint32(proto.CashType_CASH_TYPE_3):
		base = uint32(csvConfig.GasBase)
		inc = uint32(csvConfig.GasIncrement)
	case uint32(proto.CashType_CASH_TYPE_4):
		base = uint32(csvConfig.DeuteriumBase)
		inc = uint32(csvConfig.DeuteriumIncrement)
	case uint32(proto.CashType_CASH_TYPE_5):
		base = uint32(csvConfig.ColaBase)
		inc = uint32(csvConfig.ColaIncrement)
	case uint32(proto.CashType_CASH_TYPE_EXPEDITION):
		base = uint32(csvConfig.ColaBase)
		inc = uint32(csvConfig.ColaIncrement)
	default:
		return 0
	}
	supplyNum = uint32(supplyAsset.TotleTimes[cashType-1].GetY())
	return base + inc*supplyNum
}
func getCritInfo() uint32 {
	crit := csv.GetGameConfigValueString("SupplyCrit")
	randNum := common.GetRandomNum(10000)
	for _, v := range strings.Split(crit, "|") {
		list := strings.Split(v, " ")
		if len(list) != 2 {
			return 1
		}
		if randNum <= common.StringToInt32(list[1]) {
			return common.StringToUint32(list[0])
		}
		randNum -= common.StringToInt32(list[1])
	}
	return 1
}

func Supply(uid uint64, cashType, supplyType uint32) *proto.ST_ResourceObtain_Supply_PB {
	if cashType > uint32(proto.CashType_CASH_TYPE_5) {
		return nil
	}
	userData := cache.GetCharinfo(uid)
	if userData == nil {
		return nil
	}
	if !checkCanSupply(userData, cashType, supplyType) {
		return nil
	}
	var cost uint32
	supplyAsset := userData.GetSupplyAsset()
	csvConfig := csv.Mgr.CSV_Logistics.GetEntryPtr(int64(userData.GetMainCityLevel()))
	getNum := getSupplyNum(supplyAsset, cashType, csvConfig)
	crit := getCritInfo()
	if supplyType == 1 {
		userData.ReduceSupplyFreeTimes(1)
	} else {
		cost = getSupplyCost(supplyAsset, cashType, csvConfig)
		if !userData.CheckMoney(uint64(cost)) {
			return nil
		}
		userData.ReduceMoney(uint64(cost), oss.ReduceCashSrcTypeSupply)
		userData.AddSupplyBuyTimes(cashType)
	}
	userData.AddSupplyTotalTimes(cashType)
	userData.AddCash(cashType, uint64(getNum*crit), oss.AddCashSrcTypeSupply)

	observer.ObserverSingleton.AsyncNotify(observer.SupplyEvent, []interface{}{userData, uint32(0), uint32(1)})
	observer.ObserverSingleton.AsyncNotify(observer.ActivityTaskSupplyEvent, []interface{}{userData, uint32(1)})
	newOssLogistics(uid, cost, cashType, csvConfig, crit, uint32(getNum*crit))
	userData.SyncAchievementAdd(cache.Src1001, uint64(1))

	activityDropItems := processDropActivity(userData, int32(proto.DropActivityType_DAT_Supply), 0, 1)
	dropList := &proto.ST_Vector4IntList_PB{}
	for _, v := range activityDropItems {
		AddItem(userData, v.GetItemId(), v.GetItemNum(), oss.AddCashSrcDropActivity)
		dropList.Reward = append(dropList.Reward, &proto.ST_Vector4Int_PB{
			X: proto.SetInt32(int32(proto.VectorType_VT_ITEM)),
			Y: proto.SetInt32(int32(v.GetItemId())),
			Z: proto.SetInt32(0),
			W: proto.SetInt32(int32(v.GetItemNum())),
		})
	}

	return &proto.ST_ResourceObtain_Supply_PB{
		Multiple: proto.SetUint32(crit),
		CashType: proto.SetUint32(cashType),
		Count:    proto.SetUint64(uint64(getNum * crit)),
		DropList: dropList,
	}

}