package main

import (
	"context"
	"log"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"

	"github.com/gorilla/mux"
	"github.com/jobs-scraper/internal/pkg/infrastructure"
	"github.com/jobs-scraper/internal/pkg/infrastructure/rabbitmq"
	"github.com/jobs-scraper/libs/repo"
	"github.com/jobs-scraper/services/api/internal/app"
	httpHandler "github.com/jobs-scraper/services/api/pkg/http"
	_ "github.com/jobs-scraper/services/api/pkg/swagger"
	"github.com/joho/godotenv"
	httpSwagger "github.com/swaggo/http-swagger"
)

// @title Jobs Scraper API
// @version 1.0
// @description API for managing job scraping operations
// @BasePath /
func main() {
	// Try to load .local.env first, then fallback to .env
	if err := godotenv.Load("../../.local.env"); err != nil {
		log.Println("No .local.env file found, trying .env")
		if err := godotenv.Load("../../.env"); err != nil {
			log.Println("No .env file found, using system environment variables")
		}
	}

	dbConfig := infrastructure.LoadConfigFromEnv()

	db, err := infrastructure.NewConnection(dbConfig)
	if err != nil {
		log.Fatal("Error connecting to db")
	}

	err = db.Ping()
	if err != nil {
		log.Fatal("Error pinging db")
	}

	log.Println("Successfully connected to db")

	rmq, err := rabbitmq.NewRabbitMQClient()

	if err != nil {
		log.Fatal("Failed to create RabbitMQ client")
	}

	defer rmq.Close()

	// Run database migrations
	if err := infrastructure.RunMigrations(db); err != nil {
		log.Fatalf("Failed to run migrations: %v", err)
	}

	log.Println("Successfully ran migrations")

	router := mux.NewRouter()

	// Swagger endpoint
	router.PathPrefix("/swagger/").Handler(httpSwagger.WrapHandler)

	router.Use(httpHandler.CORSMiddleware)
	router.Use(httpHandler.LogsMiddleware)

	app := app.NewApplication(router, db, rmq)

	// Create job analysis result repository
	jobAnalysisResultRepo := repo.NewJobAnalysisResultRepository(db)

	jobHandler := httpHandler.NewJobHandler(app.JobCommands, jobAnalysisResultRepo, app.JobQueries)

	jobHandler.RegisterRoutes(router)

	go func() {
		log.Printf("Server running on http %s\n", "8080")
		if err := app.Server.Start(); err != nil && err != http.ErrServerClosed {
			log.Fatalf("Could not listen on http %s: %v\n", "8080", err)
		}
	}()

	stopChan := make(chan os.Signal, 1)
	signal.Notify(
		stopChan,
		os.Interrupt,
		syscall.SIGTERM,
	)

	<-stopChan

	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
	defer cancel()

	app.Server.Stop(ctx)

	log.Println("Server shutting down")
	os.Exit(0)
}
