package task

import (
	"go_dreamfactory/comm"
	"go_dreamfactory/lego/core"
	"go_dreamfactory/lego/sys/mgo"
	"go_dreamfactory/modules"
	"go_dreamfactory/pb"

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

type ModelTaskActive struct {
	modules.MCompModel
	module *ModuleTask
}

func (this *ModelTaskActive) Init(service core.IService, module core.IModule, comp core.IModuleComp, options core.IModuleOptions) (err error) {
	this.TableName = comm.TableTaskActive
	err = this.MCompModel.Init(service, module, comp, options)
	this.module = module.(*ModuleTask)
	// 加索引
	this.DB.CreateIndex(core.SqlTable(this.TableName), mongo.IndexModel{
		Keys: bsonx.Doc{{Key: "uid", Value: bsonx.Int32(1)}},
	})
	return
}

// 初始化活跃度
func (this *ModelTaskActive) initActiveReward(active *pb.DBActivity, taskTag comm.TaskTag) {
	data := this.module.configure.getTaskActiveByTag(int32(taskTag))
	for _, conf := range data {
		ta := &pb.ActivityData{
			Tag:    int32(taskTag),
			TaskId: conf.Key,
		}
		active.ActivityList = append(active.ActivityList, ta)
	}
}

func (this *ModelTaskActive) getActiveList(uid string) (active *pb.DBActivity, err error) {
	active = &pb.DBActivity{}
	if err = this.Get(uid, active); err != nil && err != mgo.MongodbNil {
		this.module.Errorf("getTaskList err %v", err)
		return
	}
	if err == mongo.ErrNoDocuments {
		objId := primitive.NewObjectID().Hex()
		active = &pb.DBActivity{
			Uid:          uid,
			Id:           objId,
			ActivityList: make([]*pb.ActivityData, 0),
		}
		err = this.Add(uid, active)
	}
	return
}

// 获取玩家活跃度列表
func (this *ModelTaskActive) getActiveListByTag(uid string, taskTag comm.TaskTag) (list []*pb.ActivityData) {
	task := &pb.DBActivity{}
	if err := this.Get(uid, task); err != nil {
		this.module.Errorf("getTaskList err %v", err)
		return
	}

	for _, v := range task.ActivityList {
		if v.Tag == int32(taskTag) {
			list = append(list, v)
		}
	}

	return list
}

// 查询完成的且未领取的任务 发现未领取返回true
func (this *ModelTaskActive) noReceiveTaskActive(user *pb.DBUserExpand, activityList []*pb.ActivityData, taskTag comm.TaskTag) (bool, error) {

	for _, v := range activityList {
		if v.Tag == int32(taskTag) && v.Received == 0 {
			conf := this.module.configure.getTaskActiveById(v.TaskId)
			if conf != nil && user != nil {
				switch taskTag {
				case comm.TASK_DAILY:
					if user.Activeday >= conf.Active {
						return true, nil
					}
				case comm.TASK_WEEKLY:
					if user.Activeweek >= conf.Active {
						return true, nil
					}
				}
			}
		}
	}
	return false, nil
}

// 获取玩家活跃记录 id 唯一ID
func (this *ModelTaskActive) getUserActive(uid string, taskId int32, taskTag comm.TaskTag) *pb.ActivityData {
	record := this.getActiveListByTag(uid, taskTag)
	for _, v := range record {
		if v.TaskId == taskId {
			return v
		}
	}
	return nil
}

func (this *ModelTaskActive) updateReceive(uid string, data map[string]interface{}) (err error) {
	if len(data) == 0 {
		return
	}
	return this.module.modelTaskActive.Change(uid, data)
}

// 清空活跃度任务
func (this *ModelTaskActive) clearTask(uid string, taskTag ...comm.TaskTag) {
	if len(taskTag) == 0 {
		this.module.Errorf("least one param for taskTag")
		return
	}
	var (
		active *pb.DBActivity
		err    error
	)
	if active, err = this.getActiveList(uid); err != nil {
		this.module.Errorln(err)
		return
	}
	for i := 0; i < len(active.ActivityList); i++ {
		if active.ActivityList[i].Tag == int32(taskTag[0]) {
			active.ActivityList = append(active.ActivityList[:i], active.ActivityList[i+1:]...)
			i--
		}
	}
	update := map[string]interface{}{
		"activityList": active.ActivityList,
	}
	if err := this.module.modelTaskActive.Change(uid, update); err != nil {
		this.module.Errorf("uid: %v err:%v", uid, err)
		return
	}

}