package server

import (
	"fmt"
	"log"
	"net"
	"time"

	"datarush/internal/competition/config"
	grpcHandlers "datarush/internal/competition/handler/grpc"
	"datarush/internal/competition/repository/postgres"
	"datarush/internal/competition/service"
	authpb "datarush/pkg/api/auth"
	pb "datarush/pkg/api/competition"
	"datarush/pkg/interceptor"

	"github.com/jmoiron/sqlx"
	_ "github.com/lib/pq"
	"github.com/redis/go-redis/v9"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
	"google.golang.org/grpc/reflection"
)

const (
	httpReadTimeout  = 10 * time.Second
	httpWriteTimeout = 10 * time.Second
	httpIdleTimeout  = 60 * time.Second
)

type Server struct {
	grpcServer  *grpc.Server
	config      *config.Config
	db          *sqlx.DB
	redisClient *redis.Client
	authConn    *grpc.ClientConn
}

func New(cfg *config.Config) *Server {
	return &Server{
		config: cfg,
	}
}

func (s *Server) Start() error {
	db, err := sqlx.Connect("postgres", s.config.BuildPostgresConnStr())
	if err != nil {
		return fmt.Errorf("failed to connect to postgres: %w", err)
	}
	s.db = db

	s.redisClient = redis.NewClient(&redis.Options{
		Addr:     s.config.RedisAddr,
		Password: s.config.RedisPassword,
		DB:       s.config.RedisDB,
	})

	authConn, err := grpc.Dial(s.config.AuthSvcAddr, grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		return fmt.Errorf("failed to connect to auth service: %w", err)
	}
	s.authConn = authConn

	if err := s.registerGRPCServices(); err != nil {
		return fmt.Errorf("failed to register gRPC services: %w", err)
	}

	go func() {
		lis, err := net.Listen("tcp", fmt.Sprintf(":%d", s.config.GRPCPort))
		if err != nil {
			log.Fatalf("failed to listen on grpc port: %v", err)
		}

		log.Printf("starting gRPC server on port %d", s.config.GRPCPort)
		if err := s.grpcServer.Serve(lis); err != nil {
			log.Fatalf("failed to serve gRPC: %v", err)
		}
	}()

	return nil
}

func (s *Server) registerGRPCServices() error {
	authClient := authpb.NewAuthServiceClient(s.authConn)
	authInterceptor := interceptor.NewAuthInterceptor(authClient)

	s.grpcServer = grpc.NewServer(
		grpc.UnaryInterceptor(authInterceptor.Unary()),
	)

	compRepo := postgres.NewCompetitionRepository(s.db, s.redisClient, s.config.CacheEnabled)
	compService := service.NewCompetitionService(compRepo)
	compHandler := grpcHandlers.NewCompetitionHandler(compService)

	pb.RegisterCompetitionServiceServer(s.grpcServer, compHandler)

	if s.config.GRPCEnableReflection {
		reflection.Register(s.grpcServer)
	}

	return nil
}

func (s *Server) Stop() {
	log.Println("shutting down competition server...")

	if s.grpcServer != nil {
		s.grpcServer.GracefulStop()
	}

	if s.authConn != nil {
		if err := s.authConn.Close(); err != nil {
			log.Printf("failed to close auth service connection: %v", err)
		}
	}

	if s.db != nil {
		if err := s.db.Close(); err != nil {
			log.Printf("failed to close database: %v", err)
		}
	}

	if s.redisClient != nil {
		if err := s.redisClient.Close(); err != nil {
			log.Printf("failed to close redis client: %v", err)
		}
	}

	log.Println("competition server stopped")
}