package growtask

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

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

type ModelGrowtask struct {
	modules.MCompModel
	moduleGrowtask *Growtask
}

func (this *ModelGrowtask) Init(service core.IService, module core.IModule, comp core.IModuleComp, options core.IModuleOptions) (err error) {
	err = this.MCompModel.Init(service, module, comp, options)
	this.TableName = comm.TableGrowtask
	this.moduleGrowtask = module.(*Growtask)
	return
}

// 初始化成长任务
func (this *ModelGrowtask) initGrowtask(uid string, taskType int32) (*pb.DBGrowtask, error) {
	gtConf, err := this.moduleGrowtask.configure.getGrowtaskCfg()
	if err != nil {
		return nil, err
	}

	if gtConf == nil {
		return nil, errors.New("growtask config is nil")
	}
	data := &pb.DBGrowtask{
		Uid: uid,
	}

	update := map[string]interface{}{}
	for _, v := range gtConf.GetDataList() {
		if taskType == v.Type {
			task := &pb.Growtask{
				Id:       v.Id,
				TaskType: v.Type,
				Fstask:   v.Fstask,
				PreTask:  v.Onetask,
			}
			if v.Type == taskType && taskType == 1 { //默认状态：锁定
				data.InitTaskList = append(data.InitTaskList, task)
			} else if v.Type == taskType && taskType == 2 {
				data.MidTaskList = append(data.MidTaskList, task)
			} else if v.Type == taskType && taskType == 3 {
				data.HighTaskList = append(data.HighTaskList, task)
			}
		}
	}
	update["uid"] = data.Uid

	update["curTaskType"] = taskType
	if taskType == 1 {
		update["initTaskList"] = data.InitTaskList
	} else if taskType == 2 {
		update["midTaskList"] = data.MidTaskList
	} else if taskType == 3 {
		update["highTaskList"] = data.HighTaskList
	}

	if err = this.Change(uid, update); err != nil {
		return nil, err
	}
	return data, nil
}

// 获取玩家成长任务
func (this *ModelGrowtask) getUserGrowtask(uid string) (*pb.DBGrowtask, error) {
	gt := &pb.DBGrowtask{}
	if err := this.Get(uid, gt); err != nil {
		if err == mongo.ErrNoDocuments {
			return this.initGrowtask(uid, 1) //从初级任务开始初始
		}
		return nil, err
	}
	return gt, nil
}

// 任务列表
func (this *ModelGrowtask) list(uid string, taskType int32, gt *pb.DBGrowtask) ([]*pb.Growtask, int32) {

	var (
		curList   []*pb.Growtask
		curTaskId int32
	)

	getList := func(list []*pb.Growtask) []*pb.Growtask {
		taskStatusMap := make(map[int32]pb.GrowtaskStatus) //任务状态
		for _, v := range list {
			//已完成
			if v.Status == pb.GrowtaskStatus_Finish {
				taskStatusMap[v.Id] = pb.GrowtaskStatus_Finish
				continue
			}

			//上个任务是否完成
			pre := this.preTaskStatus(v.PreTask, v.TaskType-1, gt)
			if pre != nil {
				if v.TaskType-1 >= 1 &&
					pre.Status == pb.GrowtaskStatus_Finish &&
					pre.TaskType == v.TaskType-1 { //非初级
					taskStatusMap[v.PreTask] = pb.GrowtaskStatus_Finish
				}
			} else {
				taskStatusMap[v.Id] = v.Status
			}

			//任务完成
			if _, err := this.moduleGrowtask.ModuleBuried.CheckCondition(uid, v.Fstask); err == nil {
				if v.PreTask == 0 {
					v.Status = pb.GrowtaskStatus_Wait //待领奖状态
				} else {
					if s, ok := taskStatusMap[v.PreTask]; ok {
						// 上个任务是领取状态
						if s == pb.GrowtaskStatus_Wait {
							continue
						} else if s == pb.GrowtaskStatus_Finish {
							v.Status = pb.GrowtaskStatus_Wait //待领状态
						}
					}
				}
			} else {
				if v.PreTask == 0 {
					v.Status = pb.GrowtaskStatus_Ongoing //进行中
				} else {
					if s, ok := taskStatusMap[v.PreTask]; ok {
						// 上个任务是领取状态
						if s == pb.GrowtaskStatus_Ongoing {
							v.Status = pb.GrowtaskStatus_Lock
							continue
						}
					}
				}
			}
		}
		return list
	}

	getCurTaskId := func(list []*pb.Growtask) (curTaskId int32) {
		for _, v := range list {
			if v.Status == pb.GrowtaskStatus_Ongoing ||
				v.Status == pb.GrowtaskStatus_Wait {
				curTaskId = v.Id
				return
			}
		}
		return
	}

	if gt.Uid != "" {
		update := map[string]interface{}{}
		switch taskType {
		case 1:
			curList = getList(gt.InitTaskList)
			update["initTaskList"] = curList
			curTaskId = getCurTaskId(curList)
		case 2:
			curList = getList(gt.MidTaskList)
			update["midTaskList"] = curList
			curTaskId = getCurTaskId(curList)
		case 3:
			curList = getList(gt.HighTaskList)
			update["highTaskList"] = curList
			curTaskId = getCurTaskId(curList)
		}

		//更新
		if len(update) > 0 {
			if err := this.Change(uid, update); err != nil {
				log.Errorf("更新任务列表 err:%v", err)
				return nil, 0
			}
		}
	}

	return curList, curTaskId
}

