package main

import (
	"encoding/json"
	"log"
	"net/http"
	"strconv"
	"sync"
)

type Tache struct {
	ID     int    `json:"id"`
	Titre  string `json:"titre"`
	Faite  bool   `json:"faite"`
}

type Stockage struct {
	mu     sync.RWMutex
	taches map[int]Tache
	nextID int
}

func nouveauStockage() *Stockage {
	return &Stockage{taches: make(map[int]Tache), nextID: 1}
}

func (s *Stockage) Lister() []Tache {
	s.mu.RLock()
	defer s.mu.RUnlock()
	resultat := make([]Tache, 0, len(s.taches))
	for _, t := range s.taches {
		resultat = append(resultat, t)
	}
	return resultat
}

func (s *Stockage) Creer(titre string) Tache {
	s.mu.Lock()
	defer s.mu.Unlock()
	t := Tache{ID: s.nextID, Titre: titre}
	s.taches[t.ID] = t
	s.nextID++
	return t
}

func repondreJSON(w http.ResponseWriter, statut int, donnees any) {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(statut)
	json.NewEncoder(w).Encode(donnees)
}

func repondreErreur(w http.ResponseWriter, statut int, message string) {
	repondreJSON(w, statut, map[string]string{"erreur": message})
}

// Handler via mux avec ServeMux (routage natif depuis Go 1.22, avec methodes/params)
func creerRoutes(s *Stockage) *http.ServeMux {
	mux := http.NewServeMux()

	mux.HandleFunc("GET /taches", func(w http.ResponseWriter, r *http.Request) {
		repondreJSON(w, http.StatusOK, s.Lister())
	})

	mux.HandleFunc("POST /taches", func(w http.ResponseWriter, r *http.Request) {
		var payload struct {
			Titre string `json:"titre"`
		}
		if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {
			repondreErreur(w, http.StatusBadRequest, "corps JSON invalide")
			return
		}
		if payload.Titre == "" {
			repondreErreur(w, http.StatusUnprocessableEntity, "titre requis")
			return
		}
		t := s.Creer(payload.Titre)
		repondreJSON(w, http.StatusCreated, t)
	})

	mux.HandleFunc("GET /taches/{id}", func(w http.ResponseWriter, r *http.Request) {
		id, err := strconv.Atoi(r.PathValue("id"))
		if err != nil {
			repondreErreur(w, http.StatusBadRequest, "id invalide")
			return
		}
		s.mu.RLock()
		t, ok := s.taches[id]
		s.mu.RUnlock()
		if !ok {
			repondreErreur(w, http.StatusNotFound, "tache non trouvee")
			return
		}
		repondreJSON(w, http.StatusOK, t)
	})

	return mux
}

// Middleware : fonction qui enveloppe un handler pour ajouter un comportement
func middlewareLog(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		log.Printf("%s %s", r.Method, r.URL.Path)
		next.ServeHTTP(w, r)
	})
}

func main() {
	stockage := nouveauStockage()
	mux := creerRoutes(stockage)

	handler := middlewareLog(mux)

	log.Println("serveur demarre sur :8080")
	log.Fatal(http.ListenAndServe(":8080", handler))
}