package dragon

import (
	"fmt"
	"go_dreamfactory/comm"
	"go_dreamfactory/lego/core"
	"go_dreamfactory/modules"
	"go_dreamfactory/pb"
	"go_dreamfactory/sys/configure"
	cfg "go_dreamfactory/sys/configure/structs"
	"go_dreamfactory/sys/db"
	"time"

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

func NewModule() core.IModule {
	m := new(Dragon)
	return m
}

type Dragon struct {
	modules.ModuleBase
	service     core.IService
	api         *apiComp
	configure   *configureComp
	modelDragon *ModelDragon
}

// 模块名
func (this *Dragon) GetType() core.M_Modules {
	return comm.ModuleDragon
}

// 模块初始化接口 注册用户创建角色事件
func (this *Dragon) 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 *Dragon) OnInstallComp() {
	this.ModuleBase.OnInstallComp()
	this.api = this.RegisterComp(new(apiComp)).(*apiComp)
	this.modelDragon = this.RegisterComp(new(ModelDragon)).(*ModelDragon)
	this.configure = this.RegisterComp(new(configureComp)).(*configureComp)
}
func (this *Dragon) Start() (err error) {
	err = this.ModuleBase.Start()

	return
}

// 获取坐骑列表
func (this *Dragon) GetDragonList(uid string) (list []*pb.DBDragon, err error) {
	return this.modelDragon.GetDragonList(uid)
}

// 创建坐骑
func (this *Dragon) CreateDragon(session comm.IUserSession, dragons map[string]int32, bPush bool) (errdata *pb.ErrorData) {
	return this.modelDragon.CreateDragon(session, dragons)
}

func (this *Dragon) CreateRobotDragon(dragonid string, lv int32) (dragon *pb.DBDragon, err error) {
	var (
		conf *cfg.GameTrainlvData
	)
	dragon = &pb.DBDragon{
		Id:       "",
		Uid:      "",
		Dragonid: dragonid,
		Lv:       lv,
		Exp:      0,
		Property: map[string]int32{},
		Play:     map[int32]*pb.PlayData{},
		Rtime:    configure.Now().Unix(),
	}

	if conf, err = this.configure.GetDragonConfById(dragonid, lv); err != nil {
		return
	}
	if c, err := this.configure.GetDragonMount(dragonid, conf.Type); err == nil {
		dragon.Property["stime"] = c.Stime
		dragon.Property["etime"] = c.Etime
		dragon.Property["hp"] = c.Hp
		dragon.Property["moderate"] = c.Moderate
		dragon.Property["sprint"] = c.Sprint
		dragon.Property["acceleration"] = c.Acceleration
		dragon.Property["deceleration"] = c.Deceleration
		// dragon.Property["itemsprint"] = c.Itemsprint
		dragon.Property["caddtime"] = c.Caddtime
		dragon.Property["csubtime"] = c.Csubtime
	}
	return
}

func (this *Dragon) QueryBigDragonList(uid string) (dragon []*pb.DBDragon, err error) {
	var (
		list []*pb.DBDragon
	)

	if list, err = this.modelDragon.GetDragonList(uid); err != nil {
		return
	}
	for _, v := range list {
		if c, err := this.configure.GetDragonConfById(v.Dragonid, v.Lv); err == nil {
			if c.Type == 3 {
				dragon = append(dragon, v)
			}
		}
	}
	return
}

func (this *Dragon) QueryDragonById(uid string, dragonid string) (dragon *pb.DBDragon, err error) {
	var (
		list []*pb.DBDragon
	)

	if list, err = this.modelDragon.GetDragonList(uid); err != nil {
		return
	}
	for _, v := range list {
		if v.Dragonid == dragonid {
			dragon = v
			return
		}
	}
	err = fmt.Errorf("not found dragon dragonid:%s", dragonid)
	return
}

// 通过区服id 和唯一id 查询坐骑信息
func (this *Dragon) QueryDragonByTagAndOid(tag string, objId string) (dragon *pb.DBDragon, err error) {
	var (
		conn  *db.DBConn
		model *db.DBModel
	)
	if conn, err = db.ServerDBConn(tag); err != nil {
		return
	}
	dragon = &pb.DBDragon{}
	model = db.NewDBModel(this.modelDragon.TableName, time.Hour, conn)
	if model.DB.FindOne(comm.TableHero, bson.M{"_id": objId}).Decode(dragon); err != nil {
		return
	}

	return
}