package stonehenge

import (
	"fmt"
	"go_dreamfactory/comm"
	"go_dreamfactory/modules/battle"
	"go_dreamfactory/pb"
	cfg "go_dreamfactory/sys/configure/structs"
	"go_dreamfactory/utils"
	"math"
	"strconv"
)

//参数校验
func (this *apiComp) EventCheck(session comm.IUserSession, req *pb.StonehengeEventReq) (errdata *pb.ErrorData) {
	if req.Eventid == 0 {
		errdata = &pb.ErrorData{
			Code:  pb.ErrorCode_ReqParameterError,
			Title: pb.ErrorCode_ReqParameterError.ToString(),
		}
	}
	return
}

func (this *apiComp) Event(session comm.IUserSession, req *pb.StonehengeEventReq) (errdata *pb.ErrorData) {
	var (
		stone     *pb.DBStonehenge
		update    map[string]interface{}
		roomConf  *cfg.GameStoneRoomData
		err       error
		newEvent  int32 // 是否有新的事件
		eventConf *cfg.GameStoneEventData
		reward    []*pb.UserAtno
		curbuff   int32
		newbuff   int32             // 新获得的buff
		tasks     []*pb.BuriedParam = make([]*pb.BuriedParam, 0)
	)
	update = make(map[string]interface{})
	if errdata = this.EventCheck(session, req); errdata != nil {
		return
	}

	if stone, err = this.module.modelStonehenge.GetStonehengeData(session.GetUserId()); err != nil {
		errdata = &pb.ErrorData{
			Code:    pb.ErrorCode_DBError,
			Title:   pb.ErrorCode_DBError.String(),
			Message: err.Error(),
		}
		return
	}
	if eventConf, err = this.module.configure.GetStoneEventDataById(req.Eventid); err != nil {
		errdata = &pb.ErrorData{
			Code:    pb.ErrorCode_ConfigNoFound,
			Title:   pb.ErrorCode_ConfigNoFound.ToString(),
			Message: err.Error(),
		}
		return
	}
	if eventConf.EventType == EventType999 { // 特殊事件处理
		stone.Rooms.Eventid[req.Eventid] = true
		update["rooms"] = stone.Rooms
		this.module.modelStonehenge.ChangeStonehengeData(session.GetUserId(), update)
		session.SendMsg(string(this.module.GetType()), "event", &pb.StonehengeEventResp{
			Eventid:  req.Eventid,
			NewEvent: newEvent,
			Room:     stone.Rooms,
			Reward:   reward,
			Hero:     stone.Hero,
			Userbuff: stone.Userbuff,
			Curbuff:  curbuff,
		})
		return
	}
	// EventType29 特殊事件
	if eventConf.EventType != EventType29 && eventConf.EventType != EventType10 {
		if stone.Rooms.Eventid[req.Eventid] { // 重复完成
			errdata = &pb.ErrorData{
				Code:    pb.ErrorCode_StonehengeRepeatedReward,
				Title:   pb.ErrorCode_StonehengeRepeatedReward.ToString(),
				Message: fmt.Sprintf("req.Eventid err :%d", req.Eventid),
			}
			return
		}
	}

	update["stageID"] = stone.StageID
	if roomConf, err = this.module.configure.GetStoneRoomDataById(stone.Rooms.Roomid); err != nil {
		errdata = &pb.ErrorData{
			Code:    pb.ErrorCode_ConfigNoFound,
			Title:   pb.ErrorCode_ConfigNoFound.ToString(),
			Message: err.Error(),
		}
		return
	}

	if len(eventConf.CostItem) > 0 {
		if errdata = this.module.CheckRes(session, eventConf.CostItem); errdata != nil {
			return
		}
	}

	switch eventConf.EventType {
	case EventType16: // 捡垃圾事件
		user, err := this.module.ModuleUser.GetUser(session.GetUserId())
		if err != nil {
			errdata = &pb.ErrorData{
				Code:    pb.ErrorCode_DBError,
				Title:   pb.ErrorCode_DBError.ToString(),
				Message: err.Error(),
			}
			return
		}
		if lotteryward := this.module.ModuleTools.GetGroupDataByLottery(eventConf.Value1, user.Vip, user.Lv); len(lotteryward) > 0 {
			if errdata, reward = this.module.DispenseAtno(session, lotteryward, true); errdata != nil {
				this.module.Debugf("DispenseAtno err:+%v", lotteryward)
			}
		}
	case EventType25: // buff 三选一
		lenSelect := len(stone.Rooms.Selectbuff)
		if pos, err := strconv.Atoi(req.Param1); err == nil {
			if lenSelect == 0 || lenSelect <= pos {
				return
			}
			newbuff = stone.Rooms.Selectbuff[pos]
			// 加入收藏
			if conf, err := this.module.configure.GetStoneBuffDataById(newbuff); err == nil {
				stone.Userbuff[newbuff] = 1
				stone.Rooms.Selectbuff = []int32{}
				update["userbuff"] = stone.Userbuff
				this.module.modelStonehengeBook.addStonehengeBook(session.GetUserId(), conf.Type, conf.SkillId)
				stone.Selectcount++ // 记录三选一的次数
			} else {
				newbuff = 0
			}

		} else { // 参数错误
			errdata = &pb.ErrorData{
				Code:    pb.ErrorCode_ReqParameterError,
				Title:   pb.ErrorCode_ReqParameterError.ToString(),
				Message: err.Error(),
			}
			return
		}
	case EventType14, EventType28: // 战斗事件

		if req.Report == nil {
			errdata = &pb.ErrorData{
				Code:    pb.ErrorCode_ReqParameterError,
				Title:   pb.ErrorCode_ReqParameterError.ToString(),
				Message: fmt.Sprintf("BattleReport is nil"),
			}
			return
		}
		bWin := false
		errdata, bWin = this.module.battle.CheckBattleReport(session, req.Report)
		if errdata != nil {
			// 失败了也要继承血量
			for _, v := range req.Report.Info.Redflist[0].Team {
				if _, ok := stone.Hero[v.Oid]; ok {
					stone.Hero[v.Oid].Currhp = 0
				}
			}
			update["hero"] = stone.Hero
			this.module.modelStonehenge.ChangeStonehengeData(session.GetUserId(), update)
			// 战斗失败埋点处理
			tasks = append(tasks, comm.GetBuriedParam(comm.Rtype225, 1))
			return
		}
		if bWin { // 战斗失败直接返回
			// 掉落奖励
			if conf, err := this.module.configure.GetStoneEventDataById(req.Eventid); err == nil {
				if battleConf, err := this.module.configure.GetBattleConfById(conf.Value1); err == nil {
					user, err := this.module.ModuleUser.GetUser(session.GetUserId())
					if err != nil {
						errdata = &pb.ErrorData{
							Code:    pb.ErrorCode_DBError,
							Title:   pb.ErrorCode_DBError.ToString(),
							Message: err.Error(),
						}
						return
					}
					if lotteryward := this.module.ModuleTools.GetGroupDataByLottery(battleConf.RewardLottery, user.Vip, user.Lv); len(lotteryward) > 0 {
						if errdata, reward = this.module.DispenseAtno(session, lotteryward, true); errdata != nil {
							this.module.Debugf("DispenseAtno err:+%v", lotteryward)
						}
					}
				}
			}
		}

		for _, v := range req.Report.Info.Redflist[0].Team {
			if _, ok := stone.Hero[v.Oid]; ok {
				stone.Hero[v.Oid].Currhp = 0
			}
		}
		for _, v := range req.Report.Alive {
			if _, ok := stone.Hero[v.Oid]; ok {
				stone.Hero[v.Oid] = v
			}
		}
		for k, v := range stone.Rooms.Passive {
			if conf, err := this.module.configure.GetStoneEventDataById(k); err != nil {
				errdata = &pb.ErrorData{
					Code:    pb.ErrorCode_ConfigNoFound,
					Title:   pb.ErrorCode_ConfigNoFound.ToString(),
					Message: err.Error(),
				}
				return
			} else {
				if conf.EventType == EventType30 { //扣除每名敌方最大生命值
					delete(stone.Rooms.Passive, k)
				} else if conf.EventType == EventType31 {
					v--
					if v <= 0 {
						delete(stone.Rooms.Passive, k)
					}
				}
			}
		}

		update["hero"] = stone.Hero
		if !bWin {
			update["rooms"] = stone.Rooms
			this.module.modelStonehenge.ChangeStonehengeData(session.GetUserId(), update)
			session.SendMsg(string(this.module.GetType()), "event", &pb.StonehengeEventResp{
				Eventid:  req.Eventid,
				NewEvent: newEvent,
				Room:     stone.Rooms,
				Reward:   reward,
				Hero:     stone.Hero,
				Userbuff: stone.Userbuff,
				Curbuff:  curbuff,
			})
			return
		}
	case EventType10: // 宝箱事件
		// 通关了才能领取宝箱
		if !stone.Rooms.Complete {
			errdata = &pb.ErrorData{
				Code:  pb.ErrorCode_StonehengeNoComplete,
				Title: pb.ErrorCode_StonehengeNoComplete.ToString(),
			}
			return
		}
		// 次数校验
		if stone.Rooms.Box[req.Eventid] < eventConf.Value2 {
			user, err := this.module.ModuleUser.GetUser(session.GetUserId())
			if err != nil {
				errdata = &pb.ErrorData{
					Code:    pb.ErrorCode_DBError,
					Title:   pb.ErrorCode_DBError.ToString(),
					Message: err.Error(),
				}
				return
			}

			if lotteryward := this.module.ModuleTools.GetGroupDataByLottery(eventConf.Value1, user.Vip, user.Lv); len(lotteryward) > 0 {
				if errdata, reward = this.module.DispenseAtno(session, lotteryward, true); errdata != nil {
					this.module.Debugf("DispenseAtno err:+%v", lotteryward)
				}
			}
			stone.Rooms.Box[req.Eventid] += 1 // 更新宝箱进度
		} else {
			errdata = &pb.ErrorData{
				Code:  pb.ErrorCode_StonehengeRewardBoxFailed,
				Title: pb.ErrorCode_StonehengeRewardBoxFailed.ToString(),
			}
			return
		}
	case EventType17, EventType18: // 英雄回血

		var sz []int32 // 获取
		var szHero []string
		for _, v := range stone.Hero {
			if v.Currhp > 0 {
				szHero = append(szHero, v.Oid)
				sz = append(sz, 100)
			}
		}
		for _, v := range comm.GetRandWs(sz, eventConf.Value2) {
			objId := szHero[v]
			maxHp := stone.Hero[objId].Property[battle.AttributesTransBase("hp")]
			stone.Hero[objId].Currhp += int32(math.Floor(float64(maxHp*eventConf.Value1) / 1000)) // 回血
			// 血量上限处理
			if stone.Hero[objId].Currhp > maxHp {
				stone.Hero[objId].Currhp = maxHp
			}
		}
		update["hero"] = stone.Hero
	case EventType19:
		var sz []int32 // 获取
		var szHero []string
		for _, v := range stone.Hero { // 过滤死亡英雄
			if v.Currhp > 0 {
				szHero = append(szHero, v.Oid)
				sz = append(sz, 100)
			}
		}
		for _, v := range comm.GetRandWs(sz, eventConf.Value2) {
			objId := szHero[v]
			stone.Hero[objId].Currhp -= int32(math.Floor(float64(stone.Hero[objId].Currhp*eventConf.Value1) / 1000)) // 扣除当前生命值X（千分比）
			if stone.Hero[objId].Currhp <= 0 {                                                                       // 不能扣死英雄
				stone.Hero[objId].Currhp = 1
			}
		}
		update["hero"] = stone.Hero
	case EventType20: // 克隆一名英雄
		if _, ok := stone.Hero[req.Param1]; ok {
			errdata = &pb.ErrorData{
				Code:    pb.ErrorCode_StonehengeHeroRepeated,
				Message: pb.ErrorCode_StonehengeHeroRepeated.ToString(),
			}
			return
		}
		// 查库
		if hero, err := this.module.ModuleHero.GetHeroByObjID(session.GetUserId(), req.Param1); err != nil {
			errdata = &pb.ErrorData{
				Code:    pb.ErrorCode_HeroNoExist,
				Message: pb.ErrorCode_HeroNoExist.ToString(),
			}
			return
		} else {
			var roles []*pb.BattleRole
			if roles, errdata = this.module.battle.CreateRolesByHeros([]*pb.DBHero{hero}); errdata != nil {
				return
			}
			if len(roles) == 1 {
				roles[0].Tid = 100 + int32(len(stone.Hero))
				stone.Hero[req.Param1] = roles[0]
			}
		}
		update["hero"] = stone.Hero
	case EventType23: // 事件buff 强化// 商店强化
		if eventConf.Value2 == 0 { // 强化所有1级buff
			for _, v := range stone.Userbuff {
				if conf, e := this.module.configure.GetStoneBuffDataById(v); e != nil {
					if conf.BuffLevel == 1 && conf.Type != 5 { // 5是负面buff
						if nextConf, e := this.module.configure.GetStoneBuffDataById(v + 1); e != nil { // 是否有2级
							delete(stone.Userbuff, v)
							stone.Userbuff[nextConf.BuffId] = 1
							curbuff = nextConf.BuffId
							break
						}
					}
				}
			}
		} else if eventConf.Value2 == 1 { // 强化类型 buff
			itype := eventConf.Value3
			for _, v := range stone.Userbuff {
				if conf, e := this.module.configure.GetStoneBuffDataById(v); e != nil {
					if conf.BuffLevel == 1 && conf.Type != itype {
						if nextConf, e := this.module.configure.GetStoneBuffDataById(v + 1); e != nil { // 是否有2级
							delete(stone.Userbuff, v)
							stone.Userbuff[nextConf.BuffId] = 1
							curbuff = nextConf.BuffId
							break
						}
					}
				}
			}
		} else if eventConf.Value2 == 2 { // 强化品质buff
			quility := eventConf.Value3
			for _, v := range stone.Userbuff {
				if conf, e := this.module.configure.GetStoneBuffDataById(v); e != nil {
					if conf.BuffLevel == 1 && conf.Quality == quility && conf.Type != 5 {
						if nextConf, e := this.module.configure.GetStoneBuffDataById(v + 1); e != nil { // 是否有2级
							delete(stone.Userbuff, v)
							stone.Userbuff[nextConf.BuffId] = 1
							curbuff = nextConf.BuffId
							break
						}
					}
				}
			}
		}
		//////////////end EventType23
	case EventType29:
		if num, err := strconv.Atoi(req.Param1); err == nil {
			buffid := int32(num) // 随机获得n个buff
			if _, ok := stone.Userbuff[buffid]; ok {
				if oldbufConf, e := this.module.configure.GetStoneBuffDataById(buffid); e == nil {
					if oldbufConf.BuffUpgradeCost.N > 0 {
						if errdata = this.module.ConsumeRes(session, []*cfg.Gameatn{oldbufConf.BuffUpgradeCost}, true); errdata != nil { // 校验消耗
							return
						}
					}
				} else {
					errdata = &pb.ErrorData{
						Code:    pb.ErrorCode_ConfigNoFound,
						Title:   pb.ErrorCode_ConfigNoFound.ToString(),
						Message: e.Error(),
					}
					return
				}
				if newbufConf, e := this.module.configure.GetStoneBuffDataById(buffid + 1); e == nil {
					stone.Userbuff[newbufConf.BuffId] = 1
					delete(stone.Userbuff, buffid) // 删除旧buff
					update["userbuff"] = stone.Userbuff
					curbuff = newbufConf.BuffId
				} else {
					errdata = &pb.ErrorData{
						Code:    pb.ErrorCode_ConfigNoFound,
						Title:   pb.ErrorCode_ConfigNoFound.ToString(),
						Message: e.Error(),
					}
					return
				}
			}
		}
	case EventType13: // 扣除背包中指定道具数量
		amount := this.module.ModuleItems.QueryItemAmount(session.GetUserId(), strconv.Itoa(int(eventConf.Value2))) // 查询道具的数量
		if amount > 0 {
			if n := math.Floor(float64(int32(amount)*eventConf.Value1) / 1000); n > 0 {
				atn := &cfg.Gameatn{
					A: "item",
					T: strconv.Itoa(int(eventConf.Value2)),
					N: int32(n),
				}
				if errdata = this.module.ConsumeRes(session, []*cfg.Gameatn{atn}, true); errdata != nil {
					return
				}
			}
		}
	case EventType24: // 增加背包中指定道具数量
		amount := this.module.ModuleItems.QueryItemAmount(session.GetUserId(), strconv.Itoa(int(eventConf.Value2)))
		if amount > 0 {
			if n := math.Floor(float64(int32(amount)*eventConf.Value1) / 1000); n > 0 {
				atn := &cfg.Gameatn{
					A: "item",
					T: strconv.Itoa(int(eventConf.Value2)),
					N: int32(n),
				}
				if errdata, reward = this.module.DispenseAtno(session, []*cfg.Gameatn{atn}, true); errdata != nil {
					this.module.Debugf("DispenseAtno err:+%v", atn)
				}
			}
		}
	case EventType26: //所有1级buff强化至2级
		// 查询所有1级buff
		for _, v := range stone.Userbuff {
			if conf, e := this.module.configure.GetStoneBuffDataById(v); e != nil {
				if conf.BuffLevel == 1 {
					// 是否有2级
					if nextConf, e := this.module.configure.GetStoneBuffDataById(v + 1); e != nil {
						delete(stone.Userbuff, v)
						stone.Userbuff[nextConf.BuffId] = 1
					}
				}
			}
		}
		update["userbuff"] = stone.Userbuff
	case EventType22: //
		lenSelect := len(stone.Rooms.Selectbuff)
		if pos, err := strconv.Atoi(req.Param1); err == nil {
			if lenSelect == 0 || lenSelect <= pos {
				return
			}
			delbuff := stone.Rooms.Selectbuff[pos]
			if _, ok := stone.Userbuff[delbuff]; ok {
				delete(stone.Userbuff, delbuff)
				update["userbuff"] = stone.Userbuff
			} else {
				errdata = &pb.ErrorData{
					Code:    pb.ErrorCode_ReqParameterError,
					Title:   pb.ErrorCode_ReqParameterError.ToString(),
					Message: err.Error(),
				}
				return
			}
		} else { // 参数错误
			errdata = &pb.ErrorData{
				Code:    pb.ErrorCode_ReqParameterError,
				Title:   pb.ErrorCode_ReqParameterError.ToString(),
				Message: err.Error(),
			}
			return
		}
	}
	stone.Rooms.Eventid[req.Eventid] = true //
	// 校验事件有后续事件
	if eventConf.Probability >= comm.GetRandNum(0, 1000) { // 命中
		newEvent = eventConf.PostEvent
		this.module.modelStonehenge.AddNewEvent([]int32{eventConf.PostEvent}, stone)

	} else { // 没有后置事件的事件处理特权事件
		// 查特权
		for _, v := range stone.Privilege {
			if v == pb.StonehengePrivilege_StonehengePrivilege_4 ||
				v == pb.StonehengePrivilege_StonehengePrivilege_5 ||
				v == pb.StonehengePrivilege_StonehengePrivilege_6 { // 4 5 6 特权
				if p, err := this.module.configure.getGameStonePrivilegeData(int32(v)); err != nil {
					if stone.Selectcount > p.Value2 { // 达到指定次数
						if _, ok := stone.Privilegeevent[int32(v)]; !ok {
							// 记录buff 三选一的次数
							if stone.Selectcount == p.Value2 { //可额外触发一次随机buff三选一事件
								if c, err := this.module.configure.getGameStonePrivilegeData(3); err != nil {
									newEvent = c.Value1
								}
							}
						}
					}
				}
				break
			}
		}
	}
	stone.Rooms.Complete = true
	for _, v := range roomConf.Condition {
		for k, ok := range stone.Rooms.Eventid {
			if !ok {
				if tmp, err := this.module.configure.GetStoneEventDataById(k); err == nil {
					if tmp.EventType == v {
						stone.Rooms.Complete = false
						break
					}
				}
			}
		}
		if !stone.Rooms.Complete {
			break
		}
	}

	if len(eventConf.CostItem) > 0 {
		if errdata = this.module.ConsumeRes(session, eventConf.CostItem, true); errdata != nil { //真正的消耗
			return
		}
	}
	update["rooms"] = stone.Rooms
	this.module.modelStonehenge.ChangeStonehengeData(session.GetUserId(), update)
	session.SendMsg(string(this.module.GetType()), "event", &pb.StonehengeEventResp{
		Eventid:  req.Eventid,
		NewEvent: newEvent,
		Room:     stone.Rooms,
		Reward:   reward,
		Hero:     stone.Hero,
		Userbuff: stone.Userbuff,
		Curbuff:  curbuff,
	})

	// 埋点处理
	for k := range stone.Rooms.Eventid { // 首次触发指定ID的事件
		tasks = append(tasks, comm.GetBuriedParam(comm.Rtype215, k))
	}
	var totalhp int32
	//上阵英雄都为指定职业
	if eventConf.EventType == EventType28 { // 必须是战斗类型才可以触发
		var job int32
		for _, v := range req.Report.Info.Redflist[0].Team {
			if v.HeroID != "" {
				if h, err := this.module.ModuleTools.GetHeroConfig(v.HeroID); err == nil {
					if job == 0 {
						job = h.Job
					}
					if job != h.Job {
						job = 0
						break
					}
				}
				maxHp := v.Property[battle.AttributesTransBase("hp")]
				totalhp += v.Currhp * 1000 / maxHp
			}
		}
		if job != 0 { // 上阵英雄都为指定职业
			tasks = append(tasks, comm.GetBuriedParam(comm.Rtype216, job, stone.StageID)) //上阵英雄都为指定职业，击败石阵秘境中指定关卡的首领
		}
		for _, v := range stone.Webuff {
			tasks = append(tasks, comm.GetBuriedParam(comm.Rtype217, v, stone.StageID))
		}
		for _, v := range stone.Enemybuff {
			tasks = append(tasks, comm.GetBuriedParam(comm.Rtype217, v, stone.StageID))
		}
		// Rtype218 统计类型
		var buffType map[int32]int32
		buffType = make(map[int32]int32, 0)
		for _, v := range stone.Webuff {
			if conf, err := this.module.configure.GetStoneBuffDataById(v); err != nil {
				buffType[conf.Type]++
			}

		}
		for _, v := range stone.Enemybuff {
			if conf, err := this.module.configure.GetStoneBuffDataById(v); err != nil {
				buffType[conf.Type]++
			}
		}
		for k, v := range buffType {
			tasks = append(tasks, comm.GetBuriedParam(comm.Rtype218, k, v, stone.StageID)) //携带指定类型、≥指定数量的buff，击败石阵秘境中指定关卡的首领
		}
		// 累计击败石阵秘境任意关卡的首领N次
		tasks = append(tasks, comm.GetBuriedParam(comm.Rtype219, stone.StageID))

		//击败指定关卡的首领时，背包中指定道具数量≥指定数量
		if item, err := this.module.ModuleItems.QueryUserPack(session.GetUserId()); err != nil {
			for _, v := range item {
				if v.Amount > 0 {
					tasks = append(tasks, comm.GetBuriedParam(comm.Rtype222, stone.StageID, utils.ToInt32(v.ItemId), int32(v.Amount)))
					tasks = append(tasks, comm.GetBuriedParam(comm.Rtype226, stone.StageID, utils.ToInt32(v.ItemId), int32(v.Amount)))
				}
			}
		}
		//击败石阵秘境中指定关卡的首领时，每名上阵英雄血量≤比例（千分比）
		tasks = append(tasks, comm.GetBuriedParam(comm.Rtype224, totalhp, stone.StageID))
	}

	// 强化商店
	if eventConf.EventType == EventType29 {
		tasks = append(tasks, comm.GetBuriedParam(comm.Rtype220, 1)) // 强化buff 埋点
	}
	// 累计获得指定类型buff
	if eventConf.EventType == EventType25 {
		if newbuff != 0 {
			if conf, err := this.module.configure.GetStoneBuffDataById(newbuff); err == nil {
				tasks = append(tasks, comm.GetBuriedParam(comm.Rtype221, conf.Type, 1)) //累计获得N个指定类型的buff
			}
		}
	}

	go this.module.AsynHandleSession(session.Clone(), func(session comm.IUserSession) {
		if len(tasks) > 0 {
			this.module.ModuleBuried.TriggerBuried(session, tasks...)
		}
		if len(reward) > 0 {
			this.module.WriteUserLog(session.GetUserId(), comm.GMResAddType, "StonehengeEventReq", reward)
		}
	})

	return
}