package main

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

	"github.com/joho/godotenv"
	"github.com/juanatsap/cv-site/internal/cache"
	"github.com/juanatsap/cv-site/internal/chat"
	"github.com/juanatsap/cv-site/internal/config"
	c "github.com/juanatsap/cv-site/internal/constants"
	"github.com/juanatsap/cv-site/internal/email"
	"github.com/juanatsap/cv-site/internal/handlers"
	"github.com/juanatsap/cv-site/internal/routes"
	"github.com/juanatsap/cv-site/internal/templates"
)

const version = "1.1.0"

func main() {
	// Initialize logger
	log.SetFlags(log.LstdFlags | log.Lshortfile)
	log.Println("🚀 Starting CV Server v" + version)

	// Load .env file (ignore error if file doesn't exist)
	if err := godotenv.Load(); err != nil {
		log.Println("⚠️  No .env file found, using system environment variables")
	} else {
		log.Println("📂 .env file loaded")
	}

	// Load configuration
	cfg := config.Load()
	log.Printf("⚙️  Configuration loaded (env: %s)", os.Getenv("GO_ENV"))

	// Initialize template manager
	templateMgr, err := templates.NewManager(&cfg.Template)
	if err != nil {
		log.Fatalf("❌ Failed to initialize templates: %v", err)
	}

	// Initialize data cache (load CV and UI data once at startup)
	dataCache, err := cache.New([]string{"en", "es"})
	if err != nil {
		log.Fatalf("❌ Failed to initialize data cache: %v", err)
	}
	log.Println("📦 Data cache initialized (en, es)")

	// Initialize email service
	emailService := email.NewService(&email.Config{
		SMTPHost:     cfg.Email.SMTPHost,
		SMTPPort:     cfg.Email.SMTPPort,
		SMTPUser:     cfg.Email.SMTPUser,
		SMTPPassword: cfg.Email.SMTPPassword,
		FromEmail:    cfg.Email.FromEmail,
		ToEmail:      cfg.Email.ContactEmail,
	})
	log.Printf("📧 Email service configured (SMTP: %s:%s)", cfg.Email.SMTPHost, cfg.Email.SMTPPort)

	// Initialize chat handler (gracefully disabled if no API key)
	chatHandler := chat.NewHandler(dataCache)

	// Initialize handlers
	cvHandler := handlers.NewCVHandler(templateMgr, cfg.Address(), emailService, dataCache, chatHandler.Enabled())
	healthHandler := handlers.NewHealthHandler(version)

	// Setup routes and middleware
	handler := routes.Setup(cvHandler, healthHandler, chatHandler)

	// Create server with timeouts
	server := &http.Server{
		Addr:         ":" + cfg.Server.Port,
		Handler:      handler,
		ReadTimeout:  time.Duration(cfg.Server.ReadTimeout) * time.Second,
		WriteTimeout: time.Duration(cfg.Server.WriteTimeout) * time.Second,
		IdleTimeout:  c.TimeoutIdleConnection,
	}

	// Start server in goroutine
	serverErrors := make(chan error, 1)
	go func() {
		log.Printf("🌐 Server listening on http://%s:%s", cfg.Server.Host, cfg.Server.Port)
		log.Printf("🇬🇧 English: http://%s:%s/?lang=en", cfg.Server.Host, cfg.Server.Port)
		log.Printf("🇪🇸 Spanish: http://%s:%s/?lang=es", cfg.Server.Host, cfg.Server.Port)
		log.Printf("❤️  Health: http://%s:%s/health", cfg.Server.Host, cfg.Server.Port)
		log.Println("⏹️  Press Ctrl+C to shutdown")

		serverErrors <- server.ListenAndServe()
	}()

	// Setup graceful shutdown
	shutdown := make(chan os.Signal, 1)
	signal.Notify(shutdown, os.Interrupt, syscall.SIGTERM)

	// Wait for shutdown signal or server error
	select {
	case err := <-serverErrors:
		if !errors.Is(err, http.ErrServerClosed) {
			log.Fatalf("❌ Server error: %v", err)
		}

	case sig := <-shutdown:
		log.Printf("🛑 Shutdown signal received: %v", sig)

		// Create shutdown context with timeout
		ctx, cancel := context.WithTimeout(context.Background(), c.TimeoutGracefulShutdown)
		defer cancel()

		// Attempt graceful shutdown of HTTP server
		log.Println("🛑 Shutting down HTTP server...")
		if err := server.Shutdown(ctx); err != nil {
			log.Printf("⚠️  Graceful shutdown failed, forcing: %v", err)
			if err := server.Close(); err != nil {
				log.Fatalf("❌ Failed to close server: %v", err)
			}
		}

		log.Println("✓ Server stopped gracefully")
	}
}