package robot

import (
	"errors"
	"fmt"
	"go_dreamfactory/comm"
	"go_dreamfactory/lego/core"
	"go_dreamfactory/lego/sys/log"
	"go_dreamfactory/pb"
	"go_dreamfactory/sys/configure"
	cfg "go_dreamfactory/sys/configure/structs"
	"time"

	"google.golang.org/protobuf/proto"
)

//用户模块 机器人
type ModuleRobot_WTask struct {
	info     *pb.DBWTask
	progress []*pb.DBWTaskItem //任务进度
	state    int32
	change   chan bool
}

func (this *ModuleRobot_WTask) Init() (err error) {
	this.change = make(chan bool)
	return
}

//接收到消息
func (this *ModuleRobot_WTask) Receive(robot IRobot, stype string, message proto.Message) (err error) {
	// log.Debug("[机器人 WTask]", log.Field{Key: "Account", Value: robot.Account()}, log.Field{Key: "message", Value: message})
	switch stype {
	case "info":
		resp := message.(*pb.WTaskInfoResp)
		this.info = resp.Info
		this.progress = resp.Accepts
		break
	case "accept":
		resp := message.(*pb.WTaskAcceptResp)
		this.progress = resp.Accepts
		if this.info != nil {
			this.info.Activations = resp.Activations
			this.info.Accepts = make([]int32, 0)
			for _, v := range this.progress {
				this.info.Accepts = append(this.info.Accepts, v.Tid)
			}
		}
		break
	case "completecondi":
		resp := message.(*pb.WTaskCompleteCondiResp)
		for i, v := range this.progress {
			if v.Tid == resp.TaskId {
				this.progress[i] = resp.Progress
				break
			}
		}
		for _, v := range this.progress {
			if v.Tid == resp.Progress.Tid {
				v.Conlds = resp.Progress.Conlds
				return
			}
		}
		this.progress = append(this.progress, resp.Progress)
		break
	case "finish":
		resp := message.(*pb.WTaskFinishResp)
		if this.info != nil && this.info.Accepts != nil {
			for i, v := range this.info.Accepts {
				if v == resp.Tid {
					this.info.Accepts = append(this.info.Accepts[0:i], this.info.Accepts[i+1:]...)
					break
				}
			}
		}
		break
	case "activationschange":
		resp := message.(*pb.WTaskActivationsChangePush)
		if this.info != nil {
			this.info.Activations = resp.Activations
		}
		break
	case "acceptchange":
		resp := message.(*pb.WTaskAcceptChangePush)
		// log.Debug("[机器人 WTask-AcceptChange]", log.Field{Key: "Account", Value: robot.Account()}, log.Field{Key: "Resp", Value: resp.String()})
		this.progress = resp.Accepts
		if this.info != nil {
			this.info.Accepts = make([]int32, 0)
			for _, v := range this.progress {
				this.info.Accepts = append(this.info.Accepts, v.Tid)
			}
		}
		break
	case "boxchange":
		resp := message.(*pb.WTaskBoxChangePush)
		this.info.Boxs = resp.Boxs
		break
	}
	return
}
func (this *ModuleRobot_WTask) OncePipeline(robot IRobot) (err error) {
	var (
		errdata *pb.ErrorData
	)
	//获取任务列表
	if _, errdata = robot.SendMessage("wtask", "info", &pb.WTaskInfoReq{}); errdata != nil {
		err = errors.New(fmt.Sprintf("code:%d message:%s", errdata.Code, errdata.Message))
		return
	}
	return
}

