package main

import (
	"context"
	"os"

	"github.com/jackc/pgx/v5/pgxpool"
	_ "github.com/jackc/pgx/v5/stdlib"
	rkboot "github.com/rookie-ninja/rk-boot/v2"
	rkentry "github.com/rookie-ninja/rk-entry/v2/entry"
	rkgrpc "github.com/rookie-ninja/rk-grpc/v2/boot"
	"go.uber.org/zap"
	"google.golang.org/grpc"

	"git.techease.ru/Smart-search/smart-search-back/internal/config"
	"git.techease.ru/Smart-search/smart-search-back/internal/database"
	grpcServer "git.techease.ru/Smart-search/smart-search-back/internal/grpc"
	"git.techease.ru/Smart-search/smart-search-back/internal/repository"
	"git.techease.ru/Smart-search/smart-search-back/internal/worker"
)

func main() {
	boot := rkboot.NewBoot(rkboot.WithBootConfigPath("config/boot.yaml", nil))

	loggerEntry := rkentry.GlobalAppCtx.GetLoggerEntry("smart-search-logger")
	if loggerEntry == nil {
		loggerEntry = rkentry.GlobalAppCtx.GetLoggerEntryDefault()
	}
	logger := loggerEntry.Logger

	cfg, err := config.Load("config/config.yaml")
	if err != nil {
		logger.Fatal("Failed to load config", zap.Error(err))
	}

	ctx := context.Background()

	if err := database.RunMigrations(cfg.DatabaseURL(), logger); err != nil {
		logger.Fatal("Failed to run migrations", zap.Error(err))
	}

	pool, err := pgxpool.New(ctx, cfg.DatabaseURL())
	if err != nil {
		logger.Fatal("Failed to connect to database", zap.Error(err))
	}
	defer pool.Close()

	if err := pool.Ping(ctx); err != nil {
		logger.Fatal("Failed to ping database", zap.Error(err))
	}

	logger.Info("Successfully connected to database")

	grpcEntry := rkgrpc.GetGrpcEntry("smart-search-service")
	if grpcEntry == nil {
		logger.Fatal("Failed to get gRPC entry from rk-boot")
		os.Exit(1)
	}

	sessionRepo := repository.NewSessionRepository(pool)
	inviteRepo := repository.NewInviteRepository(pool)

	sessionCleaner := worker.NewSessionCleaner(ctx, sessionRepo, logger)
	sessionCleaner.Start()
	defer sessionCleaner.Stop()

	inviteCleaner := worker.NewInviteCleaner(ctx, inviteRepo, logger)
	inviteCleaner.Start()
	defer inviteCleaner.Stop()

	authHandler, userHandler, inviteHandler, requestHandler, supplierHandler := grpcServer.NewHandlers(
		pool,
		cfg.Security.JWTSecret,
		cfg.Security.CryptoSecret,
		cfg.AI.OpenAIKey,
		cfg.AI.PerplexityKey,
		logger,
	)

	grpcEntry.AddRegFuncGrpc(func(s *grpc.Server) {
		grpcServer.RegisterServices(s, authHandler, userHandler, inviteHandler, requestHandler, supplierHandler)
	})

	boot.Bootstrap(ctx)

	logger.Info("gRPC server started via rk-boot")

	boot.WaitForShutdownSig(ctx)

	logger.Info("Server stopped gracefully")
}