package wtask

import (
	"fmt"
	"go_dreamfactory/comm"
	"go_dreamfactory/lego/core"
	"go_dreamfactory/lego/sys/log"
	"go_dreamfactory/modules"
	"go_dreamfactory/pb"
	cfg "go_dreamfactory/sys/configure/structs"
)

const modulename = "世界任务"

type WTask struct {
	modules.ModuleBase
	service    core.IService
	caravan    comm.ICaravan
	dailytask  comm.IDailytask
	battle     comm.IBattle
	sys        comm.ISys
	api        *apiComp
	configure  *configureComp
	modelwtask *ModelWTask
}

func NewModule() core.IModule {
	return &WTask{}
}

func (this *WTask) GetType() core.M_Modules {
	return comm.ModuleWtask
}

func (this *WTask) Init(service core.IService, module core.IModule, options core.IModuleOptions) (err error) {
	err = this.ModuleBase.Init(service, module, options)
	this.service = service
	return
}

func (this *WTask) Start() (err error) {
	err = this.ModuleBase.Start()
	var module core.IModule
	if module, err = this.service.GetModule(comm.ModuleBattle); err != nil {
		return
	}
	this.battle = module.(comm.IBattle)
	if module, err = this.service.GetModule(comm.ModuleSys); err != nil {
		return
	}
	this.sys = module.(comm.ISys)
	if module, err = this.service.GetModule(comm.ModuleCaravan); err != nil {
		return
	}
	this.caravan = module.(comm.ICaravan)
	if module, err = this.service.GetModule(comm.ModuleDailytask); err != nil {
		return
	}
	this.dailytask = module.(comm.IDailytask)
	return
}

func (this *WTask) OnInstallComp() {
	this.ModuleBase.OnInstallComp()
	this.api = this.RegisterComp(new(apiComp)).(*apiComp)
	this.modelwtask = this.RegisterComp(new(ModelWTask)).(*ModelWTask)
	this.configure = this.RegisterComp(new(configureComp)).(*configureComp)
}

// 埋点通知
func (this *WTask) BuriedsNotify(session comm.IUserSession, condis []*pb.ConIProgress) {
	var (
		condisMap      map[int32]*pb.ConIProgress = make(map[int32]*pb.ConIProgress)
		utask          *pb.DBWTask
		accepttaskMap  map[int32]struct{} = make(map[int32]struct{})
		condlTask      map[int32][]*cfg.GameWorldTaskData
		temptasks      []*cfg.GameWorldTaskData
		changetasks    map[int32]*cfg.GameWorldTaskData = make(map[int32]*cfg.GameWorldTaskData)
		checkcondlsMap map[int32]struct{}               = make(map[int32]struct{})
		checkcondls    []int32                          = make([]int32, 0)
		detailstasks   []*pb.DBWTaskItem                = make([]*pb.DBWTaskItem, 0)
		ok             bool
		needcheck      bool //是否需要校验

		err error
	)
	this.Debug("收到子任务进度变化推送", log.Field{Key: "uid", Value: session.GetUserId()}, log.Field{Key: "condis", Value: condis})
	if utask, err = this.modelwtask.getUserWTasks(session.GetUserId()); err != nil {
		this.Error("读取玩家世界任务数据 失败", log.Field{Key: "err", Value: err.Error()})
		return
	}
	condlTask = this.configure.getcondlTask()

	for _, v := range condis {
		condisMap[v.Conid] = v
	}

	for _, v := range utask.Accepts {
		accepttaskMap[v] = struct{}{}
	}

	for _, v := range condis {
		if temptasks, ok = condlTask[v.Conid]; ok {
			for _, task := range temptasks {
				if _, ok = accepttaskMap[task.Key]; ok { //任务列表进度有变化
					if _, ok = changetasks[task.Key]; !ok {
						changetasks[task.Key] = task
						for _, cid := range task.Completetask {
							if _, ok = checkcondlsMap[cid]; !ok {
								checkcondlsMap[cid] = struct{}{}
								checkcondls = append(checkcondls, cid)
							}
						}
					}
				}
			}
		}
	}
	if len(changetasks) == 0 { //没有任务变化
		return
	}
	for k, _ := range checkcondlsMap {
		if _, ok = condisMap[k]; !ok {
			needcheck = true
		}
	}
	if needcheck { //校验有变化的任务 的完成条件
		if condis, err = this.ModuleBuried.CheckCondition(session.GetUserId(), checkcondls...); err != nil {
			this.Error("校验玩家子任务进度数据 失败", log.Field{Key: "err", Value: err.Error()})
			return
		}
		for _, v := range condis {
			condisMap[v.Conid] = v
		}
	}

	//推送进度变化消息
	for k, v := range changetasks {
		task := &pb.DBWTaskItem{
			Tid:    k,
			Conlds: make([]*pb.ConIProgress, len(v.Completetask)),
		}
		for i, v := range v.Completetask {
			task.Conlds[i] = condisMap[v]
		}
		detailstasks = append(detailstasks, task)
	}
	//发送进度变化消息
	session.SendMsg(string(this.GetType()), "acceptchange", &pb.WTaskAcceptChangePush{Accepts: detailstasks})
}

