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"
)

func registerDailyEventHandler() {
	observer.ObserverSingleton.Register(observer.UserCollectEvent, dailyGatherHandler)                  //采集
	observer.ObserverSingleton.Register(observer.ReceiveUnitEvent, dailyTrainUnitHandler)               //训练
	observer.ObserverSingleton.Register(observer.SpeedTimeEvent, dailySpeedTimeHandler)                 //使用加速
	observer.ObserverSingleton.Register(observer.AttackMonsterEvent, dailyAttackMonsterHandler)         //攻击了机械兽
	observer.ObserverSingleton.Register(observer.ActivityTaskKillMonsterEvent, dailyKillMonsterHandler) //击杀机械兽、alpha
	observer.ObserverSingleton.Register(observer.CostCashEvent, dailyConsumeCashHandler)                //消耗体力
	observer.ObserverSingleton.Register(observer.ActivityTaskBlackMarketEvent, dailyBlackMarketHandler) //黑市购买
	observer.ObserverSingleton.Register(observer.BuildingUpgradeEvent, dailyBuildingUpgradeHandler)     //建筑升级提升战力
	observer.ObserverSingleton.Register(observer.ResearchEvent, dailyResearchUpgradeHandler)            //科研提升战力
	observer.ObserverSingleton.Register(observer.LeagueBoxEvent, dailyLeagueBoxHandler)                 //联盟秘宝开启
	observer.ObserverSingleton.Register(observer.LeagueHelpEvent, dailyLeagueHelpEvent)                 //联盟帮助
	observer.ObserverSingleton.Register(observer.GetLeagueGiftEvent, dailyGetLeagueGiftEvent)           //领取联盟礼物
	observer.ObserverSingleton.Register(observer.KillMachineCenterEvent, dailyKillMachineCenter)        //多人怪
	//observer.ObserverSingleton.Register(observer.SpeedItemUseEvent, dailySpeedItemUse)//修复城墙加速
}

func dailyGatherHandler(params []interface{}) {
	if len(params) < 4 {
		return
	}

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

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

	count, ok := params[3].(uint32)
	if !ok {
		return
	}
	commonDailyTaskHandler(userData, int32(proto.DailyTaskType_STT_GatherAnyRes), 0, 0, count)                   //不区分资源类型
	commonDailyTaskHandler(userData, int32(proto.DailyTaskType_STT_GatherSpecifyRes), int32(cashType), 0, count) //区分资源类型
}

func dailyTrainUnitHandler(params []interface{}) {
	if len(params) < 6 {
		return
	}

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

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

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

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

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

	//陷阱类型排除
	if unitType > uint32(proto.UnitBattleType_UBT_NOMAL_FEIJI) {
		return
	}

	//任意类型
	commonDailyTaskHandler(userData, int32(proto.DailyTaskType_STT_TrainAnyUnit), int32(0), int32(0), count)
	//指定类型
	commonDailyTaskHandler(userData, int32(proto.DailyTaskType_STT_TrainTUnit), int32(0), int32(level), count)
	//指定类型、T级
	commonDailyTaskHandler(userData, int32(proto.DailyTaskType_STT_TrainSpecifyTUnit), int32(unitType), int32(level), count)
	//战力提升
	commonDailyTaskHandler(userData, int32(proto.DailyTaskType_STT_UpPowerByTrain), 0, 0, power)
}

func dailySpeedTimeHandler(params []interface{}) {
	if len(params) < 4 {
		return
	}

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

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

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

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

	if actionType == uint32(proto.ActionType_AT_BUILD_LEVELUP) {
		commonDailyTaskHandler(userData, int32(proto.DailyTaskType_STT_UseSpeedForBuilding), int32(0), int32(0), count)
	} else if actionType == uint32(proto.ActionType_AT_RESEARCH_START) {
		commonDailyTaskHandler(userData, int32(proto.DailyTaskType_STT_UseSpeedForResearch), int32(0), int32(0), count)
	} else if actionType == uint32(proto.ActionType_AT_PRODUCTION_UNIT) || actionType == uint32(proto.ActionType_AT_PRODUCTION_LEVELUP) {
		commonDailyTaskHandler(userData, int32(proto.DailyTaskType_STT_UseSpeedForTrain), int32(0), int32(0), count)
	}
	if actionType == uint32(proto.ActionType_AT_DURABLE) || actionType == uint32(proto.ActionType_AT_BUILD_LEVELUP) ||
		actionType == uint32(proto.ActionType_AT_RESEARCH_START) || actionType == uint32(proto.ActionType_AT_PRODUCTION_UNIT) ||
		actionType == uint32(proto.ActionType_AT_PRODUCTION_LEVELUP) || actionType == uint32(proto.ActionType_AT_PRODUCTION_CURE) {
		commonDailyTaskHandler(userData, int32(proto.DailyTaskType_STT_UseAnySpeed), int32(0), int32(0), count)
	}
}

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

	userData, ok := params[0].(*cache.Info)
	if !ok {
		return
	}
	count, ok := params[1].(uint32)
	if !ok {
		return
	}
	commonDailyTaskHandler(userData, int32(proto.DailyTaskType_STT_HitMachineMonster), 0, 0, count)
}

