package handler

import (
	"encoding/json"
	"errors"
	"fmt"
	"github.com/rabbitmq/amqp091-go"
	"samba/pkg/log"
	"samba/pkg/servername"
	"samba/proto"
	"samba/util/model"
	"samba/util/routingKey"
	"samba/util/util"
)

func ntfUpdateResource(uid int64, clubId, resType int, num, amount int64) {
	d := make(map[string]interface{})
	d["a"] = proto.NtfUpdateResourceId
	xd := make(map[string]interface{})
	xd["u"] = fmt.Sprintf("%v", uid)
	xd["d"] = &proto.NtfUpdateResource{
		ClubId: clubId,
		Type:   fmt.Sprintf("%v", resType),
		Num:    num,
		Amount: amount,
	}
	d["d"] = xd

	p := make(map[string]interface{})
	p["u"] = fmt.Sprintf("%v", uid)
	p["d"] = d

	data := make(map[string]interface{})
	data["a"] = "user_transfer"
	data["p"] = p

	byteData, err := json.Marshal(data)
	if err != nil {
		log.Error(err.Error())
		return
	}
	log.Debug(fmt.Sprintf("send msg:%v to exchange:%v, routKey:%v, data:%v", proto.NtfUpdateResourceId, util.Direct(servername.User),
		routingKey.GateKey(uid), string(byteData)))
	if err = gDBServices.Get(uid).Publish(util.Direct(servername.User), routingKey.GateKey(uid), byteData); err != nil {
		log.Error(err.Error())
	}
}

func ntfBatchUpdateResource(uid int64, ntfs *proto.NtfBatchUpdateResource) {
	if len(ntfs.Data) <= 0 {
		return
	}
	d := make(map[string]interface{})
	d["a"] = proto.NtfUpdateResourceId
	xd := make(map[string]interface{})
	xd["u"] = fmt.Sprintf("%v", uid)
	xd["d"] = ntfs
	d["d"] = xd

	p := make(map[string]interface{})
	p["u"] = fmt.Sprintf("%v", uid)
	p["d"] = d

	data := make(map[string]interface{})
	data["a"] = "user_transfer"
	data["p"] = p

	byteData, err := json.Marshal(data)
	if err != nil {
		log.Error(err.Error())
		return
	}
	log.Debug(fmt.Sprintf("send msg:%v to exchange:%v, routKey:%v, data:%v", proto.NtfUpdateResourceId, util.Direct(servername.User),
		routingKey.GateKey(uid), string(byteData)))
	if err = gDBServices.Get(uid).Publish(util.Direct(servername.User), routingKey.GateKey(uid), byteData); err != nil {
		log.Error(err.Error())
	}
}

func addResource(uid int64, clubId int, req *proto.ReqAddResource) proto.RspAddResource {
	if req.ResValue == 0 {
		return proto.RspAddResource{Code: proto.BadParam, Msg: proto.BadParam.Error().Error()}
	}
	var value int64
	var err error
	switch req.ResType {
	case model.ResCoins, model.ResDiamond, model.ResTakeCoins, model.ResClubCoins:
		resOp := model.NewUserResourceOp()
		value, err = resOp.Add(clubId, uid, req.ResValue, req.ResType)
	case model.ResClubScore, model.ResClubUserFreeScore, model.ResClubUserInOutFreeScore:
		resOp := model.NewUserClubInfoOp()
		_, value, err = resOp.Add(uid, clubId, req.ResValue, req.ResType)
	}
	if err != nil {
		return proto.RspAddResource{Code: proto.Fail, ResType: req.ResType, Msg: err.Error()}
	}
	resType, _ := model.ResToInt(req.ResType)
	switch req.ResType {
	case model.ResClubScore, model.ResClubUserFreeScore, model.ResClubUserInOutFreeScore:
		if info, err := model.NewUserClubInfoOp().Load(req.UserId, req.ClubId); err == nil {
			value = info.Score + info.FreeScore + info.InOutFreeScore
		}
		resType, _ = model.ResToInt(model.ResClubScore)
	default:
	}
	if req.IsNotify {
		ntfUpdateResource(req.UserId, req.ClubId, resType, req.ResValue, value)
	}
	srv := gDBServices.Get(uid)
	model.NewResourceRecord(req, value).Flush(srv)
	return proto.RspAddResource{Code: proto.Ok, ResType: req.ResType, ResValue: value}
}

