package task

import (
	"go_dreamfactory/comm"
	"go_dreamfactory/lego/core"
	"go_dreamfactory/lego/sys/log"
	"go_dreamfactory/modules"
	"go_dreamfactory/pb"
	"sort"

	"go.mongodb.org/mongo-driver/bson/primitive"
)

const ( //Redis
	TableTask core.SqlTable = "task" //每日任务表
)

type ModelTask struct {
	modules.MCompModel
	moduleTask *ModuleTask
}

func (this *ModelTask) Init(service core.IService, module core.IModule, comp core.IModuleComp, options core.IModuleOptions) (err error) {
	err = this.MCompModel.Init(service, module, comp, options)
	this.moduleTask = module.(*ModuleTask)
	this.TableName = string(TableTask)
	return
}

// 玩家的所有任务列表
func (this *ModelTask) getTaskList(uid string) (list []*pb.DBTask) {
	if err := this.GetList(uid, &list); err != nil {
		log.Errorf("getTaskList err %v", err)
		return
	}
	return
}

//获取玩家任务列表
func (this *ModelTask) getTaskListByTag(uid string, taskTag comm.TaskTag) (newlist []*pb.DBTask) {
	list := []*pb.DBTask{}
	if err := this.GetList(uid, &list); err != nil {
		log.Errorf("getTaskList err %v", err)
		return
	}

	sort.SliceStable(list, func(i, j int) bool {
		return list[i].Sort < list[j].Sort
	})

	var taskList []*pb.DBTask
	for _, v := range list {
		if v.Tag == int32(taskTag) {
			taskList = append(taskList, v)
		}
	}

	// 当前玩家任务
	getCurTask := func(taskId int32) *pb.DBTask {
		for _, v := range list {
			if v.TaskId == taskId {
				return v
			}
		}
		return nil
	}

	// 判断上个任务领取了才显示最后一个任务
	isReceived := func(taskId int32) bool {
		if preCnf := this.moduleTask.configure.getPreTask(taskId); preCnf != nil {
			if preTask := getCurTask(preCnf.Key); preTask != nil {
				if preTask.Received == 1 {
					return true
				}
			}
		}
		return false
	}

	if taskTag == comm.TASK_ACHIEVE {
		for _, v := range taskList {
			if curTask := this.moduleTask.configure.getTaskById(v.TaskId); curTask != nil {
				if v.Received == 0 && curTask.IdAfter == 0 && this.moduleTask.configure.isFirstTask(curTask.Key) { //未领取和没有下个连续任务的
					newlist = append(newlist, v)
				} else if this.moduleTask.configure.isFirstTask(curTask.Key) && curTask.IdAfter != 0 { //连续任务的第一个任务
					next := this.moduleTask.configure.getTaskById(curTask.IdAfter)
					if next != nil && v.Received == 0 {
						newlist = append(newlist, v)
					}
				} else {
					if isReceived(curTask.Key) {
						newlist = append(newlist, v)
					}
				}

			}

		}
	} else {
		newlist = taskList
	}
	return
}

// 获取用户任务
func (this *ModelTask) getTaskById(uid string, taskId int32) (newlist []*pb.DBTask) {
	list := []*pb.DBTask{}
	if err := this.GetList(uid, &list); err != nil {
		log.Errorf("getTaskById err %v", err)
		return
	}

	for _, v := range list {
		if v.TaskId == taskId {
			newlist = append(newlist, v)
		}
	}
	return
}

//初始化任务
func (this *ModelTask) initTask(uid string) error {
	if data, err := this.moduleTask.configure.getTaskList(); err == nil {
		for _, cnf := range data {
			objId := primitive.NewObjectID().Hex()
			task := &pb.DBTask{
				Id:       objId,
				Tag:      cnf.IdTag,
				Uid:      uid,
				TypeId:   cnf.TypeId,
				TaskId:   cnf.Key,
				Active:   cnf.Active,
				Progress: cnf.ConditionSecond,
				Sort:     cnf.IdList,
			}
			if err := this.AddList(uid, task.Id, task); err != nil {
				log.Errorf("initTask addlists err %v", err)
				return err
			}
		}
	}
	return nil
}

//查询用户任务
func (this *ModelTask) getUserTask(uid string, taskId string) *pb.DBTask {
	userTask := &pb.DBTask{}
	if err := this.moduleTask.modelTask.GetListObj(uid, taskId, userTask); err != nil {
		log.Errorf("getUserTask err:%v", err)
		return nil
	}
	return userTask
}

