package handlers

import (
	"backend/models"
	"backend/repositories"
	"encoding/json"
	"log"
	"net/http"

	"github.com/gorilla/mux"
)

type NodeHandler struct {
	Repo *repositories.NodeRepository // On stocke le repo ici
}

var registeredNodes = make(map[string]models.NodeInfo)

func (h *NodeHandler) HandleRegisterNode(w http.ResponseWriter, r *http.Request) {
	if r.Method != "POST" {
		http.Error(w, "POST requested", http.StatusMethodNotAllowed)
		return
	}

	var node models.NodeInfo
	err := json.NewDecoder(r.Body).Decode(&node)
	if err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	var nodeID int
	nodeID, err = h.Repo.RegisterNode(node)

	if err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusOK)
	json.NewEncoder(w).Encode(map[string]int{"id": nodeID})
}

func (h *NodeHandler) HandleRetrieveNodeList(w http.ResponseWriter, r *http.Request) {
	if r.Method != "GET" {
		http.Error(w, "GET requested", http.StatusMethodNotAllowed)
		return
	}

	log.Printf("All node retrieved")

	var registeredNodes = make(map[string]models.FullNodeInfo)
	var err error

	registeredNodes, err = h.Repo.RetriveNodeList()

	log.Printf("nb nodes: %v", len(registeredNodes))

	if err != nil {
		log.Fatalf("Request error on retrieving all node: %v", err)
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	w.Header().Set("Content-Type", "application/json")

	err = json.NewEncoder(w).Encode(registeredNodes)
	if err != nil {
		log.Fatalf("Erreur lors de l'encodage JSON: %v", err)
		http.Error(w, "Erreur lors de l'encodage JSON", http.StatusInternalServerError)
		return
	}
}

/*func (h *NodeHandler) HandleUpdateNode(w http.ResponseWriter, r *http.Request) {
	if r.Method != "POST" {
		http.Error(w, "POST requested", http.StatusMethodNotAllowed)
		return
	}

	var nodeUpdate models.NodeUpdate

	err := json.NewDecoder(r.Body).Decode(&nodeUpdate)
	if err != nil {
		http.Error(w, "Erreur lors du décodage du JSON", http.StatusBadRequest)
		return
	}

	h.UpdateNode(nodeUpdate)

	w.WriteHeader(http.StatusOK)
	w.Write([]byte(`{"status": "success"}`))
}*/

func HandleUpdateNodes(w http.ResponseWriter, r *http.Request) {
	if r.Method != "POST" {
		http.Error(w, "POST requested", http.StatusMethodNotAllowed)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	UpdateNodes()
}

/*func (h *NodeHandler) UpdateNode(nodeUpdate models.NodeUpdate) {
	node, found := registeredNodes[nodeUpdate.NodeId]
	if found {

		updateServicesFromNode(&node)
		h.Repo.UpdateNodeLastSeen(nodeUpdate.NodeId)

		for _, serviceUpdate := range nodeUpdate.Services {
			h.Repo.UpdateServiceStatus(serviceUpdate)
		}
	}
}*/

func HandleRetrieveNode(w http.ResponseWriter, r *http.Request) {
	if r.Method != "GET" {
		http.Error(w, "GET requested", http.StatusMethodNotAllowed)
		return
	}

	w.Header().Set("Content-Type", "application/json")

	params := mux.Vars(r)
	nodeID := params["id"]

	node, found := registeredNodes[nodeID]
	if found {
		// 4. Node trouvé : le retourner au format JSON
		json.NewEncoder(w).Encode(node)
	} else {
		// 5. Node non trouvé : retourner une erreur 404
		w.WriteHeader(http.StatusNotFound)

		// Optionnel : Retourner un message d'erreur clair
		errorResponse := map[string]string{"error": "Node non trouvé", "id": nodeID}
		json.NewEncoder(w).Encode(errorResponse)
	}
}

func UpdateNodes() {
	/*for nodeId := range registeredNodes {
		updateNode(nodeId)
	}*/
}