// 功能开启
func (this *WTask) OpenCmdNotice(uid string, keys ...string) {
	var (
		opencmdTask map[string][]*cfg.GameWorldTaskData
		user        *pb.DBUser
		wtask       *pb.DBWTask
		err         error
		ok          bool
	)
	//初步校验
	opencmdTask = this.configure.getopencmdTask()
	for _, key := range keys {
		if _, ok = opencmdTask[key]; ok {
			break
		}
	}
	if user = this.ModuleUser.GetUser(uid); user == nil {
		this.Error("获取用户信息失败!", log.Field{Key: "uid", Value: uid})
		return
	}

	if wtask, err = this.modelwtask.getUserWTasks(uid); err != nil {
		this.Error("获取世界任务数据 失败!", log.Field{Key: "uid", Value: uid}, log.Field{Key: "err", Value: err.Error()})
		return
	}

	session, _ := this.GetUserSession(uid)
	defer func() {
		session.Push()
		this.PutUserSession(session)
	}()
	this.inquireActivations(session, wtask, user.Lv, keys, true)
}

// 获取商队任务
func (this *WTask) AcceptCaravanTask(session comm.IUserSession, groupId int32) (tid, groud int32, errdata *pb.ErrorData) {
	var (
		alltasks    []*cfg.GameWorldTaskData
		grouptask   []*cfg.GameWorldTaskData = make([]*cfg.GameWorldTaskData, 0)
		completeMap map[int32]struct{}       = make(map[int32]struct{})
		target      *cfg.GameWorldTaskData
		wtask       *pb.DBWTask
		err         error
		ok          bool
	)
	alltasks = this.configure.getdesTask(5)
	for _, v := range alltasks {
		if v.Group == groupId {
			grouptask = append(grouptask, v)
		}
	}

	if len(grouptask) == 0 {
		errdata = &pb.ErrorData{
			Code:    pb.ErrorCode_ConfigNoFound,
			Title:   pb.ErrorCode_ConfigNoFound.ToString(),
			Message: fmt.Sprintf("no found des:%d groud:%d tasks", 5, groupId),
		}
		return
	}

	if wtask, err = this.modelwtask.getUserWTasks(session.GetUserId()); err != nil {
		errdata = &pb.ErrorData{
			Code:    pb.ErrorCode_DBError,
			Title:   pb.ErrorCode_DBError.ToString(),
			Message: err.Error(),
		}
		return
	}

	for _, v := range wtask.Completes {
		completeMap[v] = struct{}{}
	}

	for _, v := range grouptask {
		if _, ok = completeMap[v.Key]; !ok { //找到一个为完成任务
			target = v
			break
		}
	}

	if target == nil {
		errdata = &pb.ErrorData{
			Code:    pb.ErrorCode_ConfigNoFound,
			Title:   pb.ErrorCode_ConfigNoFound.ToString(),
			Message: fmt.Sprintf("no found des:%d groud:%d nocomplete tasks", 5, groupId),
		}
		return
	}

	//有新任务接取
	wtask.Activations = append(wtask.Activations, target.Key)
	//有新任务接取
	session.SendMsg(string(this.GetType()), "activationschange", &pb.WTaskActivationsChangePush{Activations: wtask.Activations})
	if err = this.modelwtask.updateUserWTasks(session.GetUserId(), wtask); err != nil {
		errdata = &pb.ErrorData{
			Code:    pb.ErrorCode_DBError,
			Title:   pb.ErrorCode_DBError.ToString(),
			Message: err.Error(),
		}
		return
	}
	tid = target.Key
	groud = target.Group
	return
}

