package logic

/*
import (
	"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"
	"gitee.com/liuxuezhan/mylib/Utils/wlog"
	"gitee.com/liuxuezhan/mylib/Utils/wtime"
	"github.com/kataras/go-errors"
)

var challengeInterTime = uint64(CSV.GetGameConfigValueUint32("ChallengeTime")) * 86400

func processChallenge(userData *cache.Info) {
	if nil == userData {
		return
	}

	mainCityLevel := userData.GetMainCityLevel()
	if mainCityLevel < CSV.GetGameConfigValueUint32("Challengelimit") {
		return
	}

	timeNow := wtime.GetNow()
	today := wtime.GetTodayZeroClock()
	ret := false
	userData.WithChallengeAsset(false, func(asset *proto.ST_Asset_Challenge_PB) bool {
		// 第一次开启
		challengeEndTime := asset.GetChallageEndTime()
		taskEndTime := asset.GetTaskEndTime()
		if challengeEndTime == 0 {
			resetChallengeTask(asset)
			resetChallengeTarget(asset)
			asset.ChallageEndTime = proto.SetUint64(timeNow + challengeInterTime)
			startChallengeTarget(asset, mainCityLevel)
			ret = true
		} else {
			// 活动进行中
			if challengeEndTime > timeNow {
				// 任务过期
				if taskEndTime > 0 && taskEndTime <= today {
					if checkCanResetTask(asset) {
						// 所有任务奖励全领完 重置任务
						resetChallengeTask(asset)
						ret = true
					}
				}
			} else if challengeEndTime+challengeInterTime > timeNow { // 活动结束阶段
				if taskEndTime != 0 || asset.GetChallengeTarget().GetTargetID() != 0 {
					if checkCanResetChallengeTarget(asset) && checkCanResetTask(asset) {
						resetChallengeTask(asset)
						resetChallengeTarget(asset)
						ret = true
					}
				}
			} else if challengeEndTime+challengeInterTime < timeNow { // 活动再次开启
				// 强制重置任务, 和挑战目标
				resetChallengeTask(asset)
				resetChallengeTarget(asset)
				startChallengeTarget(asset, mainCityLevel)
				asset.ChallageEndTime = proto.SetUint64(timeNow + challengeInterTime)
				ret = true
			}
		}

		return ret
	})

	if ret {
		userData.DirtyAll()
	}
}

func checkCanResetTask(asset *proto.ST_Asset_Challenge_PB) bool {
	for _, v := range asset.GetTasks() {
		if v.GetTaskStatus() == uint32(proto.ChallengeTaskStatus_CTS_Finish) {
			return false
		}
	}

	return true
}

func checkCanResetChallengeTarget(asset *proto.ST_Asset_Challenge_PB) bool {
	if len(asset.GetChallengeTarget().GetRewardList()) > 0 {
		return false
	}

	return true
}

func resetChallengeTask(asset *proto.ST_Asset_Challenge_PB) {
	asset.Tasks = make([]*proto.ST_ChallengeTast_PB, 0)
	asset.CurrentTaskId = proto.SetInt64(0)
	asset.TaskEndTime = proto.SetUint64(0)
}

func resetChallengeTarget(asset *proto.ST_Asset_Challenge_PB) {
	if asset.ChallengeTarget != nil {
		asset.ChallengeTarget.Reset()
	}
}

func startChallengeTarget(asset *proto.ST_Asset_Challenge_PB, mainCityLevel uint32) bool {
	targetID := CSV.GetChallengeTarget(int64(mainCityLevel))
	targetConf := CSV.Mgr.CSV_ChallengeTarget.GetEntryPtr(targetID)
	if targetConf == nil {
		return false
	}

	asset.ChallengeTarget = &proto.ST_ChallengeTarget_PB{
		CurrentScore: proto.SetUint32(0),
		TargetID:     proto.SetInt64(targetID),
		RewardList:   make([]uint32, 0),
	}

	return true
}

func SetChallengeType(uid uint64, challengeType uint32) proto.RetActionType {
	userData := cache.GetCharinfo(uid)
	if nil == userData {
		return proto.RetActionType_RAT_INPUT_ERROR
	}

	mainCityLevel := userData.GetMainCityLevel()
	if mainCityLevel < 5 {
		return proto.RetActionType_RAT_INPUT_ERROR
	}

	ret := proto.RetActionType_RAT_INPUT_ERROR
	timeNow := wtime.GetNow()
	today := wtime.GetTodayZeroClock()
	userData.WithChallengeAsset(false, func(asset *proto.ST_Asset_Challenge_PB) bool {
		if asset.GetChallageEndTime() < timeNow {
			return false
		}
		// 有任务正在进行
		if asset.GetTaskEndTime() != 0 {
			return false
		}
		taskList := CSV.GetChallengeTask(int64(mainCityLevel), int64(challengeType))
		if len(taskList) < 8 {
			return false
		}

		for _, taskID := range taskList {
			taskConf := CSV.Mgr.CSV_Challenge.GetEntryPtr(taskID)
			if nil == taskConf {
				wlog.Error("task Id err")
				asset.GetChallengeTarget().Reset()
				resetChallengeTask(asset)
				return false
			}

			conditionVec3 := common.ParseStringToVector3(taskConf.ChallengeCondition)
			taskItem := &proto.ST_ChallengeTast_PB{
				TaskId:     proto.SetInt64(taskID),
				TaskStatus: proto.SetUint32(uint32(proto.ChallengeTaskStatus_CTS_UnStart)),
			}
			for _, v := range conditionVec3 {
				condition := &proto.ST_ChallengeCondition_PB{
					Type:         proto.SetUint32(uint32(v.GetX())),
					Param:        proto.SetUint32(uint32(v.GetY())),
					TargetScore:  proto.SetUint32(uint32(v.GetZ())),
					CurrentScore: proto.SetUint32(0),
				}
				taskItem.Conditions = append(taskItem.Conditions, condition)
			}
			asset.Tasks = append(asset.Tasks, taskItem)
		}

		choiceCurrentTask(userData, asset)

		asset.TaskEndTime = proto.SetUint64(today + 86400)
		ret = proto.RetActionType_RAT_SUCCESS

		return true
	})

	if ret == proto.RetActionType_RAT_SUCCESS {
		userData.DirtyAll()
	}

	return ret
}

func choiceCurrentTask(userData *cache.Info, asset *proto.ST_Asset_Challenge_PB) {
Loop:
	asset.CurrentTaskId = proto.SetInt64(0)
	for _, v := range asset.GetTasks() {
		if v.GetTaskStatus() == uint32(proto.ChallengeTaskStatus_CTS_UnStart) ||
			v.GetTaskStatus() == uint32(proto.ChallengeTaskStatus_CTS_Start) {
			asset.CurrentTaskId = proto.SetInt64(v.GetTaskId())
			v.TaskStatus = proto.SetUint32(uint32(proto.ChallengeTaskStatus_CTS_Start))
			break
		}
	}

	if asset.GetCurrentTaskId() != 0 {
		for _, v := range asset.GetTasks() {
			if asset.GetCurrentTaskId() == v.GetTaskId() {
				isAllCondFinish := true
				for _, cond := range v.GetConditions() {

					if cond.GetType() == uint32(proto.ChallengeConditionType_CCT_MainCityLevel) {
						cond.CurrentScore = proto.SetUint32(userData.GetMainCityLevel())
					} else if cond.GetType() == uint32(proto.ChallengeConditionType_CCT_CommenderLevel) {
						cond.CurrentScore = proto.SetUint32(userData.GetLevel())
					}
					if cond.GetCurrentScore() < cond.GetTargetScore() {
						isAllCondFinish = false
					}
				}

				if isAllCondFinish {
					v.TaskStatus = proto.SetUint32(uint32(proto.ChallengeTaskStatus_CTS_Finish))
					//完成加积分
					chTarget := asset.GetChallengeTarget()
					if nil != chTarget {
						conf := CSV.Mgr.CSV_Challenge.GetEntryPtr(v.GetTaskId())
						if nil != conf {
							addChallengeTargetScore(asset, conf.Integral)
							ossChallengeRecord(userData.GetUid(), oss.WCOP_Task, asset, v.GetTaskId())
						}
					}
					goto Loop
				}
			}
		}
	}

}

func GetChallengeReward(uid uint64, rewardType, rewardId uint32) proto.RetActionType {
	userData := cache.GetCharinfo(uid)
	if nil == userData {
		return proto.RetActionType_RAT_INPUT_ERROR
	}

	ret := proto.RetActionType_RAT_INPUT_ERROR
	var dropId int64
	var totalScore uint32
	// 目标阶段奖励
	if rewardType == 1 {
		userData.WithChallengeAsset(false, func(asset *proto.ST_Asset_Challenge_PB) bool {
			target := asset.GetChallengeTarget()
			if target != nil {
				for k, v := range target.GetRewardList() {
					if v == rewardId {
						dropId = getChallengeTargetReward(target.GetTargetID(), rewardId)
						target.RewardList = append(target.RewardList[:k], target.RewardList[k+1:]...)
						ret = proto.RetActionType_RAT_SUCCESS

						totalScore += *target.CurrentScore
						ossChallengeRecord(uid, oss.WCOP_Target, asset, 0)
						return true
					}
				}
			}

			return false
		})
	} else if rewardType == 2 {
		// 任务奖励
		userData.WithChallengeAsset(false, func(asset *proto.ST_Asset_Challenge_PB) bool {
			for _, v := range asset.GetTasks() {
				if v.GetTaskId() == int64(rewardId) && v.GetTaskStatus() == uint32(proto.ChallengeTaskStatus_CTS_Finish) {
					conf := CSV.Mgr.CSV_Challenge.GetEntryPtr(v.GetTaskId())
					if nil != conf {
						dropId = conf.ChallengeRewards
						v.TaskStatus = proto.SetUint32(uint32(proto.ChallengeTaskStatus_CTS_GetReward))
						ret = proto.RetActionType_RAT_SUCCESS

						ossChallengeRecord(uid, oss.WCOP_Reward, asset, v.GetTaskId())
						return true
					}
				}
			}

			return false
		})
	}

	if ret == proto.RetActionType_RAT_SUCCESS {
		userData.DirtyAll()
	}

	if dropId != 0 {
		for _, item := range GetDropItem(int32(dropId)) {
			AddItem(userData, item.GetItemId(), item.GetItemNum(), oss.AddCashSrcTypeChallenge)
		}
	}

	return ret
}

func GMFinishCurrentChallenge(userData *cache.Info) {
	userData.WithChallengeAsset(false, func(asset *proto.ST_Asset_Challenge_PB) bool {
		if asset.GetCurrentTaskId() != 0 {
			for _, v := range asset.GetTasks() {
				if v.GetTaskId() == asset.GetCurrentTaskId() {
					for _, v1 := range v.GetConditions() {
						v1.CurrentScore = proto.SetUint32(v1.GetTargetScore())
					}
					choiceCurrentTask(userData, asset)
					userData.DirtyAll()
					break
				}

			}
		}
		return true
	})
}

func getChallengeTargetReward(targetId int64, rewardId uint32) int64 {
	var dropId int64
	conf := CSV.Mgr.CSV_ChallengeTarget.GetEntryPtr(targetId)
	if conf == nil {
		return dropId
	}

	switch rewardId {
	case 1:
		dropId = conf.TargetReward1
	case 2:
		dropId = conf.TargetReward2
	case 3:
		dropId = conf.TargetReward3
	case 4:
		dropId = conf.TargetReward4
	case 5:
		dropId = conf.TargetReward5
	}

	return dropId
}

//cache变化，通知logic
func registerChallengeEventHandler() {
	observer.ObserverSingleton.Register(observer.CostCashEvent, costCashEventHandler)
	observer.ObserverSingleton.Register(observer.CostItemEvent, costItemEventHandler)
	observer.ObserverSingleton.Register(observer.ReceiveUnitEvent, receiveUnitEventHandler)
	observer.ObserverSingleton.Register(observer.DispatchTaskEvent, dispatchTaskEventHandler)
	observer.ObserverSingleton.Register(observer.OnlineGiftPacketEvent, onlineGiftPacketEventHandler)
	observer.ObserverSingleton.Register(observer.CommanderLevelUpgradeEvent, commanderLevelUpEventHandler)
	observer.ObserverSingleton.Register(observer.ChallengeKillMonsterEvent, challengeKillMonsterEventHandler)
	observer.ObserverSingleton.Register(observer.BlackMarketEvent, blackMarketEventHandler)
	observer.ObserverSingleton.Register(observer.SupplyEvent, supplyEventHandler)
	observer.ObserverSingleton.Register(observer.ProductStatueEvent, productStatueEventHandler)
	observer.ObserverSingleton.Register(observer.MainCityLevelUpgradeEvent, mainCityLevelUpgradeEventHandler)
	observer.ObserverSingleton.Register(observer.UserCollectEvent, userCollectEventHandler)
	observer.ObserverSingleton.Register(observer.BuildingUpgradeEvent, buildingUpgradeEventHandler)
	observer.ObserverSingleton.Register(observer.ResearchEvent, researchEventHandler)
}

func parseChallengeEventParam(params []interface{}) (error, *cache.Info, uint32, uint32) {
	if len(params) < 3 {
		return errors.New("costCashEventHandler param len err "), nil, 0, 0
	}

	userData, ok := params[0].(*cache.Info)
	if !ok {
		return errors.New("costCashEventHandler param 0 err "), nil, 0, 0
	}

	conditionParam, ok := params[1].(uint32)
	if !ok {
		return errors.New("costCashEventHandler param 2 err "), nil, 0, 0
	}

	conditionScore, ok := params[2].(uint32)
	if !ok {
		return errors.New("costCashEventHandler param 3 err "), nil, 0, 0
	}

	return nil, userData, conditionParam, conditionScore
}

func costCashEventHandler(params []interface{}) {
	err, userData, param, score := parseChallengeEventParam(params)
	if err != nil {
		wlog.Error(err.Error())
		return
	}

	processChallengeTaskScore(userData, uint32(proto.ChallengeConditionType_CCT_CostCash), param, score)
}

func costItemEventHandler(params []interface{}) {
	err, userData, param, score := parseChallengeEventParam(params)
	if err != nil {
		wlog.Error(err.Error())
		return
	}

	processChallengeTaskScore(userData, uint32(proto.ChallengeConditionType_CCT_CostItem), param, score)
}

func receiveUnitEventHandler(params []interface{}) {
	err, userData, param, score := parseChallengeEventParam(params)
	if err != nil {
		wlog.Error(err.Error())
		return
	}

	processChallengeTaskScore(userData, uint32(proto.ChallengeConditionType_CCT_ReceiveUnit), param, score)
}

func dispatchTaskEventHandler(params []interface{}) {
	err, userData, param, score := parseChallengeEventParam(params)
	if err != nil {
		wlog.Error(err.Error())
		return
	}

	processChallengeTaskScore(userData, uint32(proto.ChallengeConditionType_CCT_DispatchTask), param, score)
}

func onlineGiftPacketEventHandler(params []interface{}) {
	err, userData, param, score := parseChallengeEventParam(params)
	if err != nil {
		wlog.Error(err.Error())
		return
	}

	processChallengeTaskScore(userData, uint32(proto.ChallengeConditionType_CCT_OnlieGiftPack), param, score)
}

func commanderLevelUpEventHandler(params []interface{}) {

	if len(params) < 2 {
		return
	}

	userData, ok := params[0].(*cache.Info)
	if !ok {
		return
	}

	level, ok := params[1].(uint32)
	if !ok {
		return
	}
	CheckAllGiftSaleCondition(userData, proto.GiftConditionType_GCT_COMMANDER_LEVEL, int64(level) )
	processChallengeTaskScore(userData, uint32(proto.ChallengeConditionType_CCT_CommenderLevel), 0, level)
	ProcessCommanderLevelUpPrisonAttribute(userData)
}

func challengeKillMonsterEventHandler(params []interface{}) {
	err, userData, param, score := parseChallengeEventParam(params)
	if err != nil {
		wlog.Error(err.Error())
		return
	}

	processChallengeTaskScore(userData, uint32(proto.ChallengeConditionType_CCT_KillMonster), param, score)
}

func blackMarketEventHandler(params []interface{}) {
	err, userData, param, score := parseChallengeEventParam(params)
	if err != nil {
		wlog.Error(err.Error())
		return
	}

	processChallengeTaskScore(userData, uint32(proto.ChallengeConditionType_CCT_BlackMarket), param, score)
}

func supplyEventHandler(params []interface{}) {
	err, userData, param, score := parseChallengeEventParam(params)
	if err != nil {
		wlog.Error(err.Error())
		return
	}

	processChallengeTaskScore(userData, uint32(proto.ChallengeConditionType_CCT_Supply), param, score)
}

func productStatueEventHandler(params []interface{}) {
	err, userData, param, score := parseChallengeEventParam(params)
	if err != nil {
		wlog.Error(err.Error())
		return
	}

	processChallengeTaskScore(userData, uint32(proto.ChallengeConditionType_CCT_Statue), param, score)
}

func mainCityLevelUpgradeEventHandler(params []interface{}) {
	if len(params) < 1 {
		return
	}

	userData, ok := params[0].(*cache.Info)
	if !ok {
		return
	}

	processChallengeTaskScore(userData, uint32(proto.ChallengeConditionType_CCT_MainCityLevel), 0, userData.GetMainCityLevel())
}

func userCollectEventHandler(params []interface{}) {

	//err, userData, param, score := parseChallengeEventParam(params)

	if len(params) < 4 {
		return
	}

	userData, ok := params[0].(*cache.Info)
	if !ok {
		return
	}

	conditionParam, ok := params[1].(uint32)
	if !ok {
		return
	}

	conditionScore, ok := params[3].(uint32)
	if !ok {
		return
	}

	processChallengeTaskScore(userData, uint32(proto.ChallengeConditionType_CCT_CollectResorce), conditionParam, conditionScore)
}

func buildingUpgradeEventHandler(params []interface{}) {
	if len(params) < 3 {
		return
	}

	userData, ok := params[0].(*cache.Info)
	if !ok {
		return
	}

	power, ok := params[2].(uint32)
	if !ok {
		return
	}
	processChallengeTaskScore(userData, uint32(proto.ChallengeConditionType_CCT_BuildingPower), 0, power)
}

func researchEventHandler(params []interface{}) {
	if len(params) < 3 {
		return
	}

	userData, ok := params[0].(*cache.Info)
	if !ok {
		return
	}

	power, ok := params[2].(uint32)
	if !ok {
		return
	}
	processChallengeTaskScore(userData, uint32(proto.ChallengeConditionType_CCT_ResearchPower), 0, power)
}

func processChallengeTaskScore(userData *cache.Info, conditionType, param, score uint32) {
	timeNow := wtime.GetNow()
	today := wtime.GetTodayZeroClock()

	userData.WithChallengeAsset(false, func(asset *proto.ST_Asset_Challenge_PB) bool {
		if asset.GetChallageEndTime() < timeNow {
			return false
		}

		if asset.GetTaskEndTime() != today+86400 {
			return false
		}

		if asset.GetCurrentTaskId() == 0 {
			return false
		}

		ret := false
		for _, v := range asset.GetTasks() {
			if v.GetTaskId() == asset.GetCurrentTaskId() && v.GetTaskStatus() == uint32(proto.ChallengeTaskStatus_CTS_Start) {
				for _, condition := range v.GetConditions() {
					if condition.GetType() == conditionType && condition.GetParam() == param {
						if conditionType == uint32(proto.ChallengeConditionType_CCT_MainCityLevel) ||
							conditionType == uint32(proto.ChallengeConditionType_CCT_CommenderLevel) {
							condition.CurrentScore = proto.SetUint32(score)
						} else {
							condition.CurrentScore = proto.SetUint32(condition.GetCurrentScore() + score)
						}
						choiceCurrentTask(userData, asset)
						ret = true
						break
					}
				}
				break
			}
		}

		if ret {
			userData.DirtyAll()
		}

		return ret
	})
}

func addChallengeTargetScore(asset *proto.ST_Asset_Challenge_PB, score int64) {
	target := asset.GetChallengeTarget()
	if target != nil {
		conf := CSV.Mgr.CSV_ChallengeTarget.GetEntryPtr(target.GetTargetID())
		if nil != conf {
			oldStage := getTargetStage(conf, int64(target.GetCurrentScore()))
			target.CurrentScore = proto.SetUint32(target.GetCurrentScore() + uint32(score))
			newStage := getTargetStage(conf, int64(target.GetCurrentScore()))

			if newStage > oldStage {
				for i := oldStage + 1; i <= newStage; i++ {
					target.RewardList = append(target.RewardList, uint32(i))
				}
			}
		}
	}
}

func getTargetStage(conf *CSV.CF_ChallengeTarget_DataEntry, score int64) int64 {
	if score >= conf.Target5 {
		return 5
	} else if score >= conf.Target4 {
		return 4
	} else if score >= conf.Target3 {
		return 3
	} else if score >= conf.Target2 {
		return 2
	} else if score >= conf.Target1 {
		return 1
	} else {
		return 0
	}
}

func GMRefreshChallenge(userData *cache.Info) {
	userData.WithChallengeAsset(false, func(asset *proto.ST_Asset_Challenge_PB) bool {
		if asset.GetChallageEndTime() != 0 {
			asset.ChallageEndTime = proto.SetUint64(0)
		}
		return true
	})
}

func ossChallengeRecord(uid uint64, opType oss.WeekChallengeOpType, asset *proto.ST_Asset_Challenge_PB, taskID int64) {
	wlog.Error("Error Functions of SevenDay Action.................")
	return

	userData := cache.GetCharinfo(uid)
	if userData == nil {
		return
	}

	//targetConf := CSV.Mgr.CSV_ChallengeTarget.GetEntryPtr(asset.GetChallengeTarget().GetTargetID())

	//target := asset.ChallengeTarget
	//totalScore := target.GetCurrentScore()
	//stage := getTargetStage(targetConf, int64(totalScore))

	//var challenge map[interface{}]interface{} //map[taskID]map[condParam]condScore
	//var taskParam []uint32
	//var taskOrder uint32
	//var taskScore uint32

	//for k, v := range asset.GetTasks() {
	//	if v.GetTaskId() != taskID {
	//		continue
	//	}

	//	conf := CSV.Mgr.CSV_Challenge.GetEntryPtr(v.GetTaskId())
	//	if conf == nil {
	//		continue
	//	}

		//taskOrder = uint32(k)
		//taskScore = uint32(conf.Integral)
	//	challenge = make(map[interface{}]interface{}) //map[taskID]map[condParam]condScore
	//	for _, x := range v.GetConditions() {
	//		taskParam = make([]uint32, 0)
	//		taskParam = append(taskParam, x.GetParam())
	//		taskParam = append(taskParam, x.GetTargetScore())

	//		challenge[x.GetType()] = taskParam
	//	}
	//}

	//param := &oss.OSSWeekChallengeParam{
	//	OSSParam:   userData.GetOSSParam(),
	//	OpType:     opType,
	//	//ScoreLv:    uint32(stage + 1),
	//	TaskID:     taskOrder + 1,
	//	Challenge:  challenge,
	//	Score:      taskScore,
	//	TotalScore: uint64(totalScore),
	//}

	//if opType != oss.WCOP_Target {
	//	param.Challenge = challenge
	//}

	//param.OpType = oss.WCOP_Error
	//oss.TheOSSObject.WeekChallengeUpdate(param)
}
*/