package handler

import (
	"encoding/json"
	"fmt"
	"github.com/rabbitmq/amqp091-go"
	"math/rand"
	"samba/pkg/log"
	"samba/pkg/rmq"
	"samba/pkg/servername"
	"samba/pkg/service"
	"samba/util/config"
	"samba/util/util"
)

var gDBServices dbServices

type dbServices struct {
	services []service.IService
}

func (d *dbServices) Get(uid int64) service.IService {
	if uid < 0 {
		i := rand.Int() % len(d.services)
		return d.services[i]
	}
	return d.services[uid%int64(len(d.services))]
}

func (d *dbServices) QueueName(childId int) string {
	return fmt.Sprintf("%v-%v", servername.Money, childId)
}

func hallHandlerMessage(_ service.IService, d *amqp091.Delivery) {
	var msg map[string]interface{}
	if err := json.Unmarshal(d.Body, &msg); err != nil {
		log.Error(fmt.Sprintf("consume message error: %v.body:%v", err, string(d.Body)))
		return
	}
	log.Debug(string(d.Body))
	if fn, ok := MsgHandler[msg["a"].(string)]; ok {
		fn(d, msg)
	} else {
		log.Error(fmt.Sprintf("msgId:%v not exist", msg["a"]))
	}
}

func InitService() {
	for j := 0; j < config.Cmd.ChildNum; j++ {
		i := j
		opts := []service.Option{
			service.SetOnInit(func(s service.IService) bool {
				if err := s.ExchangeDeclare(util.Direct(servername.Money), rmq.ExchangeDirect); err != nil {
					log.Error(err.Error())
					return false
				}
				if err := s.ExchangeDeclare(util.Topic(servername.Money), rmq.ExchangeTopic); err != nil {
					log.Error(err.Error())
					return false
				}
				if err := s.QueueDeclare(gDBServices.QueueName(i)); err != nil {
					log.Error(err.Error())
					return false
				}

				if !RegisterMsgHandler(s, i) {
					return false
				}
				if err := s.Consume(gDBServices.QueueName(i)); err != nil {
					log.Error(err.Error())
					return false
				}
				log.Info(fmt.Sprintf("service:%v init", s.Name()))
				return true
			}),
			service.SetOnNotifyStop(func(s service.IService) {

			}),
			service.SetCanStop(func(s service.IService) bool {
				return true
			}),
			service.SetOnStop(func(s service.IService) {
				if err := s.ConsumeDelete(); err != nil {
					log.Error(err.Error())
				} else {
					log.Info(fmt.Sprintf("delete consume channle"))
				}
				if err := s.QueueDelete(gDBServices.QueueName(i)); err != nil {
					log.Error(err.Error())
				} else {
					log.Info(fmt.Sprintf("delete queue:%v", gDBServices.QueueName(i)))
				}
				log.Info(fmt.Sprintf("service:%v stop", s.Name()))
			}),
		}
		s := service.NewService(servername.Money, gDBServices.QueueName(i), config.RabbitmqUrl(), hallHandlerMessage, opts...)
		gDBServices.services = append(gDBServices.services, s)
		//heartbeat(s, i)
	}

}

//func heartbeat(s service.IService, i int) {
//	log.Debug(fmt.Sprintf("service:%v send heartbeat", gDBServices.QueueName(i)))
//	_ = SendMsg(util.Direct(servername.Money), routingKey.DbKey(int64(i)), "", 0, proto.ReqHeartbeatId, nil)
//	s.NewTimer(5*time.Minute, func() { heartbeat(s, i) })
//}

func StopService() {
	for _, s := range gDBServices.services {
		s.NotifyStop()
	}
	for _, s := range gDBServices.services {
		s.WaitStop()
	}
}