// 重置日常任务
func (this *WTask) ResetDailytaskTask(session comm.IUserSession, dailytaskid int32, groupId ...int32) (results map[int32][]int32, errdata *pb.ErrorData) {
	var (
		alltasks    map[int32]*cfg.GameWorldTaskData = make(map[int32]*cfg.GameWorldTaskData)
		groupTasks  map[int32][]*cfg.GameWorldTaskData
		tasks       []*cfg.GameWorldTaskData
		wtask       *pb.DBWTask
		activations []int32 = make([]int32, 0)
		accepts     []int32 = make([]int32, 0)
		completes   []int32 = make([]int32, 0)
		condiIds    []int32 = make([]int32, 0)
		box         map[int32]int32
		err         error
		ok          bool
		boxchange   bool
	)

	defer func() {
		session.Push()
		this.PutUserSession(session)
	}()

	results = make(map[int32][]int32)
	for _, v := range this.configure.getdesTask(1) {
		alltasks[v.Key] = v
	}

	if wtask, err = this.modelwtask.getUserWTasks(session.GetUserId()); err != nil {
		errdata = &pb.ErrorData{
			Code:    pb.ErrorCode_DBError,
			Title:   pb.ErrorCode_DBError.ToString(),
			Message: err.Error(),
		}
		return
	}
	//移除之前的日常任务
	for _, v := range wtask.Activations {
		if _, ok = alltasks[v]; !ok {
			activations = append(activations, v)
		}
	}
	for _, v := range wtask.Accepts {
		if _, ok = alltasks[v]; !ok {
			accepts = append(accepts, v)
		}
	}
	for _, v := range wtask.Completes {
		if _, ok = alltasks[v]; !ok {
			completes = append(completes, v)
		}
	}

	//添加新的日常任务
	groupTasks = this.configure.getgroupTask()
	for _, v := range groupId {
		if tasks, ok = groupTasks[v]; !ok {
			errdata = &pb.ErrorData{
				Code:    pb.ErrorCode_ConfigNoFound,
				Title:   pb.ErrorCode_ConfigNoFound.String(),
				Message: fmt.Sprintf("no found group:%d", v),
			}
			return
		}
		for _, task := range tasks {
			if task.Ontxe == 0 {
				condiIds = append(condiIds, task.Completetask...)
				activations = append(activations, task.Key)
				if _, ok = results[v]; !ok {
					results[v] = make([]int32, 0)
				}
				results[v] = append(results[v], task.Key)
				if task.Trigger == 1 { //触发宝箱
					if box, err = this.configure.getGameSearchitemAll(task.Key); err != nil {
						errdata = &pb.ErrorData{
							Code:    pb.ErrorCode_ConfigNoFound,
							Title:   pb.ErrorCode_ConfigNoFound.ToString(),
							Message: fmt.Sprintf("getGameSearchitemAll uid:%s taskid:%v", session.GetUserId(), task.Key),
						}
						return
					}
					wtask.Boxs[task.Key] = &pb.DBWTaskBox{
						Boxs: box,
					}
					boxchange = true
				}
			}
		}
	}
	wtask.Activations = activations
	wtask.Accepts = accepts
	wtask.Completes = completes
	wtask.Dailytaskgroup = dailytaskid
	wtask.Exchange = make(map[int32]int32)
	wtask.Events = make(map[int32]int32)
	if len(condiIds) > 0 {
		// if err = this.ModuleBuried.ActiveCondition(session.GetUserId(), condiIds...); err != nil {
		// 	errdata = &pb.ErrorData{
		// 		Code:    pb.ErrorCode_ExternalModule,
		// 		Title:   pb.ErrorCode_ExternalModule.ToString(),
		// 		Message: fmt.Sprintf("ModuleBuried.ActiveCondition uid:%s condiIds:%v", session.GetUserId(), condiIds),
		// 	}
		// 	return
		// }
	}

	//有新任务接取
	this.pushtaskprogress(session, wtask, true)
	if boxchange {
		session.SendMsg(string(this.GetType()), "boxchange", &pb.WTaskBoxChangePush{Boxs: wtask.Boxs})
	}
	if err = this.modelwtask.updateUserWTasks(session.GetUserId(), wtask); err != nil {
		errdata = &pb.ErrorData{
			Code:    pb.ErrorCode_DBError,
			Title:   pb.ErrorCode_DBError.ToString(),
			Message: err.Error(),
		}
		return
	}
	return
}