func onAddResource(d *amqp091.Delivery, msg map[string]interface{}) {
	req, err := util.MapToStructT[proto.ReqAddResource](msg["p"])
	if err != nil {
		log.Error(err.Error())
		return
	}

	response := make(map[string]interface{})
	rsp := addResource(req.UserId, req.ClubId, req)
	response["p"] = rsp
	if rsp.Code == proto.Ok && req.IsNotify {
		resType, _ := model.ResToInt(req.ResType)
		ntfUpdateResource(req.UserId, req.ClubId, resType, req.ResValue, rsp.ResValue)
	}
	if data, err := json.Marshal(response); err == nil {
		_ = gDBServices.Get(req.UserId).PublishRpc(d, data)
	}
	return
}

func onBatchAddResource(d *amqp091.Delivery, msg map[string]interface{}) {
	req, err := util.MapToStructT[proto.ReqBatchAddResource](msg["p"])
	if err != nil {
		log.Error(err.Error())
		return
	}
	uid, clubId := req.UserId, req.ClubId
	response := make(map[string]interface{})
	rsps := make([]proto.RspAddResource, 0, len(req.ReqResources))
	ntfs := make([]proto.NtfUpdateResource, 0, len(req.ReqResources))
	for _, r := range req.ReqResources {
		rsp := addResource(uid, clubId, &r)
		rsps = append(rsps, rsp)
		if rsp.Code != proto.Ok {
			continue
		}
		resType, _ := model.ResToInt(r.ResType)
		ntfs = append(ntfs, proto.NtfUpdateResource{
			ClubId: clubId,
			Type:   fmt.Sprintf("%d", resType),
			Num:    r.ResValue,
			Amount: rsp.ResValue,
		})
	}
	if req.IsNotify {
		ntfBatchUpdateResource(uid, &proto.NtfBatchUpdateResource{
			Type:   305,
			Data:   ntfs,
			ClubId: clubId,
			Reason: 306,
		})
	}

	response["p"] = proto.RspBatchAddResource{RspResources: rsps}
	if data, err := json.Marshal(response); err == nil {
		_ = gDBServices.Get(req.UserId).PublishRpc(d, data)
	}

}

func onLoadResource(d *amqp091.Delivery, msg map[string]interface{}) {
	req, err := util.MapToStructT[proto.ReqGetResource](msg["p"])
	if err != nil {
		log.Error(err.Error())
		return
	}
	response := make(map[string]interface{})
	response["r"] = "0"

	var value int64
	switch req.ResType {
	case model.ResCoins, model.ResDiamond, model.ResTakeCoins, model.ResClubCoins:
		resOp := model.NewUserResourceOp()
		value, err = resOp.Get(req.UserId, req.ResType)
	case model.ResClubScore, model.ResClubUserFreeScore, model.ResClubUserInOutFreeScore:
		resOp := model.NewUserClubInfoOp()
		value, err = resOp.Get(req.UserId, req.ClubId, req.ResType)
	}
	if err == nil {
		response["p"] = proto.RspGetResource{Code: proto.Ok, ResType: req.ResType, ResValue: value}
	} else {
		response["p"] = proto.RspGetResource{Code: proto.Fail, ResType: req.ResType, Msg: err.Error()}
	}

	if data, err := json.Marshal(response); err == nil {
		_ = gDBServices.Get(req.UserId).PublishRpc(d, data)
	}
}

func ntfUpdateClubResource(uid int64, clubId, resType int, num, amount int64) {
	d := make(map[string]interface{})
	d["a"] = proto.NtfUpdateClubResourceId
	xd := make(map[string]interface{})
	xd["u"] = fmt.Sprintf("%v", uid)
	xd["d"] = &proto.NtfUpdateClubResource{
		ClubId: clubId,
		Type:   fmt.Sprintf("%v", resType),
		Num:    num,
		Amount: amount,
	}
	d["d"] = xd

	p := make(map[string]interface{})
	p["u"] = fmt.Sprintf("%v", uid)
	p["d"] = d

	data := make(map[string]interface{})
	data["a"] = "user_transfer"
	data["p"] = p

	byteData, err := json.Marshal(data)
	if err != nil {
		log.Error(err.Error())
		return
	}
	log.Debug(fmt.Sprintf("send msg:%v to exchange:%v, routKey:%v, data:%v", proto.NtfUpdateClubResourceId, util.Direct(servername.User),
		routingKey.GateKey(uid), string(byteData)))
	if err = gDBServices.Get(uid).Publish(util.Direct(servername.User), routingKey.GateKey(uid), byteData); err != nil {
		log.Error(err.Error())
	}
}