func dailyKillMonsterHandler(params []interface{}) {
	if len(params) < 2 {
		return
	}

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

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

	if monsterType == 3 {
		commonDailyTaskHandler(userData, int32(proto.DailyTaskType_STT_KillAlphaTms), 0, 0, 1)
	} else if monsterType == 1 {
		commonDailyTaskHandler(userData, int32(proto.DailyTaskType_STT_KillMachineMonster), 0, 0, 1)
	}
}

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

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

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

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

	if cashType == uint32(proto.CashType_CASH_TYPE_STA) {
		commonDailyTaskHandler(userData, int32(proto.DailyTaskType_STT_ConsumeTL), 0, 0, count)
	} else if cashType == uint32(proto.CashType_CASH_TYPE_100) {
		commonDailyTaskHandler(userData, int32(proto.DailyTaskType_STT_UseGem), 0, 0, count)
	}
}

func dailyBlackMarketHandler(params []interface{}) {
	if len(params) < 2 {
		return
	}

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

	count, ok := params[1].(uint32)
	if !ok {
		return
	}
	commonDailyTaskHandler(userData, int32(proto.DailyTaskType_STT_DarkMarketBuy), 0, 0, count)
}

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

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

	count, ok := params[2].(uint32)
	if !ok {
		return
	}
	commonDailyTaskHandler(userData, int32(proto.DailyTaskType_STT_UpPowerByBuilding), 0, 0, count)
}

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

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

	count, ok := params[2].(uint32)
	if !ok {
		return
	}
	commonDailyTaskHandler(userData, int32(proto.DailyTaskType_STT_UpPowerByResearch), 0, 0, count)
}

func dailyLeagueBoxHandler(params []interface{}) {
	if len(params) < 2 {
		return
	}

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

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

	if eventType == 1 {
		commonDailyTaskHandler(userData, int32(proto.DailyTaskType_STT_OpenLeagueBox), 0, 0, 1)
	} else if eventType == 2 {
		commonDailyTaskHandler(userData, int32(proto.DailyTaskType_STT_HelpLeagueBox), 0, 0, 1)
	}
}

func dailyLeagueHelpEvent(params []interface{}) {
	if len(params) < 2 {
		return
	}

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

	count, ok := params[1].(uint32)
	if !ok {
		return
	}
	commonDailyTaskHandler(userData, int32(proto.DailyTaskType_STT_HelpLeague), 0, 0, count)
}

func dailyGetLeagueGiftEvent(params []interface{}) {
	if len(params) < 2 {
		return
	}

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

	count, ok := params[1].(uint32)
	if !ok {
		return
	}
	commonDailyTaskHandler(userData, int32(proto.DailyTaskType_STT_GetLeagueGift), 0, 0, count)
}

func dailyKillMachineCenter(params []interface{}) {
	if len(params) < 2 {
		return
	}

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

	level, ok := params[1].(uint32)
	if !ok {
		return
	}
	commonDailyTaskHandler(userData, int32(proto.DailyTaskType_STT_KillMachineCenter), 0, int32(level), 1)
}

func dailySpeedItemUse(params []interface{}) {
	if len(params) < 2 {
		return
	}

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

	val, ok := params[1].(uint64)
	if !ok {
		return
	}
	commonDailyTaskHandler(userData, int32(proto.DailyTaskType_STT_UseAnySpeed), 0, int32(val), 1)
}