//机器人执行流
func (this *ModuleRobot_WTask) DoPipeline(robot IRobot) (err error) {
	var (
		errdata *pb.ErrorData
		tconf   *cfg.GameWorldTaskData
		cconf   *cfg.GameBuriedCondiData
		module  core.M_Modules
	)
locp:
	for {
		//寻找可做任务
		tconf = this.findtask()
		if tconf == nil {
			break locp
		}
		if this.checkaccept(tconf) { //是否需要接收任务
			if _, errdata = robot.SendMessage("wtask", "accept", &pb.WTaskAcceptReq{Tid: tconf.Key}); errdata != nil {
				err = errors.New(fmt.Sprintf("code:%d message:%s", errdata.Code, errdata.Message))
				return
			}
			continue
		}
		//找到能做的任务
		cconf, err = this.findconlds(tconf)
		if err != nil {
			break locp
		}
		//有问完成的子任务
		if cconf != nil {
			switch comm.TaskType(cconf.Type) {
			case comm.Rtype1, comm.Rtype14:
				module = comm.ModuleHero
			case comm.Rtype20001, comm.Rtype70, comm.Rtype205, comm.Rtype227:
				module = comm.ModuleWtask
			case comm.Rtype149, comm.Rtype152:
				module = comm.ModulePractice
			case comm.Rtype61:
				module = comm.ModuleMainline
			case comm.Rtype5, comm.Rtype41, comm.Rtype43, comm.Rtype92, comm.Rtype94, comm.Rtype95, comm.Rtype96, comm.Rtype169:
				module = comm.ModuleEquipment
			case comm.Rtype128, comm.Rtype129, comm.Rtype131:
				module = comm.ModuleArena
			case comm.Rtype168:
				module = comm.ModulePagoda
			case comm.Rtype73:
				module = comm.ModuleViking
			case comm.Rtype199:
				module = comm.ModuleHero
			case comm.Rtype62:
				module = comm.ModuleChat
			case comm.Rtype104:
				module = comm.ModuleShop
			default:
				err = fmt.Errorf("[Robot DoTask] ctype:%d conld:%d Not Achieved !", cconf.Type, cconf.Id)
				// log.Error("[Robot DoTask]", log.Field{Key: "ctype", Value: cconf.Type}, log.Field{Key: "conld", Value: cconf.Id}, log.Field{Key: "err", Value: "Not Achieved !"})
				break locp
			}

			if err = robot.DoTask(tconf, cconf, module); err != nil {
				// log.Error("[Robot DoTask]", log.Field{Key: "task", Value: tconf.Key}, log.Field{Key: "conld", Value: cconf.Id}, log.Field{Key: "err", Value: err.Error()})
				break locp
			}
			time.Sleep(time.Second * 2)
			continue
		} else { //任务已完成直接完成
			if _, errdata = robot.SendMessage("wtask", "finish", &pb.WTaskFinishReq{Tid: tconf.Key}); errdata != nil {
				err = errors.New(fmt.Sprintf("code:%d message:%s", errdata.Code, errdata.Message))
				return
			}
		}
	}
	return
}

//做任务
func (this *ModuleRobot_WTask) DoTask(robot IRobot, taskconf *cfg.GameWorldTaskData, condconf *cfg.GameBuriedCondiData) (err error) {
	var (
		errdata *pb.ErrorData
	)
	switch comm.TaskType(condconf.Type) {
	case comm.Rtype20001: //完成对话
		if _, errdata = robot.SendTaskMessage(taskconf.Key, condconf.Id, "wtask", "completecondi", &pb.WTaskCompleteCondiReq{TaskId: taskconf.Key, CondiId: condconf.Id}); errdata != nil {
			err = errors.New(fmt.Sprintf("code:%d message:%s", errdata.Code, errdata.Message))
			return
		}
		break
	case comm.Rtype70: //完成世界任务战斗
		var (
			heromodule *ModuleRobot_Hero
			heros      []string
			resp       proto.Message
		)
		heromodule = robot.GetModule(comm.ModuleHero).(*ModuleRobot_Hero)
		heros = heromodule.getbattlehero()
		if resp, errdata = robot.SendTaskMessage(taskconf.Key, condconf.Id, "wtask", "battlestart", &pb.WTaskBattleStartReq{BattleConfId: condconf.Filter[0], Battle: &pb.BattleFormation{Format: heros}}); errdata != nil {
			err = errors.New(fmt.Sprintf("code:%d message:%s", errdata.Code, errdata.Message))
			return
		}
		if _, errdata = robot.SendTaskMessage(taskconf.Key, condconf.Id, "wtask", "battlefinish", &pb.WTaskBattleFinishReq{BattleConfId: condconf.Filter[0], Report: &pb.BattleReport{
			Info:    resp.(*pb.WTaskBattleStartResp).Info,
			WinSide: 1,
		}}); errdata != nil {
			err = errors.New(fmt.Sprintf("code:%d message:%s", errdata.Code, errdata.Message))
			return
		}
		break
	case comm.Rtype227: //完成世界任务战斗 失败
		var (
			heromodule *ModuleRobot_Hero
			heros      []string
			resp       proto.Message
		)
		heromodule = robot.GetModule(comm.ModuleHero).(*ModuleRobot_Hero)
		heros = heromodule.getbattlehero()
		if resp, errdata = robot.SendTaskMessage(taskconf.Key, condconf.Id, "wtask", "battlestart", &pb.WTaskBattleStartReq{BattleConfId: condconf.Filter[0], Battle: &pb.BattleFormation{Format: heros}}); errdata != nil {
			err = errors.New(fmt.Sprintf("code:%d message:%s", errdata.Code, errdata.Message))
			return
		}
		if _, errdata = robot.SendTaskMessage(taskconf.Key, condconf.Id, "wtask", "battlefinish", &pb.WTaskBattleFinishReq{BattleConfId: condconf.Filter[0], Report: &pb.BattleReport{
			Info:    resp.(*pb.WTaskBattleStartResp).Info,
			WinSide: 2,
		}}); errdata != nil {
			err = errors.New(fmt.Sprintf("code:%d message:%s", errdata.Code, errdata.Message))
			return
		}
		break
	case comm.Rtype205: //拾取宝箱
		boxid := int32(0)
		for k, v := range this.info.Boxs[taskconf.Key].Boxs {
			if v == 0 {
				boxid = k
				break
			}
		}
		if _, errdata = robot.SendTaskMessage(taskconf.Key, condconf.Id, "wtask", "boxreceive", &pb.WTaskBoxReceiveReq{
			Tid:   taskconf.Key,
			Boxid: boxid,
		}); errdata != nil {
			err = errors.New(fmt.Sprintf("code:%d message:%s", errdata.Code, errdata.Message))
			return
		}
		break
	}
	return
}