// 查询完成列表
func (this *WTask) InquireCompletes(uid string) []int32 {
	var (
		wtask     *pb.DBWTask
		completes []int32 = make([]int32, 0)
		err       error
	)
	if wtask, err = this.modelwtask.getUserWTasks(uid); err == nil {
		completes = wtask.Completes
	}
	return completes
}

// 查询日常任务进度
func (this *WTask) InquireTaskProgress(session comm.IUserSession, tasks ...int32) (progress []*pb.DBWTaskItem, errdata *pb.ErrorData) {
	var (
		checkcondlsMap map[int32]struct{} = make(map[int32]struct{})
		checkcondls    []int32            = make([]int32, 0)
		conf           *cfg.GameWorldTaskData
		condis         []*pb.ConIProgress         = make([]*pb.ConIProgress, 0)
		condisMap      map[int32]*pb.ConIProgress = make(map[int32]*pb.ConIProgress)
		err            error
		ok             bool
	)

	for _, v := range tasks {
		if conf, err = this.configure.gettaskconfconfigure(v); err != nil {
			this.Errorln(err)
			errdata = &pb.ErrorData{
				Code:    pb.ErrorCode_ConfigNoFound,
				Title:   pb.ErrorCode_ConfigNoFound.ToString(),
				Message: err.Error(),
			}
			return
		}
		for _, v := range conf.Completetask {
			if _, ok = checkcondlsMap[v]; !ok {
				checkcondlsMap[v] = struct{}{}
				checkcondls = append(checkcondls, v)
			}
		}
	}
	if len(checkcondls) > 0 {
		if condis, err = this.ModuleBuried.CheckCondition(session.GetUserId(), checkcondls...); err != nil {
			this.Error("校验玩家子任务进度数据 失败", log.Field{Key: "err", Value: err.Error()})
			errdata = &pb.ErrorData{
				Code:    pb.ErrorCode_ExternalModule,
				Title:   pb.ErrorCode_ExternalModule.ToString(),
				Message: fmt.Sprintf("ModuleBuried.CheckCondition Error:%s", err.Error()),
			}
			return
		}
		for _, v := range condis {
			condisMap[v.Conid] = v
		}
	}

	for _, v := range tasks {
		if conf, err = this.configure.gettaskconfconfigure(v); err != nil {
			errdata = &pb.ErrorData{
				Code:    pb.ErrorCode_ConfigNoFound,
				Title:   pb.ErrorCode_ConfigNoFound.ToString(),
				Message: err.Error(),
			}
			return
		}
		task := &pb.DBWTaskItem{
			Tid:    v,
			Conlds: make([]*pb.ConIProgress, len(conf.Completetask)),
		}
		for i, v := range conf.Completetask {
			task.Conlds[i] = condisMap[v]
		}
		progress = append(progress, task)
	}
	return
}

