package api

//import (
//	"context"
//	"daemonService/internal/models"
//	"encoding/json"
//	"fmt"
//	"io"
//	"log"
//	"net/http"
//	"time"
//
//	"daemonService/internal/services"
//
//	"github.com/gorilla/mux"
//)
//
//// APIResponse estructura la respuesta común del API.
//type APIResponse struct {
//	Success bool        `json:"success"`
//	Message string      `json:"message"`
//	Data    interface{} `json:"data,omitempty"`
//	Error   string      `json:"error,omitempty"`
//}
//
//// setupAPIHandlers configura los endpoints del API HTTP.
//func setupAPIHandlers(router *mux.Router, service []models.SoapService, isCron bool) {
//	// Lista de servicios disponibles
//	router.HandleFunc("/api/services", func(w http.ResponseWriter, r *http.Request) {
//		serviceNames := make([]string, len(service))
//		for i, svc := range service {
//			serviceNames[i] = svc.GetName()
//		}
//
//		response := APIResponse{
//			Success: true,
//			Message: "Lista de servicios disponibles",
//			Data:    serviceNames,
//		}
//		w.Header().Set("Content-Type", "application/json")
//		json.NewEncoder(w).Encode(response)
//	}).Methods("GET")
//
//	// Ejecutar todos los servicios
//	router.HandleFunc("/api/services/run-all", func(w http.ResponseWriter, r *http.Request) {
//		ctx, cancel := context.WithTimeout(r.Context(), 5*time.Minute)
//		defer cancel()
//
//		go func() {
//			errors := services.RunAllServices(ctx, service, isCron) //ariel agrego:request
//			log.Printf("Ejecución de todos los servicios completada con %d errores", len(errors))
//		}()
//
//		response := APIResponse{
//			Success: true,
//			Message: "Ejecución de todos los servicios iniciada",
//		}
//		w.Header().Set("Content-Type", "application/json")
//		json.NewEncoder(w).Encode(response)
//	}).Methods("POST")
//
//	// Ejecutar un servicio específico
//	router.HandleFunc("/api/services/{name}", func(w http.ResponseWriter, r *http.Request) {
//		vars := mux.Vars(r)
//
//		//////////////////////////////////////////////////////////////////////////////////////////////
//		// Es importante cerrar el body después de leerlo para liberar recursos.
//		defer r.Body.Close()
//		// Leemos el contenido del body.
//		body, err := io.ReadAll(r.Body)
//		if err != nil {
//			http.Error(w, "Error leyendo el body", http.StatusInternalServerError)
//			return
//		}
//		// Si quieres convertirlo a string:
//		bodyStr := string(body)
//		fmt.Println("Body de la petición:", bodyStr)
//		//////////////////////////////////////////////////////////////////////////////////////////////
//
//		serviceName := vars["name"]
//
//		ctx, cancel := context.WithTimeout(r.Context(), 5*time.Minute)
//		defer cancel()
//
//		var encontrado bool
//		for _, svc := range service {
//			if svc.GetName() == serviceName {
//				encontrado = true
//				go func() {
//					// if err := svc.Execute(ctx); err != nil {
//					// 	log.Printf("Error al ejecutar servicio %s: %v", serviceName, err)
//					// } else {
//					// 	log.Printf("Servicio %s ejecutado correctamente", serviceName)
//					// }
//					if err := svc.Execute(ctx, r, isCron); err != nil { //ariel agrego:request
//						log.Printf("Error al ejecutar servicio %s: %v", serviceName, err) ///modificado
//					} else {
//						log.Printf("Servicio %s ejecutado correctamente", serviceName)
//					}
//				}()
//				break
//			}
//		}
//
//		if !encontrado {
//			w.WriteHeader(http.StatusNotFound)
//			response := APIResponse{
//				Success: false,
//				Error:   fmt.Sprintf("Servicio no encontrado: %s", serviceName),
//			}
//			w.Header().Set("Content-Type", "application/json")
//			json.NewEncoder(w).Encode(response)
//			return
//		}
//
//		response := APIResponse{
//			Success: true,
//			Message: fmt.Sprintf("Ejecución del servicio %s iniciada", serviceName),
//		}
//		w.Header().Set("Content-Type", "application/json")
//		json.NewEncoder(w).Encode(response)
//	}).Methods("POST")
//
//	// Health check
//	router.HandleFunc("/api/health", func(w http.ResponseWriter, r *http.Request) {
//		response := APIResponse{
//			Success: true,
//			Message: "Servicio activo",
//			Data: map[string]interface{}{
//				"status":    "healthy",
//				"timestamp": time.Now().Format(time.RFC3339),
//			},
//		}
//		w.Header().Set("Content-Type", "application/json")
//		json.NewEncoder(w).Encode(response)
//	}).Methods("GET")
//}
//
//// StartAPIServer inicia el servidor HTTP con la configuración del API.
//func StartAPIServer(port int, services []models.SoapService, isCron bool) *http.Server {
//	router := mux.NewRouter()
//	setupAPIHandlers(router, services, isCron)
//
//	// Middleware para logging
//	router.Use(func(next http.Handler) http.Handler {
//		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
//			start := time.Now()
//			log.Printf("API Request: %s %s", r.Method, r.URL.Path)
//			next.ServeHTTP(w, r)
//			log.Printf("API Request: %s %s completada en %v", r.Method, r.URL.Path, time.Since(start))
//		})
//	})
//
//	srv := &http.Server{
//		Addr:         fmt.Sprintf(":%d", port),
//		Handler:      router,
//		ReadTimeout:  15 * time.Second,
//		WriteTimeout: 15 * time.Second,
//		IdleTimeout:  60 * time.Second,
//	}
//
//	go func() {
//		log.Printf("API HTTP iniciada en puerto %d", port)
//		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
//			log.Fatalf("Error en servidor HTTP: %v", err)
//		}
//	}()
//
//	return srv
//}

// // runAllServices ejecuta todos los servicios de manera concurrente.
// func runAllServices(ctx context.Context, services []services.SoapService) []error {
// 	var wg sync.WaitGroup
// 	var mu sync.Mutex
// 	var errors []error

// 	for _, svc := range services {
// 		s := svc
// 		wg.Add(1)
// 		go func() {
// 			defer wg.Done()
// 			serviceCtx, cancel := context.WithCancel(ctx)
// 			defer cancel()
// 			// if err := s.Execute(serviceCtx); err != nil {
// 			if err := s.Execute(serviceCtx, nil); err != nil { //ariel agrego:request
// 				mu.Lock()
// 				errors = append(errors, err)
// 				mu.Unlock()
// 			}
// 		}()
// 	}
// 	wg.Wait()
// 	log.Println("Todos los servicios han sido ejecutados")
// 	return errors
// }