package main

import (
	"log"
	"os"
	"os/signal"
	"syscall"

	"github.com/gin-gonic/gin"
	"github.com/ydn/yourdreamnamehere/internal/api"
	"github.com/ydn/yourdreamnamehere/internal/config"
	"github.com/ydn/yourdreamnamehere/internal/database"
	"github.com/ydn/yourdreamnamehere/internal/middleware"
	"github.com/ydn/yourdreamnamehere/internal/services"
	"gorm.io/gorm"
)

func main() {
	// Load configuration
	cfg, err := config.Load()
	if err != nil {
		log.Fatalf("Failed to load configuration: %v", err)
	}

	// Initialize database
	db, err := database.NewDatabase(cfg.DatabaseDSN(), getLogLevel(cfg))
	if err != nil {
		log.Fatalf("Failed to initialize database: %v", err)
	}

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

	// Initialize services
	userService := services.NewUserService(db.DB, cfg)
	stripeService := services.NewStripeService(db.DB, cfg)
	ovhService, err := services.NewOVHService(db.DB, cfg)
	if err != nil {
		log.Fatalf("Failed to initialize OVH service: %v", err)
	}
	cloudronService := services.NewCloudronService(db.DB, cfg)
	dolibarrService := services.NewDolibarrService(db.DB, cfg)
	emailService := services.NewEmailService(cfg)
	deploymentService := services.NewDeploymentService(db.DB, cfg, ovhService, cloudronService, stripeService, dolibarrService, emailService, userService)

	// Initialize API handler
	handler := api.NewHandler(userService, stripeService, ovhService, cloudronService, dolibarrService, deploymentService, emailService)

	// Setup Gin
	if cfg.IsProduction() {
		gin.SetMode(gin.ReleaseMode)
	}

	router := gin.New()
	
	// Add middleware
	router.Use(middleware.RequestID())
	router.Use(middleware.ErrorHandler())
	router.Use(middleware.LoggingMiddleware())
	router.Use(middleware.ErrorMiddleware())
	router.Use(middleware.CORSMiddleware(cfg))
	router.Use(middleware.RateLimitMiddleware(cfg))

	// Register routes
	handler.RegisterRoutes(router)

	// Start server
	go func() {
		log.Printf("Starting server on %s:%s", cfg.App.Host, cfg.App.Port)
		if err := router.Run(cfg.App.Host + ":" + cfg.App.Port); err != nil {
			log.Fatalf("Failed to start server: %v", err)
		}
	}()

	// Graceful shutdown
	quit := make(chan os.Signal, 1)
	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
	<-quit

	log.Println("Shutting down server...")

	// Close database connection
	if err := db.Close(); err != nil {
		log.Printf("Error closing database: %v", err)
	}

	log.Println("Server shutdown complete")
}

func getLogLevel(cfg *config.Config) gorm.LogLevel {
	switch cfg.Logging.Level {
	case "silent":
		return gorm.Silent
	case "error":
		return gorm.Error
	case "warn":
		return gorm.Warn
	case "info":
		return gorm.Info
	default:
		return gorm.Info
	}
}