package robot

import (
	"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"

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

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

//接收到消息
func (this *ModuleRobot_WTask) Receive(robot IRobot, stype string, message proto.Message) (err error) {
	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
			}
		}
		break
	case "finish":
		resp := message.(*pb.WTaskFinishResp)
		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
	case "activationschange":
		resp := message.(*pb.WTaskActivationsChangePush)
		if this.info != nil {
			this.info.Activations = resp.Activations
		}
		break
	case "acceptchange":
		resp := message.(*pb.WTaskAcceptChangePush)
		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
	}
	return
}

//接收到消息
func (this *ModuleRobot_WTask) ErrReceive(robot IRobot, stype string, code pb.ErrorCode) (err error) {
	switch stype {
	case "info":
		err = fmt.Errorf("信息获取:%d", code)
		break
	}
	return
}

//机器人执行流
func (this *ModuleRobot_WTask) DoPipeline(robot IRobot) (err error) {
	//获取任务列表
	if err = robot.SendMessage("wtask", "info", &pb.WTaskInfoReq{}); err != nil {
		return
	}
	var (
		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 err = robot.SendMessage("wtask", "accept", &pb.WTaskAcceptReq{Tid: tconf.Key}); err != nil {
				return
			}
			continue
		}
		//找到能做的任务
		cconf, err = this.findconlds(tconf)
		if err != nil {
			break locp
		}
		//有问完成的子任务
		if cconf != nil {
			switch comm.TaskType(cconf.Type) {
			case comm.Rtype1:
				module = comm.ModuleHero
			case comm.Rtype20001:
				module = comm.ModuleWtask
			default:
				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
			}
			continue
		} else { //任务已完成直接完成
			if err = robot.SendMessage("wtask", "finish", &pb.WTaskFinishReq{Tid: tconf.Key}); err != nil {
				return
			}
		}
	}
	return
}

//做任务
func (this *ModuleRobot_WTask) DoTask(robot IRobot, taskconf *cfg.GameWorldTaskData, condconf *cfg.GameBuriedCondiData) (err error) {
	switch comm.TaskType(condconf.Type) {
	case comm.Rtype20001:
		if err = robot.SendMessage("wtask", "completecondi", &pb.WTaskCompleteCondiReq{TaskId: taskconf.Key, CondiId: condconf.Id}); err != nil {
			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()})
		}
		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
}