package privilege

import (
	"go_dreamfactory/comm"
	"go_dreamfactory/lego/core"
	"go_dreamfactory/lego/sys/event"
	"go_dreamfactory/lego/sys/mgo"
	"go_dreamfactory/modules"
	"go_dreamfactory/pb"
	"go_dreamfactory/sys/configure"
	cfg "go_dreamfactory/sys/configure/structs"
	"go_dreamfactory/utils"

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

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

type Privilege struct {
	modules.ModuleBase
	api_comp       *apiComp
	configure      *configureComp
	modelPrivilege *ModelPrivilege
	mail           comm.Imail
	service        core.IService
	modelVip       *ModelVip
}

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

//模块初始化接口 注册用户创建角色事件
func (this *Privilege) Init(service core.IService, module core.IModule, options core.IModuleOptions) (err error) {
	if err = this.ModuleBase.Init(service, module, options); err != nil {
		return
	}
	this.service = service
	return
}

//装备组件
func (this *Privilege) OnInstallComp() {
	this.ModuleBase.OnInstallComp()
	this.api_comp = this.RegisterComp(new(apiComp)).(*apiComp)
	this.modelPrivilege = this.RegisterComp(new(ModelPrivilege)).(*ModelPrivilege)
	this.configure = this.RegisterComp(new(configureComp)).(*configureComp)
	this.modelVip = this.RegisterComp(new(ModelVip)).(*ModelVip)
}

func (this *Privilege) Start() (err error) {
	var module core.IModule
	if module, err = this.service.GetModule(comm.ModuleMail); err != nil {
		return
	}
	this.mail = module.(comm.Imail)
	if err = this.ModuleBase.Start(); err != nil {
		return
	}
	event.RegisterGO(comm.EventUserOffline, this.EventUserOffline)
	return
}

//Event------------------------------------------------------------------------------------------------------------
func (this *Privilege) EventUserOffline(uid, sessionid string) {
	//this.modelPrivilege.DelByUId(session.GetUserId(), db.SetDBMgoLog(false))
}

// 购买了一个新的特权
func (this *Privilege) Delivery(session comm.IUserSession, pId int32) (errdata *pb.ErrorData, items []*pb.UserAtno) {
	var (
		bFind bool
		cId   int32
		conf  *cfg.GamePrivilegeCardData
		err   error
	)
	if conf, err = this.configure.GetPrivilegeCard(pId); err != nil {
		errdata = &pb.ErrorData{
			Code:    pb.ErrorCode_ConfigNoFound,
			Title:   pb.ErrorCode_ConfigNoFound.ToString(),
			Message: err.Error(),
		}
		return
	}
	cId = pId
	// 是不是购买过
	list, err := this.modelPrivilege.getPrivilegeList(session.GetUserId())
	if err != nil {
		errdata = &pb.ErrorData{
			Code:    pb.ErrorCode_DBError,
			Title:   pb.ErrorCode_DBError.ToString(),
			Message: err.Error(),
		}
		return
	}
	for _, v := range list {
		if v.CId == cId {
			update := map[string]interface{}{}
			if v.ETime > configure.Now().Unix() { // 加时间
				// 检测能否续费
				if v.ETime-configure.Now().Unix() > int64(conf.RenewDay)*24*3600 {
					errdata = &pb.ErrorData{
						Code:  pb.ErrorCode_PayRenewTimeErr,
						Title: pb.ErrorCode_PayRenewTimeErr.ToString(),
					}
					return
				}
				v.ETime += int64(conf.AssertDay) * 24 * 3600
				update["eTime"] = v.ETime
			} else { // 过期了
				v.CTime = configure.Now().Unix()
				v.ETime = v.CTime + int64(conf.AssertDay)*24*3600
				update["cTime"] = v.CTime
				update["eTime"] = v.ETime
			}
			if err = this.modelPrivilege.Change(session.GetUserId(), update); err != nil {
				this.Errorf("err:%v", err)
				return
			}
			bFind = true
			break
		}
	}
	if !bFind { // 创建一条新的信息

		data := &pb.DBPrivilege{
			Id:         primitive.NewObjectID().Hex(),
			Uid:        session.GetUserId(),
			CId:        cId,
			CTime:      configure.Now().Unix(),
			ETime:      configure.Now().Unix() + int64(conf.AssertDay*24*3600), // 设置过期时间
			RewardTime: configure.Now().Unix(),
		}
		// 特权插入
		vip, err := this.modelVip.getVipList(session.GetUserId())
		if err != nil && err == mgo.MongodbNil { // 没有数据 直接创建一条
			vip = &pb.DBVip{
				Id:         primitive.NewObjectID().Hex(),
				Uid:        session.GetUserId(),
				Reward:     map[int32]bool{},
				Privilege:  map[int32]*pb.PrivilegeList{},
				CTime:      configure.Now().Unix(),
				RewardTime: 0,
			}
			if err = this.modelVip.createVipData(session.GetUserId(), vip); err != nil {
				this.Errorf("err:%v", err)
				return
			}
		}
		if vip.Id != "" {
			update := map[string]interface{}{}
			for _, v := range conf.PrivilegeId {
				conf := this.configure.GetPrivilegeData(v)
				if conf != nil {
					if _, ok := vip.Privilege[conf.PrivilegeType]; ok {
						// 过滤重复的特权
						bRepeat := false
						for _, v1 := range vip.Privilege[conf.PrivilegeType].PrivilegeID {
							if v1 == v {
								bRepeat = true
								break
							}
						}
						if !bRepeat {
							vip.Privilege[conf.PrivilegeType].PrivilegeID = append(vip.Privilege[conf.PrivilegeType].PrivilegeID, v)
						}
					} else {
						sz := &pb.PrivilegeList{}
						sz.PrivilegeID = append(sz.PrivilegeID, v)
						vip.Privilege[conf.PrivilegeType] = sz
					}
				}
			}
			update["privilege"] = vip.Privilege
			this.modelVip.modifyVipData(session.GetUserId(), update)
		}
		list = append(list, data)
		this.modelPrivilege.addNewPrivilegeData(session.GetUserId(), data)
		this.SendDailyMail(session, cId, 1, conf.PType)
	}
	// 即使奖励 马上发送
	if errdata, items = this.DispenseAtno(session, conf.DisposableReward, true); errdata != nil {
		return
	}

	// 推送
	session.SendMsg(string(this.GetType()), PrivilegeBuyYuekaResp, &pb.PrivilegeBuyYuekaResp{Data: list})
	go this.AsynHandleSession(session.Clone(), func(session comm.IUserSession) {
		this.WriteUserLog(session.GetUserId(), pId, 0, "PrivilegeBuyYuekaReq", items)
	})
	return
}

// 续费特权
func (this *Privilege) RenewPrivilegeCard(session comm.IUserSession, cId int32) (errdata *pb.ErrorData) {
	list, err := this.modelPrivilege.getPrivilegeList(session.GetUserId())
	if err != nil {
		return
	}
	for _, v := range list {
		if v.CId == cId {
			conf, err := this.configure.GetPrivilegeCard(cId)
			if err != nil {
				errdata = &pb.ErrorData{
					Code:    pb.ErrorCode_ConfigNoFound,
					Title:   pb.ErrorCode_ReqParameterError.ToString(),
					Message: err.Error(),
				}
				return

			}
			if conf.RenewDay >= int32(configure.Now().Unix()-v.ETime)/(24*3600) {
				v.ETime += int64(conf.AssertDay) * 24 * 3600
				mapData := make(map[string]interface{}, 0)
				mapData["eTime"] = v.ETime
				this.modelPrivilege.modifyPrivilegeData(session.GetUserId(), v.Id, mapData)
				// 发放奖励
				if errdata = this.DispenseRes(session, conf.DisposableReward, true); errdata != nil {
					break
				}
				session.SendMsg(string(this.GetType()), PrivilegeBuyYuekaResp, &pb.PrivilegeGetListResp{Data: list})
				go this.AsynHandleSession(session.Clone(), func(session comm.IUserSession) {
					this.WriteUserLog(session.GetUserId(), cId, 0, "PrivilegeGetListReq", conf.DisposableReward)
				})
			} else {
				errdata = &pb.ErrorData{
					Code:  pb.ErrorCode_PrivilegeRenewTime,
					Title: pb.ErrorCode_PrivilegeRenewTime.ToString(),
				}
			}
			break
		}
	}
	errdata = &pb.ErrorData{
		Code:  pb.ErrorCode_PrivilegeNotFound,
		Title: pb.ErrorCode_PrivilegeNotFound.ToString(),
	}
	return
}

// 查询特权特权
func (this *Privilege) CheckPrivilege(session comm.IUserSession, cId int32) bool {
	list, err := this.modelPrivilege.getPrivilegeList(session.GetUserId())
	if err != nil {
		return false
	}
	for _, v := range list {
		if v.CId == cId {
			if v.ETime < configure.Now().Unix() { // 判断当前特权是否过期
				return false
			}
			return true
		}
	}
	return false
}

// 检查特权 并发送每日邮件
func (this *Privilege) CheckDailyPrivilegeMail(session comm.IUserSession) {
	vipList, err := this.modelVip.getVipList(session.GetUserId())
	if err != nil {
		return
	}
	list, err := this.modelPrivilege.getPrivilegeList(session.GetUserId())
	if err != nil {
		return
	}
	for _, v := range list {
		conf, err := this.configure.GetPrivilegeCard(v.CId)
		if err != nil {
			return
		}
		if v.ETime < configure.Now().Unix() { // 判断当前特权是否过期

			update := map[string]interface{}{}
			for _, id := range conf.PrivilegeId { // 找到过期的特权 计算过期天数
				data := this.configure.GetPrivilegeData(id)
				if data != nil {

					if v, ok := vipList.Privilege[data.PrivilegeType]; ok {

						for i, v1 := range v.PrivilegeID {
							if v1 == id {
								v.PrivilegeID = append(v.PrivilegeID[:i], v.PrivilegeID[i+1:]...)
								break
							}
						}
					}
				}
			}
			update["privilege"] = vipList.Privilege
			this.modelVip.modifyVipData(session.GetUserId(), update) // 更新数据
		} else {
			// 检查 每日奖励是否发放
			if !utils.IsToday(v.RewardTime) {
				v.RewardTime = configure.Now().Unix()
				if err = this.modelPrivilege.Change(session.GetUserId(), map[string]interface{}{
					"rewardTime": v.RewardTime,
				}); err != nil {
					this.Errorf("err:%v", err)
					return
				}
				// 检查离上次领奖过去几天
				dt := configure.Now().Unix() - utils.GetZeroTime(v.RewardTime)
				count := dt / (24 * 3600)
				this.SendDailyMail(session, v.CId, int32(count+1), conf.PType)

			}
		}
		if !utils.IsToday(v.RewardTime) {
			// 每日奖励
			if v, ok := vipList.Privilege[comm.PrivilegeType1]; ok {
				this.SendDailyPrivilegeMail(session, v.PrivilegeID)
			}
			vipList.RewardTime = configure.Now().Unix()
			if err = this.modelVip.Change(session.GetUserId(), map[string]interface{}{
				"rewardTime": v.RewardTime,
			}); err != nil {
				this.Errorf("err:%v", err)
				return
			}
		}
	}
	return
}

func (this *Privilege) SendDailyMail(session comm.IUserSession, cId int32, count int32, pType int32) {
	conf, err := this.configure.GetPrivilegeCard(cId)
	if err != nil {
		return
	}
	var (
		res []*pb.UserAssets
	)
	for _, v := range conf.DayReward {
		res = append(res, &pb.UserAssets{
			A: v.A,
			T: v.T,
			N: v.N,
		})
	}
	for i := 0; i < int(count); i++ {
		if pType == 1 {
			this.mail.SendMailByCid(session, comm.Yueka_1, res)
		} else if pType == 2 {
			this.mail.SendMailByCid(session, comm.Yueka_2, res)
		}
	}
}

func (this *Privilege) CheckAllPrivilege(session comm.IUserSession) map[int32]*pb.PrivilegeList {
	vip, err := this.modelVip.getVipList(session.GetUserId())
	if err != nil {
		return make(map[int32]*pb.PrivilegeList)
	}
	return vip.Privilege
}

func (this *Privilege) AddVipData(session comm.IUserSession, oldVip, newVip int32) {
	defer this.PutUserSession(session)
	if newVip <= oldVip {
		return
	}
	vip, err := this.modelVip.getVipList(session.GetUserId())
	if err != nil && err == mgo.MongodbNil { // 没有数据 直接创建一条
		vip = &pb.DBVip{
			Id:         primitive.NewObjectID().Hex(),
			Uid:        session.GetUserId(),
			Reward:     map[int32]bool{},
			Privilege:  map[int32]*pb.PrivilegeList{},
			CTime:      configure.Now().Unix(),
			RewardTime: configure.Now().Unix(),
		}
		if err = this.modelVip.createVipData(session.GetUserId(), vip); err != nil {
			this.Errorf("err:%v", err)
			return
		}
	}

	for i := oldVip + 1; i <= newVip; i++ {
		conf := this.configure.GetVipConfigureData(i)
		if conf != nil {
			for _, v := range conf.VipPrivilege {
				data := this.configure.GetPrivilegeData(v)
				if data != nil {
					if _, ok := vip.Privilege[data.PrivilegeType]; ok {
						vip.Privilege[data.PrivilegeType].PrivilegeID = append(vip.Privilege[data.PrivilegeType].PrivilegeID, v)
					} else {
						sz := &pb.PrivilegeList{}
						sz.PrivilegeID = append(sz.PrivilegeID, v)
						vip.Privilege[data.PrivilegeType] = sz
					}
				}
			}
			// 发放每日福利
			var res []*pb.UserAssets
			for _, v := range conf.Daygift {
				res = append(res, &pb.UserAssets{
					A: v.A,
					T: v.T,
					N: v.N,
				})
			}
			this.mail.SendMailByCid(session, comm.VipDaily, res)
		}
	}

	this.modelVip.modifyVipData(session.GetUserId(), map[string]interface{}{
		"privilege": vip.Privilege,
	})

	session.SendMsg(string(this.GetType()), PrivilegeGetListResp, &pb.PrivilegeVipListResp{Data: vip})
	session.Push()
}

// 发送特权每日奖励
func (this *Privilege) SendDailyPrivilegeMail(session comm.IUserSession, cId []int32) {
	var (
		res        []*pb.UserAssets
		totalCount int32 // 获得的钻石累加
	)

	for _, id := range cId {
		conf := this.configure.GetPrivilegeData(id)
		if conf != nil {
			totalCount += conf.PrivilegeParameter
		}
	}
	if totalCount > 0 {
		res = append(res, &pb.UserAssets{
			A: "attr",
			T: "diamond",
			N: totalCount,
		})
		this.mail.SendMailByCid(session, comm.VipDaily, res)
	}
}
func (this *Privilege) GetCountByPrivilegeId(uid string, pType int32) (count int32) {
	if this.IsCross() { // 跨服情况
		if model, err := this.GetDBModelByUid(uid, comm.TableVip); err == nil {
			vip := &pb.DBVip{}
			if err = model.Get(uid, vip); err == nil {
				if v, ok := vip.Privilege[pType]; ok {
					data := this.configure.GetPrivilegeByType(pType)
					for _, v1 := range v.PrivilegeID {
						if c, ok1 := data[v1]; ok1 {
							count += c
						}
					}
				}
			}
		}
	} else {
		if vip, err := this.modelVip.getVipList(uid); err == nil {
			if v, ok := vip.Privilege[pType]; ok {
				data := this.configure.GetPrivilegeByType(pType)
				for _, v1 := range v.PrivilegeID {
					if c, ok1 := data[v1]; ok1 {
						count += c
					}
				}
			}
		}
	}
	return
}