package equipment

import (
	"go_dreamfactory/comm"
	"go_dreamfactory/lego/core"
	"go_dreamfactory/lego/sys/log"
	"go_dreamfactory/modules"
	"go_dreamfactory/pb"
	cfg "go_dreamfactory/sys/configure/structs"
	"math/rand"
	"time"

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

///装备 数据组件
type modelEquipmentComp struct {
	modules.MCompModel
	module *Equipment
}

//组件初始化接口
func (this *modelEquipmentComp) Init(service core.IService, module core.IModule, comp core.IModuleComp, opt core.IModuleOptions) (err error) {
	this.TableName = comm.TableEquipment
	this.MCompModel.Init(service, module, comp, opt)
	this.module = module.(*Equipment)
	//创建uid索引
	this.DB.CreateIndex(core.SqlTable(this.TableName), mongo.IndexModel{
		Keys: bsonx.Doc{{Key: "uid", Value: bsonx.Int32(1)}},
	})
	return
}

//查询用户装备数据
func (this *modelEquipmentComp) QueryUserEquipmentsById(uId, id string) (equipment *pb.DB_Equipment, err error) {
	equipment = &pb.DB_Equipment{}
	err = this.GetListObj(uId, id, equipment)
	return
}

//查询用户装备数据
func (this *modelEquipmentComp) QueryUserEquipmentsByIds(uId string, ids []string) (equipments []*pb.DB_Equipment, err error) {
	equipments = []*pb.DB_Equipment{}
	err = this.GetListObjs(uId, ids, &equipments)
	return
}

///查询用户的武器背包
func (this *modelEquipmentComp) QueryUserEquipments(uId string) (equipments []*pb.DB_Equipment, err error) {
	equipments = make([]*pb.DB_Equipment, 0)
	if err = this.GetList(uId, &equipments); err != nil {
		this.module.Errorf("err:%v", err)
	}
	return
}

///查询目标卡片数量
func (this *modelEquipmentComp) QueryEquipmentAmount(uid string, equipmentId string) (amount uint32) {
	var (
		equipments []*pb.DB_Equipment
		err        error
	)
	amount = 0
	if equipments, err = this.QueryUserEquipments(uid); err != nil {
		return
	}
	for _, v := range equipments {
		if v.CId == equipmentId {
			amount += v.OverlayNum
		}
	}
	return
}

//添加装备
func (this *modelEquipmentComp) AddEquipments(session comm.IUserSession, cIds map[string]uint32) (change []*pb.DB_Equipment, err error) {
	var (
		configure  *cfg.GameEquip
		equipments []*pb.DB_Equipment
		iskeep     bool
		add        map[string]*pb.DB_Equipment
		update     map[string]*pb.DB_Equipment
		uId        string = session.GetUserId()
	)
	if configure, err = this.module.configure.GetEquipmentConfigure(); err != nil {
		return
	}
	if equipments, err = this.QueryUserEquipments(uId); err != nil {
		return
	}
	add = make(map[string]*pb.DB_Equipment)
	update = make(map[string]*pb.DB_Equipment)
	change = make([]*pb.DB_Equipment, 0, len(equipments))
	for k, v := range cIds {
		iskeep = false
		for _, equipment := range equipments {
			if equipment.CId == k && equipment.IsInitialState {
				update[equipment.Id] = equipment
				change = append(change, equipment)
				equipment.OverlayNum += v
				iskeep = true
				break
			}
		}
		if !iskeep {
			if c, ok := configure.GetDataMap()[k]; ok {
				if equipment, err := this.newEquipment(uId, c, v); err != nil {
					return nil, err
				} else {
					//随机任务
					this.module.ModuleRtask.SendToRtask(session, comm.Rtype50, 1, c.Star)
					add[equipment.Id] = equipment
					change = append(change, equipment)
				}
			}
		}
	}
	if len(add) > 0 {
		if err = this.AddLists(uId, add); err != nil {
			log.Errorf("err:%v", err)
			return
		}
	}

	for _, v := range update {
		if err = this.ChangeList(uId, v.Id, map[string]interface{}{"overlayNum": v.OverlayNum}); err != nil {
			log.Errorf("err:%v", err)
			return
		}
	}
	return
}

//删除装备
func (this *modelEquipmentComp) DelEquipments(uId string, eIds []string) (change []*pb.DB_Equipment, err error) {
	change = make([]*pb.DB_Equipment, 0)
	if err = this.DelListlds(uId, eIds...); err != nil {
		this.module.Errorln(err)
		return
	}
	for _, v := range eIds {
		change = append(change, &pb.DB_Equipment{
			Id:         v,
			UId:        uId,
			OverlayNum: 0,
		})
	}
	return
}

//更新武器挂载信息
func (this *modelEquipmentComp) UpdateByHeroId(uid string, equipments ...*pb.DB_Equipment) (err error) {
	for _, v := range equipments {
		if err = this.ChangeList(uid, v.Id, map[string]interface{}{
			"heroId": v.HeroId,
		}); err != nil {
			log.Errorf("err:%v", err)
			return
		}
	}
	return
}

//创建新的武器对象
func (this *modelEquipmentComp) newEquipment(uid string, conf *cfg.GameEquipData, num uint32) (equipment *pb.DB_Equipment, err error) {
	var (
		mattr     []*cfg.GameEquipAttrlibraryData
		sattr     []*cfg.GameEquipAttrlibraryData
		total     int
		satterNum int32
	)
	equipment = &pb.DB_Equipment{
		Id:             primitive.NewObjectID().Hex(),
		CId:            conf.Id,
		Lv:             1,
		UId:            uid,
		OverlayNum:     num,
		IsInitialState: false,
		AdverbEntry:    make([]*pb.EquipmentAttributeEntry, 0),
	}
	if mattr, err = this.module.configure.GetEquipmentAttrlibraryConfigureById(conf.Leadlibrary); err != nil || len(mattr) == 0 {
		return
	}
	equipment.MainEntry = &pb.EquipmentAttributeEntry{
		Id:        mattr[0].Key,
		Libraryid: mattr[0].Libraryid,
		Lv:        1,
		AttrName:  mattr[0].Attrkey,
		Value:     mattr[0].Attrvar,
		BaseValue: mattr[0].Attrvar,
	}
	if sattr, err = this.module.configure.GetEquipmentAttrlibraryConfigureById(conf.Addlibrary); err != nil || len(mattr) == 0 {
		return
	}

	for _, v := range conf.Addattrnump {
		total += int(v)
	}
	n := rand.Intn(total)
	for i, v := range conf.Addattrnump {
		if int32(n) <= v {
			satterNum = conf.Addattrnum[i]
			break
		}
	}
	if satterNum > 0 && satterNum <= 4 {
		r := rand.New(rand.NewSource(time.Now().Unix()))
		for _, v := range r.Perm(len(sattr))[:satterNum] {
			equipment.AdverbEntry = append(equipment.AdverbEntry, &pb.EquipmentAttributeEntry{
				Id:        sattr[v].Key,
				Libraryid: sattr[v].Libraryid,
				Lv:        1,
				AttrName:  sattr[v].Attrkey,
				Value:     sattr[v].Attrvar,
				BaseValue: sattr[v].Attrvar,
			})
		}
	}
	return
}

//升级武器
func (this *modelEquipmentComp) upgradeEquipment(equipment *pb.DB_Equipment, equip *cfg.GameEquipData, intensify *cfg.GameEquipIntensifyData) (err error) {
	equipment.Lv++
	equipment.MainEntry.Lv++
	equipment.MainEntry.Value = equipment.MainEntry.BaseValue + int32(float64(equipment.MainEntry.BaseValue)*float64(intensify.Bonus)/1000.0)
	if !intensify.Activation { //不触发副词条变化
		return
	}
	if len(equipment.AdverbEntry) < 4 { //去随机副词条
		var temp []*cfg.GameEquipAttrlibraryData
		var sattr []*cfg.GameEquipAttrlibraryData
		if temp, err = this.module.configure.GetEquipmentAttrlibraryConfigureById(equip.Addlibrary); err != nil || len(temp) == 0 {
			log.Errorf("升级服务错误 读取副词条配置错误!")
			return
		}
		//检索出未使用的词条
		for _, v := range temp {
			iskeep := false
			for _, v1 := range equipment.AdverbEntry {
				if v.Key == v1.Id {
					iskeep = true
				}
			}
			if !iskeep {
				sattr = append(sattr, v)
			}
		}
		r := rand.New(rand.NewSource(time.Now().Unix()))
		index := r.Perm(len(sattr))[0]
		equipment.AdverbEntry = append(equipment.AdverbEntry, &pb.EquipmentAttributeEntry{
			Id:        sattr[index].Key,
			Libraryid: sattr[index].Libraryid,
			Lv:        1,
			AttrName:  sattr[index].Attrkey,
			Value:     sattr[index].Attrvar,
		})
	} else { //随机一个副词条 强化
		var attrlibrary *cfg.GameEquipAttrlibraryData
		r := rand.New(rand.NewSource(time.Now().Unix()))
		index := r.Perm(len(equipment.AdverbEntry))[0]

		if attrlibrary, err = this.module.configure.GetEquipmentAttrlibraryConfigureByKey(equipment.AdverbEntry[index].Id); err != nil {
			return
		}
		equipment.AdverbEntry[index].Value = equipment.AdverbEntry[index].BaseValue + int32(float64(attrlibrary.Addition[equipment.AdverbEntry[index].Lv-1])/1000.0*float64(equipment.AdverbEntry[index].BaseValue))
		equipment.AdverbEntry[index].Lv++
	}
	return
}