// 获取上一个任务状态
func (this *ModelGrowtask) preTaskStatus(preTaskId int32, preTaskType int32, gt *pb.DBGrowtask) *pb.Growtask {
	switch preTaskType {
	case 1:
		for _, v := range gt.InitTaskList {
			if v.Id == preTaskId {
				return v
			}
		}
	case 2:
		for _, v := range gt.MidTaskList {
			if v.Id == preTaskId {
				return v
			}
		}
	case 3:
		for _, v := range gt.HighTaskList {
			if v.Id == preTaskId {
				return v
			}
		}
	}
	return nil
}

// 领取子任务奖励
func (this *ModelGrowtask) receive(uid string, taskId int32) error {
	gt, err := this.getUserGrowtask(uid)
	if err != nil {
		return err
	}

	switch gt.CurTaskType {
	case 1:
		for _, v := range gt.InitTaskList {
			if v.Id == taskId {
				if v.Status == pb.GrowtaskStatus_Wait {
					v.Status = pb.GrowtaskStatus_Finish
				} else {
					return errors.New("不能领取")
				}
				break
			}
		}
		//更新
		update := map[string]interface{}{
			"initTaskList": gt.InitTaskList,
		}
		if err := this.Change(uid, update); err != nil {
			log.Errorf("更新任务列表 err:%v", err)
			return err
		}
	case 2:
		for _, v := range gt.MidTaskList {
			if v.Id == taskId {
				if v.Status == pb.GrowtaskStatus_Wait {
					v.Status = pb.GrowtaskStatus_Finish
				} else {
					return errors.New("不能领取")
				}
				break
			}
		}
		//更新
		update := map[string]interface{}{
			"midTaskList": gt.MidTaskList,
		}
		if err := this.Change(uid, update); err != nil {
			log.Errorf("更新任务列表 err:%v", err)
			return err
		}
	case 3:
		for _, v := range gt.HighTaskList {
			if v.Id == taskId {
				if v.Status == pb.GrowtaskStatus_Wait {
					v.Status = pb.GrowtaskStatus_Finish
				} else {
					return errors.New("不能领取")
				}
				break
			}
		}
		//更新
		update := map[string]interface{}{
			"highTaskList": gt.HighTaskList,
		}
		if err := this.Change(uid, update); err != nil {
			log.Errorf("更新任务列表 err:%v", err)
			return err
		}
	}

	return nil
}

// 当前进阶是否全部完成
func (this *ModelGrowtask) isAllFinish(gt *pb.DBGrowtask, taskType int32) bool {
	switch taskType {
	case 1:
		for _, v := range gt.InitTaskList {
			if v.Status != pb.GrowtaskStatus_Finish {
				return false
			}
		}
	case 2:
		for _, v := range gt.MidTaskList {
			if v.Status != pb.GrowtaskStatus_Finish {
				return false
			}
		}
	case 3:
		for _, v := range gt.HighTaskList {
			if v.Status != pb.GrowtaskStatus_Finish {
				return false
			}
		}
	default:
		return false
	}

	return true
}