projet_gestion_commande/backend/gestion/main.go

// ============================================
// main.go - VERSION SIMPLIFIÉE AVEC CLEANUP AUTO
// ============================================

package main

import (
	"gestion/db"
	"gestion/routes"
	"gestion/services"
	"gestion/workers"
	"log"
	"net/http"
	"os"
	"time"

	"github.com/gin-contrib/cors"
	"github.com/gin-contrib/sessions"
	"github.com/gin-contrib/sessions/cookie"
	"github.com/gin-gonic/gin"
	"github.com/joho/godotenv"
)

func main() {
	if loc, err := time.LoadLocation("Europe/Paris"); err == nil {
		time.Local = loc
	} else {
		log.Printf("⚠️ Impossible de charger la timezone Europe/Paris: %v", err)
	}

	if err := godotenv.Load(); err != nil {
		log.Println("⚠️ Aucun fichier .env trouvé, utilisation des valeurs par défaut.")
	}

	database := db.InitDB()
	defer database.Close()
	log.Printf("✅ Database initialisée: %+v", database)
	db.InitRedis()
	defer db.Redis.Close()
	log.Println("✅ Redis initialisé avec succès")

	geoService := services.NewGeoService(db.Redis, db.RedisCtx)
	log.Println("✅ Service de géolocalisation initialisé")

	telegramService := services.NewTelegramService()
	if telegramService.IsConfigured() {
		log.Println("✅ Service Telegram initialisé")
		if webhookURL := os.Getenv("TELEGRAM_WEBHOOK_URL"); webhookURL != "" {
			if err := telegramService.SetWebhook(webhookURL); err != nil {
				log.Printf("⚠️ [TELEGRAM] Erreur enregistrement webhook: %v", err)
			}
		}
	} else {
		log.Println("ℹ️ Service Telegram désactivé (TELEGRAM_BOT_TOKEN non défini)")
	}

	database.MigrateAddTelegramColumns()

	if dbSettings, err := database.GetSettings(); err == nil {
		telegramService.Reload(dbSettings.TelegramBotToken, dbSettings.TelegramBotUsername)
		if dbSettings.TelegramBotToken != "" {
			log.Printf("✅ [TELEGRAM] Config chargée depuis la DB (username: %s)", dbSettings.TelegramBotUsername)
			if webhookURL := os.Getenv("TELEGRAM_WEBHOOK_URL"); webhookURL != "" {
				if err := telegramService.SetWebhook(webhookURL); err != nil {
					log.Printf("⚠️ [TELEGRAM] Erreur enregistrement webhook (DB reload): %v", err)
				}
			}
		}
	}

	log.Println("")
	log.Println("🧹 Démarrage du nettoyage des commandes invalides...")
	removed, err := database.CleanupInvalidQueueCommands()
	if err != nil {
		log.Printf("❌ Erreur lors du nettoyage initial: %v", err)
	} else {
		if removed > 0 {
			log.Printf("✅ Nettoyage initial terminé: %d commandes invalides supprimées", removed)
		} else {
			log.Println("✅ Nettoyage initial: Aucune commande invalide trouvée")
		}
	}

	go database.StartQueueCleanupScheduler()
	log.Println("✅ Scheduler de nettoyage démarré (toutes les 5 min)")

	if err := database.SyncAllDeliverymanStatuses(); err != nil {
		log.Printf("⚠️ Erreur synchronisation statuts: %v", err)
	} else {
		log.Println("✅ Synchronisation des statuts livreurs terminée")
	}

	go workers.StartAutoAssignmentCron(database, geoService)
	log.Println("✅ Cron job auto-assignation démarré (5 min)")

	go workers.StartRedisWorkers(database)
	log.Println("✅ Workers Redis démarrés")

	workers.StartDynamicPaymentChecker(database, func() *services.NowPaymentsClient {
		s, err := database.GetSettings()
		if err != nil || !s.CryptoPaymentEnabled || s.NowPaymentsAPIKey == "" {
			return nil
		}
		return services.NewNowPaymentsClient(s.NowPaymentsAPIKey, s.NowPaymentsIPNSecret)
	}, 2*time.Minute)
	log.Println("✅ Worker paiements crypto démarré (2 min)")
	gin.SetMode(gin.ReleaseMode)
	r := gin.Default()

	store := cookie.NewStore([]byte(os.Getenv("SESSION_SECRET")))
	store.Options(sessions.Options{
		Path:     "/",
		Domain:   "",
		MaxAge:   3600,
		HttpOnly: true,
		Secure:   true,
		SameSite: http.SameSiteStrictMode,
	})
	r.Use(sessions.Sessions("mysession", store))

	r.Use(cors.New(cors.Config{
		AllowOrigins:     []string{"https://uber-stup.club", "https://5.181.0.112.nip.io", "https://5.181.0.112.nip.io:8080", "https://5.181.0.112.nip.io:8443", "https://mln-uber.club", "http://localhost:5173", "http://5.181.0.112"},
		AllowMethods:     []string{"GET", "POST", "PUT", "DELETE", "OPTIONS", "PATCH"},
		AllowHeaders:     []string{"Origin", "Content-Type", "Accept", "Authorization", "X-Request-ID"},
		ExposeHeaders:    []string{"Content-Length"},
		AllowCredentials: true,
	}))

	r.Use(func(c *gin.Context) {
		c.Set("database", database)
		c.Set("geoService", geoService)
		c.Next()
	})

	r.Use(func(c *gin.Context) {
		settings, err := database.GetSettings()
		if err == nil && settings.CryptoPaymentEnabled && settings.NowPaymentsAPIKey != "" {
			np := services.NewNowPaymentsClient(settings.NowPaymentsAPIKey, settings.NowPaymentsIPNSecret)
			c.Set("nowpayments", np)
		}
		c.Next()
	})

	r.Static("/uploads", "./uploads")

	routes.SetupRoutes(r, database, geoService)

	if err := r.Run(":8080"); err != nil {
		log.Fatalf("❌ Erreur au lancement du serveur : %v", err)
	}
}