package handlers

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

/*func retrieveServicesFromNode(node *models.NodeInfo) map[string]models.Service {

	apiURL := node.Address + "/list"

	resp, err := http.Get(apiURL)

	log.Printf("retrieving node %s on address %s", node.Name, apiURL)

	if err != nil {
		log.Fatalf("Erreur lors de la requête : %v", err)
	}

	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		log.Fatalf("Requête échouée avec le statut : %s", resp.Status)
	}

	bodyBytes, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Fatalf("Erreur lors de la lecture du corps de la réponse : %v", err)
	}

	var services []models.Service

	err = json.Unmarshal(bodyBytes, &services)
	if err != nil {
		log.Fatalf("Erreur lors du décodage JSON : %v", err)
	}

	var result map[string]models.Service

	for _, service := range services {
		result[service.Name] = service
	}

	return result
}*/

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

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

	var serviceID int
	serviceID, err = h.Repo.RegisterService(serviceRegister.Service, serviceRegister.NodeId)

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

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

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

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

	err = h.Repo.UpdateServiceStatus(serviceUpdate)

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

	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusOK)
}

/*func updateServicesFromNode(node *models.NodeInfo) {
	node.Services = retrieveServicesFromNode(node)
}*/

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

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

	var node models.NodeInfo

	node, err = h.Repo.RetriveNode(serviceDelete.NodeId)

	if err == nil {
		err = h.Repo.DeleteService(node, serviceDelete.ServiceId)
		if err != nil {

			log.Fatalf("error on deleteing service from node %v error : %v", serviceDelete.NodeId, err.Error())
			http.Error(w, err.Error(), http.StatusBadRequest)
			return
		}

		w.Header().Set("Content-Type", "application/json")
	} else {
		log.Fatalf("Node not found %v error : %v", serviceDelete.NodeId, err.Error())
	}
}