package server

import (
	"context"
	"fmt"
	"log"
	"net"
	"net/http"
	"time"

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

	"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
	"github.com/jmoiron/sqlx"
	_ "github.com/lib/pq"
	"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
	httpServer *http.Server
	config     *config.Config
	db         *sqlx.DB
}

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

	go func() {
		if err := s.startGRPCServer(); err != nil {
			log.Fatalf("failed to start gRPC server: %v", err)
		}
	}()

	go func() {
		if err := s.startHTTPServer(); err != nil {
			log.Fatalf("failed to start HTTP server: %v", err)
		}
	}()

	log.Println("competition service started")
	return nil
}

func (s *Server) startGRPCServer() error {
	lis, err := net.Listen("tcp", fmt.Sprintf(":%d", s.config.GRPCPort))
	if err != nil {
		return fmt.Errorf("failed to listen on grpc port: %w", err)
	}

	s.grpcServer = grpc.NewServer()
	s.registerGRPCServices()

	log.Printf("starting gRPC server on port %d", s.config.GRPCPort)
	return s.grpcServer.Serve(lis)
}

func (s *Server) registerGRPCServices() {
	compRepo := postgres.NewCompetitionRepository(s.db.DB, nil, false)
	compService := service.NewService(compRepo)
	compHandler := grpcHandlers.NewCompetitionHandler(compService)

	pb.RegisterCompetitionServiceServer(s.grpcServer, compHandler)

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

func (s *Server) startHTTPServer() error {
	ctx := context.Background()
	ctx, cancel := context.WithCancel(ctx)
	defer cancel()

	mux := runtime.NewServeMux()
	opts := []grpc.DialOption{grpc.WithTransportCredentials(insecure.NewCredentials())}
	grpcEndpoint := fmt.Sprintf("localhost:%d", s.config.GRPCPort)

	err := pb.RegisterCompetitionServiceHandlerFromEndpoint(ctx, mux, grpcEndpoint, opts)
	if err != nil {
		return fmt.Errorf("failed to register http handlers: %w", err)
	}

	s.httpServer = &http.Server{
		Addr:         fmt.Sprintf(":%d", s.config.HTTPPort),
		Handler:      mux,
		ReadTimeout:  httpReadTimeout,
		WriteTimeout: httpWriteTimeout,
		IdleTimeout:  httpIdleTimeout,
	}

	log.Printf("starting HTTP server on port %d", s.config.HTTPPort)
	return s.httpServer.ListenAndServe()
}

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

	// Shutdown HTTP server
	if s.httpServer != nil {
		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
		defer cancel()
		if err := s.httpServer.Shutdown(ctx); err != nil {
			log.Printf("failed to shutdown HTTP server gracefully: %v", err)
		}
	}

	// Shutdown gRPC server
	if s.grpcServer != nil {
		s.grpcServer.GracefulStop()
	}

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

	log.Println("competition server stopped")
}