package main

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

func main() {
	mux := http.NewServeMux()
	mux.HandleFunc("GET /health", func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
	})

	serveur := &http.Server{
		Addr:         ":8080",
		Handler:      mux,
		ReadTimeout:  5 * time.Second,
		WriteTimeout: 10 * time.Second,
		IdleTimeout:  120 * time.Second,
	}

	// Lancer le serveur dans une goroutine pour ne pas bloquer le shutdown
	go func() {
		log.Println("serveur demarre sur :8080")
		if err := serveur.ListenAndServe(); err != nil && err != http.ErrServerClosed {
			log.Fatalf("erreur serveur: %v", err)
		}
	}()

	// Attendre un signal d'arret (Ctrl+C, ou SIGTERM envoye par Docker/Kubernetes)
	arret := make(chan os.Signal, 1)
	signal.Notify(arret, os.Interrupt, syscall.SIGTERM)
	<-arret

	log.Println("signal d'arret recu, fermeture en cours...")

	// Laisser 10s aux requetes en cours pour se terminer proprement
	ctx, annuler := context.WithTimeout(context.Background(), 10*time.Second)
	defer annuler()

	if err := serveur.Shutdown(ctx); err != nil {
		log.Fatalf("fermeture forcee apres timeout: %v", err)
	}
	log.Println("serveur arrete proprement")
}

// Worker pool borne : traiter un grand volume de taches avec un parallelisme controle
package main

import (
	"fmt"
	"sync"
)

type Tache struct {
	ID int
}

type Resultat struct {
	TacheID  int
	Sortie   int
}

func lancerPool(nbWorkers int, taches <-chan Tache, resultats chan<- Resultat) {
	var wg sync.WaitGroup
	for w := 0; w < nbWorkers; w++ {
		wg.Add(1)
		go func(idWorker int) {
			defer wg.Done()
			for t := range taches {
				// traitement simule
				resultats <- Resultat{TacheID: t.ID, Sortie: t.ID * t.ID}
			}
		}(w)
	}
	wg.Wait()
	close(resultats) // fermer une fois TOUS les workers termines
}

func main2() {
	taches := make(chan Tache, 100)
	resultats := make(chan Resultat, 100)

	for i := 1; i <= 20; i++ {
		taches <- Tache{ID: i}
	}
	close(taches) // signale qu'aucune nouvelle tache n'arrivera

	go lancerPool(5, taches, resultats) // 5 workers max en parallele

	for r := range resultats {
		fmt.Println(r)
	}
}

// Rate limiting simple avec time.Ticker
func limiteurDebit() {
	limiteur := time.NewTicker(200 * time.Millisecond)
	defer limiteur.Stop()

	requetes := []int{1, 2, 3, 4, 5}
	for _, r := range requetes {
		<-limiteur.C // attend le prochain "tick" avant de traiter
		fmt.Println("traitement requete", r)
	}
}