package server

import (
	"fmt"
	"net"

	grpc_middleware "github.com/grpc-ecosystem/go-grpc-middleware"
	grpc_logrus "github.com/grpc-ecosystem/go-grpc-middleware/logging/logrus"
	grpc_recovery "github.com/grpc-ecosystem/go-grpc-middleware/recovery"
	"github.com/sirupsen/logrus"
	"google.golang.org/grpc"
	"penahub.gitlab.yandexcloud.net/pena-services/accruals-service/internal/core"
	"penahub.gitlab.yandexcloud.net/pena-services/accruals-service/internal/proto/discount"
)

type GRPC struct {
	logger *logrus.Entry
	grpc   *grpc.Server
}

func NewGRPC(logger *logrus.Logger) *GRPC {
	grpcLogger := logrus.NewEntry(logger)

	grpcStreamInterceptor := grpc.StreamInterceptor(grpc_middleware.ChainStreamServer(
		grpc_logrus.StreamServerInterceptor(grpcLogger),
		grpc_recovery.StreamServerInterceptor(),
	))

	grpcUnaryInterceptor := grpc.UnaryInterceptor(grpc_middleware.ChainUnaryServer(
		grpc_logrus.UnaryServerInterceptor(grpcLogger),
		grpc_recovery.UnaryServerInterceptor(),
	))

	return &GRPC{
		grpc:   grpc.NewServer(grpcStreamInterceptor, grpcUnaryInterceptor),
		logger: grpcLogger,
	}
}

func (receiver *GRPC) Run(config *core.GRPCConfiguration) {
	connectionString := fmt.Sprintf("%s:%s", config.Host, config.Port)

	receiver.logger.Infof("Starting GRPC Server on %s", connectionString)

	if err := receiver.listen(connectionString); err != nil && err != grpc.ErrServerStopped {
		receiver.logger.Errorf("GRPC Listen error: %v", err)
		panic(err)
	}
}

func (receiver *GRPC) Register(server discount.DiscountServiceServer) *GRPC {
	discount.RegisterDiscountServiceServer(receiver.grpc, server)

	return receiver
}

func (receiver *GRPC) listen(address string) error {
	listener, err := net.Listen("tcp", address)
	if err != nil {
		return err
	}

	if err := receiver.grpc.Serve(listener); err != nil {
		return err
	}

	return nil
}

func (receiver *GRPC) Stop() {
	receiver.grpc.GracefulStop()
	receiver.logger.Infoln("Shutting down GRPC server...")
}