func (this *ModuleRobot_WTask) findtask() (conf *cfg.GameWorldTaskData) {
	var (
		confs []*cfg.GameWorldTaskData
		err   error
	)
	for _, v := range this.info.Accepts {
		if conf, err = this.getGameWorldTaskData(v); err != nil {
			log.Error("[Robot 世界任务配置未找到]", log.Field{Key: "task", Value: v}, log.Field{Key: "err", Value: err.Error()})
		}
		if conf.Des == 2 { //优先找到主线任务
			return
		}
		confs = append(confs, conf)
	}

	for _, v := range this.info.Activations { //可接取任务列表
		if conf, err = this.getGameWorldTaskData(v); err != nil {
			log.Error("[Robot 世界任务配置未找到]", log.Field{Key: "task", Value: v}, log.Field{Key: "err", Value: err.Error()})
			return
		}
		if conf.Des == 2 { //优先找到主线任务
			return
		}
	}

	return
}

func (this *ModuleRobot_WTask) findconlds(conf *cfg.GameWorldTaskData) (cconf *cfg.GameBuriedCondiData, err error) {
	for _, tp := range this.progress {
		if tp.Tid == conf.Key {
			for _, v := range tp.Conlds {
				if v.State == pb.BuriedItemFinishState_buried_unfinish { //未完成
					if cconf, err = this.getburiedcondidata(v.Conid); err != nil {
						log.Error("[Robot 埋点任务配置未找到]", log.Field{Key: "conld", Value: v.Conid}, log.Field{Key: "err", Value: err.Error()})
						return
					}
					return
				}
			}
		}
	}
	return
}

func (this *ModuleRobot_WTask) checkaccept(conf *cfg.GameWorldTaskData) bool {
	for _, v := range this.info.Accepts {
		if v == conf.Key {
			return false
		}
	}
	return true
}

//获取任务配置
func (this *ModuleRobot_WTask) getGameWorldTaskData(tid int32) (conf *cfg.GameWorldTaskData, err error) {
	var (
		v  interface{}
		ok bool
	)
	if v, err = configure.GetConfigure(gameWorldTask); err != nil {
		return
	} else {
		if conf, ok = v.(*cfg.GameWorldTask).GetDataMap()[tid]; !ok {
			err = comm.NewNotFoundConfErr("robot", gameWorldTask, tid)
			return
		}
	}
	return
}

// 读取条件任务id配置
func (this *ModuleRobot_WTask) getburiedcondidata(cid int32) (conf *cfg.GameBuriedCondiData, err error) {
	var (
		v  interface{}
		ok bool
	)
	if v, err = configure.GetConfigure(game_buriedcondi); err != nil {
		return
	} else {
		if conf, ok = v.(*cfg.GameBuriedCondi).GetDataMap()[cid]; !ok {
			err = comm.NewNotFoundConfErr("robot", game_buriedcondi, cid)
			return
		}
	}
	return
}