// 获取待处理的任务
func (this *ModelTask) getUnFinishTasks(uid string, taskId int32) (list []*pb.DBTask) {
	taskList := this.getTaskById(uid, taskId)
	for _, v := range taskList {
		if v.Status == 0 {
			list = append(list, v)
		}
	}
	return
}

//活跃度统计
func (this *ModelTask) countActive(uid string, taskTag comm.TaskTag) (total int32) {
	taskList := this.getTaskListByTag(uid, taskTag)
	for _, v := range taskList {
		if v.Status == 1 {
			total += v.Active
		}
	}
	return
}

//检查任务状态 返回等待处理的任务
func (this *ModelTask) checkTask(uid string, taskId int32) (*pb.DBTask, bool) {
	taskList := this.getUnFinishTasks(uid, taskId)
	for _, v := range taskList {
		if taskId == v.TaskId && v.Status == 0 {
			return v, true
		}
	}
	return nil, false
}

//更改用户任务
func (this *ModelTask) modifyUserTask(uid string, taskId string, data map[string]interface{}) error {
	if err := this.ChangeList(uid, taskId, data); err != nil {
		log.Errorf("err %v", err)
		return err
	}
	return nil
}

//清空任务
func (this *ModelTask) clearTask(uid string, taskTag ...comm.TaskTag) {
	if len(taskTag) == 0 {
		log.Errorf("least one param for taskTag")
		return
	}
	taskList := this.getTaskListByTag(uid, taskTag[0])
	for _, v := range taskList {
		if err := this.moduleTask.modelTask.DelListlds(uid, v.Id); err != nil {
			log.Errorf("uid: %v  err:%v", uid, err)
			return
		}
	}
}

//进入卡牌攻略
func (this *ModelTask) inStrategy(uid string, heroCfgId int32) (taskIds []int32, err error) {
	//检查此英雄攻略是否完成
	taskList := this.getTaskListByTag(uid, comm.TASK_STRATEGY)
	allFinished := true
	for _, v := range taskList {
		conf := this.moduleTask.configure.getTaskById(v.TaskId)
		if conf != nil {
			if conf.RestrictiveCondition == heroCfgId && v.Status != 1 {
				allFinished = false
				break
			}
		}
	}

	if !allFinished {
		//重置状态
		for _, v := range taskList {
			if v.Status != 0 {
				update := map[string]interface{}{
					"status": 0,
				}
				if err = this.modifyUserTask(uid, v.Id, update); err != nil {
					this.moduleTask.Errorf("doStrategy err %v", err)
					break
				}
			}
			taskIds = append(taskIds, v.TaskId)
		}
	}

	return
}

// 任务类型-装备升级
func (this *ModelTask) UpEquip(uid string, taskId int32, tp *pb.TaskParam) *pb.DBTask {
	return nil
}

// 任务类型-英雄星级升级
func (this *ModelTask) UpHeroStar(uid string, taskId int32, tp *pb.TaskParam) *pb.DBTask {
	return nil
}

// 任务类型-英雄等级升级
func (this *ModelTask) UpHeroLevel(uid string, taskId int32, tp *pb.TaskParam) *pb.DBTask {
	if task, ok := this.checkTask(uid, taskId); ok {
		var progress int32
		// 任务完成
		if tp.Second >= task.Progress {
			progress = 0
			update := map[string]interface{}{
				"progress": progress,
				"status":   1,
			}
			if err := this.modifyUserTask(task.Uid, task.Id, update); err != nil {
				log.Errorf("err %v", err)
				return nil
			}
			task.Progress = progress
			task.Status = 1
			return task
		} else {
			// 任务未完成
			progress = task.Progress - tp.Second
			if progress <= 0 {
				progress = 0
			}
			update := map[string]interface{}{
				"progress": progress,
			}
			if err := this.modifyUserTask(task.Uid, task.Id, update); err != nil {
				log.Errorf("err %v", err)
				return nil
			}
			task.Progress = progress
			return task
		}
	}
	return nil
}

// 任务处理
func (this *ModelTask) doTaskHandle(uid string, taskType comm.TaskType, taskParam *pb.TaskParam) (tasks []*pb.DBTask, err error) {
	data, err := this.moduleTask.configure.getTasks(int32(taskType))
	if err != nil {
		log.Errorf("taskHandle err %v", err)
		return nil, err
	}

	for _, conf := range data {
		if handle, ok := this.moduleTask.taskHandleMap[conf.TypeId]; ok {
			if task := handle(uid, conf.Key, taskParam); task != nil {
				tasks = append(tasks, task)
			}
		}
	}
	return
}