// 清除商队任务
func (this *WTask) ClearCaravanTask(session comm.IUserSession, task int32) {
	var (
		wtask  *pb.DBWTask
		err    error
		change bool
	)

	if wtask, err = this.modelwtask.getUserWTasks(session.GetUserId()); err != nil {
		this.Errorln(err)
		return
	}
	for i, v := range wtask.Accepts {
		if v == task {
			wtask.Accepts = append(wtask.Accepts[0:i], wtask.Accepts[i+1:]...)
			change = true
		}
	}

	if change {
		this.pushtaskprogress(session, wtask, true)
		if err = this.modelwtask.updateUserWTasks(session.GetUserId(), wtask); err != nil {
			this.Errorln(err)
			return
		}
	}
}

// 跳世界任务
func (this *WTask) BingoJumpTask(session comm.IUserSession, taskId int32) (errdata *pb.ErrorData) {
	var (
		wtask       *pb.DBWTask
		accepts     []int32            = make([]int32, 0)
		acceptsMap  map[int32]struct{} = make(map[int32]struct{})
		complete    []int32            = make([]int32, 0)
		completeMap map[int32]struct{} = make(map[int32]struct{})
		conf        *cfg.GameWorldTaskData
		update      map[string]interface{} = make(map[string]interface{})
		ok          bool
		err         error
	)
	if conf, err = this.configure.gettaskconfconfigure(taskId); err != nil {
		errdata = &pb.ErrorData{
			Code:    pb.ErrorCode_ConfigNoFound,
			Title:   pb.ErrorCode_ConfigNoFound.ToString(),
			Message: err.Error(),
		}
		return
	}

	if wtask, err = this.modelwtask.getUserWTasks(session.GetUserId()); err != nil {
		errdata = &pb.ErrorData{
			Code:    pb.ErrorCode_DBError,
			Title:   pb.ErrorCode_DBError.ToString(),
			Message: err.Error(),
		}
		return
	}
	for _, v := range wtask.Accepts {
		acceptsMap[v] = struct{}{}
	}
	for _, v := range wtask.Completes {
		completeMap[v] = struct{}{}
	}
	ok = false
	for _, v := range wtask.Activations {
		if taskId == v {
			ok = true
		}
	}

	if ok {
		return
	}

	for {
		if conf.Ontxe != 0 {
			if _, ok = completeMap[conf.Ontxe]; !ok {
				completeMap[conf.Ontxe] = struct{}{}
				if _, ok = acceptsMap[conf.Ontxe]; ok {
					delete(acceptsMap, conf.Ontxe)
				}
			}
			if conf, err = this.configure.gettaskconfconfigure(conf.Ontxe); err != nil {
				errdata = &pb.ErrorData{
					Code:    pb.ErrorCode_ConfigNoFound,
					Title:   pb.ErrorCode_ConfigNoFound.ToString(),
					Message: err.Error(),
				}
				return
			}
		} else {
			break
		}
	}
	for k, _ := range acceptsMap {
		accepts = append(accepts, k)
	}
	for k, _ := range completeMap {
		complete = append(complete, k)
	}

	wtask.Activations = append(wtask.Activations, taskId)
	wtask.Accepts = accepts
	wtask.Completes = complete
	update["activations"] = wtask.Activations
	update["accepts"] = wtask.Accepts
	update["completes"] = wtask.Completes

	if err = this.modelwtask.Change(session.GetUserId(), update); err != nil {
		errdata = &pb.ErrorData{
			Code:    pb.ErrorCode_DBError,
			Title:   pb.ErrorCode_DBError.ToString(),
			Message: err.Error(),
		}
		return
	}
	session.SendMsg(string(this.GetType()), "activationschange", &pb.WTaskActivationsChangePush{Activations: wtask.Activations})
	return
}