func commonDailyTaskHandler(userData *cache.Info, taskType, mainType, subType int32, num uint32) {
	if nil == userData {
		return
	}

	taskIds := CSV.GetDailyTaskIdsByType(taskType)
	for _, v := range taskIds {
		cfg := CSV.Mgr.CSV_DailyTarget.GetEntryPtr(int64(v))
		if cfg == nil {
			wlog.Error("CSV_DailyTarget nil id:", v)
			continue
		}

		actCfg := CSV.Mgr.CSV_Activity.GetEntryPtr(int64(cfg.ActivityId))
		if actCfg == nil {
			wlog.Error("CSV_Activity nil id:", cfg.ActivityId)
			continue
		}
		userData.WithActivityAsset(false, uint32(actCfg.ID), func(asset *proto.ST_Asset_Activity_Item_PB) bool {
			if asset.GetStage() != uint32(proto.ActivityStage_AS_ProcessingStage) {
				return false
			}

			if asset.DailyTask == nil {
				asset.DailyTask = &proto.ST_DailyTask_PB{}
			}

			if asset.DailyTask.GetLevel() == 0 {
				asset.DailyTask.Level = proto.SetUint32(userData.GetMainCityLevel())
			}

			taskIdx := -1
			daily := asset.DailyTask
			for k, v := range daily.Tasks {
				if v.GetX() == int32(cfg.ID) {
					taskIdx = k
					break
				}
			}

			level := asset.DailyTask.GetLevel()
			cdt := CSV.GetDailyTaskCondition(int32(v), int32(level))
			if cdt == nil {
				wlog.Error("GetGapValeByCityLevel return nil id, lv:", v, level)
				return false
			}

			if cdt.GetY() != mainType {
				return false
			}
			if (taskType == int32(proto.DailyTaskType_STT_TrainTUnit) ||
				taskType == int32(proto.DailyTaskType_STT_TrainSpecifyTUnit) ||
				taskType == int32(proto.DailyTaskType_STT_KillMachineCenter)) && subType < cdt.GetZ() {
				return false
			}

			if taskIdx == -1 {
				daily.Tasks = append(daily.Tasks, &proto.ST_Vector4Int_PB{
					X: proto.SetInt32(int32(cfg.ID)),
					Y: proto.SetInt32(int32(num)),
					W: proto.SetInt32(int32(1)),
				})
				taskIdx = len(daily.Tasks) - 1
			} else {
				daily.Tasks[taskIdx].Y = proto.SetInt32(daily.Tasks[taskIdx].GetY() + int32(num))
			}

			if daily.Tasks[taskIdx].GetY() >= cdt.GetW() && daily.Tasks[taskIdx].GetW() == 1 {
				daily.Tasks[taskIdx].Z = proto.SetInt32(1)
				newOssDailyTask(userData, daily.Tasks[taskIdx], actCfg.ActivityType, nil, 1)
			}
			return true
		})
	}
}

// 领取日常活动奖励
func GetDailyTaskReward(uid uint64, taskId int64) proto.RetActionType {
	ret := proto.RetActionType_RAT_INPUT_ERROR
	userData := cache.GetCharinfo(uid)
	if nil == userData {
		return ret
	}
	cfg := CSV.Mgr.CSV_DailyTarget.GetEntryPtr(int64(taskId))
	if cfg == nil {
		wlog.Error("CSV_DailyTarget return  nil taskId:", taskId)
		return ret
	}
	actCfg := CSV.Mgr.CSV_Activity.GetEntryPtr(int64(cfg.ActivityId))
	if actCfg == nil {
		wlog.Error("CSV_Activity nil id:", cfg.ActivityId)
		return ret
	}
	userData.WithActivityAsset(false, uint32(actCfg.ID), func(asset *proto.ST_Asset_Activity_Item_PB) bool {
		if asset.GetStage() != uint32(proto.ActivityStage_AS_ProcessingStage) {
			wlog.Error("GetDailyTaskReward err stage ", asset.GetStage())
			return false
		}

		//任务是否存在
		taskIdx := -1
		tasks := asset.DailyTask.GetTasks()
		for k, v := range tasks {
			if v.GetX() == int32(cfg.ID) {
				taskIdx = k
				break
			}
		}
		if taskIdx == -1 {
			wlog.Error("GetDailyTaskReward err taskIdx -1")
			return false
		}

		//达成且未领取
		if tasks[taskIdx].GetZ() != 1 || tasks[taskIdx].GetW() != 1 {
			wlog.Error("GetDailyTaskReward err finish rewards", tasks[taskIdx].GetZ(), tasks[taskIdx].GetW())
			return false
		}

		level := asset.DailyTask.GetLevel()
		rewardsId := CSV.GetDailyTaskRewards(int32(cfg.ID), int32(level))
		if rewardsId == 0 {
			wlog.Error("GetDailyTaskReward err rewardsId", rewardsId, cfg.ID, level)
			return false
		}

		tasks[taskIdx].W = proto.SetInt32(0)
		items := CSV.GetDropItem(rewardsId)
		for _, item := range items {
			item.ItemNum = proto.SetUint32(item.GetItemNum())
			userData.AddItem(item.GetItemId(), item.GetItemNum(), oss.Activity_DailyTask)
		}
		ret = proto.RetActionType_RAT_SUCCESS
		//ossDailyTaskRecord(userData,tasks[taskIdx], items)
		newOssDailyTask(userData, tasks[taskIdx], actCfg.ActivityType, items, 2)
		cache.NewOssDailyActive(userData, actCfg, int(taskId), 1, common.ItemEntryToString(items))
		return true
	})
	return ret
}

//func ossDailyTaskRecord(userData *cache.Info, task *proto.ST_Vector4Int_PB, items []*proto.ST_ItemEntry_PB) {
//	ossParam := &oss.OSSDailyTaskParam{
//		userData.GetOSSParam(),
//		uint32(task.GetX()),
//		uint32(task.GetY()),
//		make(map[interface{}]interface{}),
//	}
//	for _, v := range items {
//		ossParam.Rewards[v.GetItemId()] = v.GetItemNum()
//	}
//	oss.TheOSSObject.DailyTask(ossParam)
//}