// 添加俱乐部资源，目前只有俱乐部本身的积分
func onAddClubResource(d *amqp091.Delivery, msg map[string]interface{}) {
	req, err := util.MapToStructT[proto.ReqAddClubResource](msg["p"])
	if err != nil {
		log.Error(err.Error())
		return
	}

	response := make(map[string]interface{})
	if req.ResValue == 0 {
		response["p"] = proto.RspAddClubResource{Code: proto.BadParam, Msg: proto.BadParam.Error().Error()}
	} else {
		resOp := model.NewClubResourceOp()

		var value int64
		if value, err = resOp.Add(req.ClubId, req.ResValue, req.ResType); err == nil {
			srv := gDBServices.Get(req.UserId)
			model.NewClubResourceRecord(req, value).Flush(srv)
			response["p"] = proto.RspAddClubResource{Code: proto.Ok, ResType: req.ResType, ResValue: value, ClubId: req.ClubId}
			resType, _ := model.ClubResToInt(req.ResType)
			if req.GameNo != "" {
				ntfUpdateClubResource(req.UserId, req.ClubId, resType, req.ResValue, value)
			}

		} else {
			response["p"] = proto.RspAddClubResource{Code: proto.Fail, ResType: req.ResType, Msg: err.Error()}
		}
	}

	if data, err := json.Marshal(response); err == nil {
		_ = gDBServices.Get(req.UserId).PublishRpc(d, data)
	}
	return
}

func onLoadClubResource(d *amqp091.Delivery, msg map[string]interface{}) {
	req, err := util.MapToStructT[proto.ReqGetClubResource](msg["p"])
	if err != nil {
		log.Error(err.Error())
		return
	}
	response := make(map[string]interface{})
	response["r"] = "0"

	resOp := model.NewClubResourceOp()
	if coins, err := resOp.Get(req.ResType, req.ClubId); err == nil {
		response["p"] = proto.RspGetClubResource{Code: proto.Ok, ResType: req.ResType, ResValue: coins, ClubId: req.ClubId}
	} else {
		response["p"] = proto.RspGetClubResource{Code: proto.Fail, ResType: req.ResType, Msg: err.Error(), ClubId: req.ClubId}
	}

	if data, err := json.Marshal(response); err == nil {
		_ = gDBServices.Get(req.UserId).PublishRpc(d, data)
	}
}

// 获取玩家身上所有资源
func onGetUserAllResource(d *amqp091.Delivery, msg map[string]interface{}) {
	req, err := util.MapToStructT[proto.ReqGetAllResource](msg["p"])
	if err != nil {
		log.Error(err.Error())
		return
	}
	response := make(map[string]interface{})
	response["r"] = "0"

	res := model.NewUserResourceOp().Load(req.UserId)
	var resMap map[string]interface{}
	if res == nil {
		err = errors.New(fmt.Sprintf("user:%v is not exist", req.UserId))
	} else {
		resMap, err = util.StructToMap(res)
	}
	if err == nil {
		response["p"] = proto.RspGetAllResource{Code: proto.Ok, UserId: req.UserId, Res: resMap}
	} else {
		response["p"] = proto.RspGetAllResource{Code: proto.Fail, Msg: err.Error()}
	}

	if data, err := json.Marshal(response); err == nil {
		_ = gDBServices.Get(req.UserId).PublishRpc(d, data)
	}
}

// 获取玩家身上所有资源
func onGetUserClubAllResource(d *amqp091.Delivery, msg map[string]interface{}) {
	req, err := util.MapToStructT[proto.ReqGetUserClubAllResource](msg["p"])
	if err != nil {
		log.Error(err.Error())
		return
	}
	response := make(map[string]interface{})
	response["r"] = "0"

	res, err := model.NewUserClubInfoOp().Load(req.UserId, req.ClubId)
	var resMap map[string]interface{}
	if err == nil {
		resMap, err = util.StructToMap(res)
	}

	if err == nil {
		response["p"] = proto.RspGetUserClubAllResource{Code: proto.Ok, UserId: req.UserId, ClubId: req.ClubId, Res: resMap}
	} else {
		response["p"] = proto.RspGetUserClubAllResource{Code: proto.Fail, Msg: err.Error()}
	}

	if data, err := json.Marshal(response); err == nil {
		_ = gDBServices.Get(req.UserId).PublishRpc(d, data)
	}
}