// 校验任务进度
func (this *WTask) pushtaskprogress(session comm.IUserSession, wtask *pb.DBWTask, ispush bool) (progress []*pb.DBWTaskItem, errdata *pb.ErrorData) {
	var (
		checkcondlsMap map[int32]struct{} = make(map[int32]struct{})
		checkcondls    []int32            = make([]int32, 0)
		conf           *cfg.GameWorldTaskData
		condis         []*pb.ConIProgress         = make([]*pb.ConIProgress, 0)
		condisMap      map[int32]*pb.ConIProgress = make(map[int32]*pb.ConIProgress)
		err            error
		ok             bool
	)
	progress = make([]*pb.DBWTaskItem, 0)
	if len(wtask.Accepts) == 0 {
		return
	}

	for _, v := range wtask.Accepts {
		if conf, err = this.configure.gettaskconfconfigure(v); err != nil {
			this.Errorln(err)
			errdata = &pb.ErrorData{
				Code:    pb.ErrorCode_ConfigNoFound,
				Title:   pb.ErrorCode_ConfigNoFound.ToString(),
				Message: err.Error(),
			}
			return
		}
		for _, v := range conf.Completetask {
			if _, ok = checkcondlsMap[v]; !ok {
				checkcondlsMap[v] = struct{}{}
				checkcondls = append(checkcondls, v)
			}
		}
	}
	if len(checkcondls) > 0 {
		if condis, err = this.ModuleBuried.CheckCondition(session.GetUserId(), checkcondls...); err != nil {
			this.Error("校验玩家子任务进度数据 失败", log.Field{Key: "err", Value: err.Error()})
			errdata = &pb.ErrorData{
				Code:    pb.ErrorCode_ExternalModule,
				Title:   pb.ErrorCode_ExternalModule.ToString(),
				Message: fmt.Sprintf("ModuleBuried.CheckCondition Error:%s", err.Error()),
			}
			return
		}
		for _, v := range condis {
			condisMap[v.Conid] = v
		}
	}

	for _, v := range wtask.Accepts {
		if conf, err = this.configure.gettaskconfconfigure(v); err != nil {
			errdata = &pb.ErrorData{
				Code:    pb.ErrorCode_ConfigNoFound,
				Title:   pb.ErrorCode_ConfigNoFound.ToString(),
				Message: err.Error(),
			}
			return
		}
		task := &pb.DBWTaskItem{
			Tid:    v,
			Conlds: make([]*pb.ConIProgress, len(conf.Completetask)),
		}
		ok = true
		for i, v := range conf.Completetask {
			task.Conlds[i] = condisMap[v]
		}
		progress = append(progress, task)
	}
	if ispush {
		session.SendMsg(string(this.GetType()), "acceptchange", &pb.WTaskAcceptChangePush{Accepts: progress})
	}
	return
}

// 完成任务
func (this *WTask) fishtask(session comm.IUserSession, wtask *pb.DBWTask, ispush bool) (progress []*pb.DBWTaskItem, errdata *pb.ErrorData) {
	var (
		opencmdMap map[string]int32
		opencmd    []string
		user       *pb.DBUser
	)

	if opencmdMap, errdata = this.sys.QueryOpenCondData(session.GetUserId()); errdata != nil {
		this.Error("查询用户功能是否开启表 失败!", log.Field{Key: "key", Value: errdata})
		return
	}
	opencmd = make([]string, 0)
	for k, v := range opencmdMap {
		if v == 2 {
			opencmd = append(opencmd, k)
		}
	}
	if user = this.ModuleUser.GetUser(session.GetUserId()); user == nil {
		this.Error("获取用户信息失败!", log.Field{Key: "uid", Value: session.GetUserId()})
		return
	}
	progress, errdata = this.inquireActivations(session, wtask, user.Lv, opencmd, ispush)
	return
}

// 校验组进度变化
func (this *WTask) checkgroupState(session comm.IUserSession, wtask *pb.DBWTask, group int32) {
	var (
		groupTask   map[int32][]*cfg.GameWorldTaskData
		completeMap map[int32]struct{} = make(map[int32]struct{})
		des         int32
		ok          bool
	)
	groupTask = this.configure.getgroupTask()
	for _, v := range wtask.Completes {
		completeMap[v] = struct{}{}
	}
	for _, v := range groupTask[group] {
		if _, ok = completeMap[v.Key]; !ok {
			return
		}
		des = v.Des
	}
	wtask.Groups[group] = 1
	if des == 5 { //商队任务
		this.caravan.TaskGroupComplete(session, group)
	} else if des == 1 { //日常任务
		this.dailytask.TaskGroupComplete(session, group)
	}
}

// 查询可接取任务列表
func (this *WTask) inquireActivations(session comm.IUserSession, wtask *pb.DBWTask, lv int32, opencmd []string, ispush bool) (progress []*pb.DBWTaskItem, errdata *pb.ErrorData) {
	var (
		conf         *cfg.GameWorldTask
		err          error
		activatMap   map[int32]struct{}  = make(map[int32]struct{})
		acceptsMap   map[int32]struct{}  = make(map[int32]struct{})
		completeMap  map[int32]struct{}  = make(map[int32]struct{})
		opencmdMap   map[string]struct{} = make(map[string]struct{})
		condiIds     []int32             = make([]int32, 0)
		ok           bool
		changeActiva bool
		changeAccept bool
	)
	if conf, err = this.configure.getWorldtaskCfg(); err != nil {
		return
	}
	for _, v := range wtask.Activations {
		activatMap[v] = struct{}{}
	}
	for _, v := range wtask.Accepts {
		acceptsMap[v] = struct{}{}
	}
	for _, v := range wtask.Completes {
		completeMap[v] = struct{}{}
	}
	for _, v := range opencmd {
		opencmdMap[v] = struct{}{}
	}
	for _, v := range conf.GetDataList() {
		if _, ok = activatMap[v.Key]; ok { //已在可接取列表中
			continue
		}
		if _, ok = acceptsMap[v.Key]; v.LockAdd == 0 && ok { //已在已接取任务列表中 LockAdd 0 表示只能接取一次 1 表示可以重复接取
			continue
		}
		if _, ok = completeMap[v.Key]; ok { //已在完成列表中
			continue
		}
		if lv < v.Lock || lv > v.Lockend { //等级不符合
			continue
		}
		if _, ok = opencmdMap[v.Opencond]; v.Opencond != "" && !ok { //功能未开启
			continue
		}
		if _, ok = completeMap[v.Ontxe]; v.Ontxe != 0 && !ok { //前置任务判断
			continue
		}
		if v.Des == 5 { //商队任务不主动触发 日常任务直接接取不进入可接取列表中
			continue
		}
		wtask.Activations = append(wtask.Activations, v.Key)
		changeActiva = true
		if v.Des == 2 { //主线任务
			wtask.Currchapter = v.Group
		}
		if _, ok = wtask.Groups[v.Group]; !ok {
			wtask.Groups[v.Group] = 0
		}
	}

	//有新任务接取
	if ispush && changeActiva {
		session.SendMsg(string(this.GetType()), "activationschange", &pb.WTaskActivationsChangePush{Activations: wtask.Activations})
	}

	if changeAccept {
		if errdata = this.ModuleBuried.ActiveCondition(session.GetUserId(), condiIds...); err != nil {
			return
		}
		progress, errdata = this.pushtaskprogress(session, wtask, ispush)
	}
	return
}