selvaGo/internal/api/handlers.go

package api

import (
	"database/sql"
	"encoding/json"
	"html/template"
	"log"
	"net/http"
	"strconv"

	"github.com/gorilla/mux"
)

// Nombre representa la estructura de la tabla Nombres (assuming this is your plant table).
type Nombre struct {
	NombreID    int     `json:"NombreID"`
	FamiliaID   int     `json:"FamiliaID"`
	Nombre      string  `json:"Nombre"`
	Fecha       string  `json:"Fecha"`
	ProveedorID int     `json:"ProveedorID"`
	Precio      float64 `json:"Precio"`
	Inactivo    bool    `json:"Inactivo"`
	// Add other relevant fields if you want to display them
}

// APIHandler ... (rest of your struct definition)

// NewAPIHandler ... (rest of your function)

// GetIndexPlantsHTML recupera the first 20 plants from the Nombres table.
// internal/api/api.go

func (h *APIHandler) GetIndexPlantsHTML(w http.ResponseWriter, r *http.Request) {
	log.Println("GetIndexPlantsHTML called")

	rows, err := h.DB.Query("SELECT NombreID, FamiliaID, Nombre, Fecha, ProveedorID, Precio, Inactivo FROM Nombres WHERE Inactivo = 0 LIMIT 20")
	if err != nil {
		log.Println("Database query error:", err)
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	defer rows.Close()

	var plants []Nombre
	for rows.Next() {
		var plant Nombre
		if err := rows.Scan(&plant.NombreID, &plant.FamiliaID, &plant.Nombre, &plant.Fecha, &plant.ProveedorID, &plant.Precio, &plant.Inactivo); err != nil {
			log.Println("Row scan error:", err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		plants = append(plants, plant)
	}

	log.Println("Retrieved plants:", plants)

	if err := h.template.ExecuteTemplate(w, "index.html", plants); err != nil {
		log.Println("Template execution error:", err)
		http.Error(w, "Failed to render HTML", http.StatusInternalServerError)
		return
	}
	log.Println("index.html rendered")
}

// APIHandler maneja las operaciones de la API para la tabla Nombres.
type APIHandler struct {
	DB       *sql.DB
	template *template.Template // To store loaded HTML templates
}

// NewAPIHandler crea una nueva instancia de APIHandler.
func NewAPIHandler(db *sql.DB, tmpl *template.Template) *APIHandler {
	return &APIHandler{DB: db, template: tmpl}
}

// CreateNombre crea un nuevo registro en la tabla Nombres.
func (h *APIHandler) CreateNombre(w http.ResponseWriter, r *http.Request) {
	var nombre Nombre
	if err := json.NewDecoder(r.Body).Decode(&nombre); err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	result, err := h.DB.Exec("INSERT INTO Nombres (FamiliaID, Nombre, Fecha, ProveedorID, Precio, Inactivo) VALUES (?, ?, ?, ?, ?, ?)",
		nombre.FamiliaID, nombre.Nombre, nombre.Fecha, nombre.ProveedorID, nombre.Precio, nombre.Inactivo)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

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

	nombre.NombreID = int(id)
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusCreated)
	json.NewEncoder(w).Encode(nombre)
}

// GetNombres recupera todos los registros de la tabla Nombres.
func (h *APIHandler) GetNombres(w http.ResponseWriter, r *http.Request) {
	rows, err := h.DB.Query("SELECT NombreID, FamiliaID, Nombre, Fecha, ProveedorID, Precio, Inactivo FROM Nombres")
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	defer rows.Close()

	var nombres []Nombre
	for rows.Next() {
		var nombre Nombre
		if err := rows.Scan(&nombre.NombreID, &nombre.FamiliaID, &nombre.Nombre, &nombre.Fecha, &nombre.ProveedorID, &nombre.Precio, &nombre.Inactivo); err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		nombres = append(nombres, nombre)
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(nombres)
}

// GetNombreByID recupera un registro de la tabla Nombres por su ID.
func (h *APIHandler) GetNombreByID(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	idStr, ok := vars["id"]
	if !ok {
		http.Error(w, "Invalid ID", http.StatusBadRequest)
		return
	}
	id, err := strconv.Atoi(idStr)
	if err != nil {
		http.Error(w, "Invalid ID", http.StatusBadRequest)
		return
	}

	var nombre Nombre
	err = h.DB.QueryRow("SELECT NombreID, FamiliaID, Nombre, Fecha, ProveedorID, Precio, Inactivo FROM Nombres WHERE NombreID = ?", id).Scan(
		&nombre.NombreID, &nombre.FamiliaID, &nombre.Nombre, &nombre.Fecha, &nombre.ProveedorID, &nombre.Precio, &nombre.Inactivo)
	if err != nil {
		if err == sql.ErrNoRows {
			http.Error(w, "Nombre not found", http.StatusNotFound)
		} else {
			http.Error(w, err.Error(), http.StatusInternalServerError)
		}
		return
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(nombre)
}

// UpdateNombre actualiza un registro existente en la tabla Nombres.
func (h *APIHandler) UpdateNombre(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	idStr, ok := vars["id"]
	if !ok {
		http.Error(w, "Invalid ID", http.StatusBadRequest)
		return
	}
	id, err := strconv.Atoi(idStr)
	if err != nil {
		http.Error(w, "Invalid ID", http.StatusBadRequest)
		return
	}

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

	_, err = h.DB.Exec("UPDATE Nombres SET FamiliaID = ?, Nombre = ?, Fecha = ?, ProveedorID = ?, Precio = ?, Inactivo = ? WHERE NombreID = ?",
		nombre.FamiliaID, nombre.Nombre, nombre.Fecha, nombre.ProveedorID, nombre.Precio, nombre.Inactivo, id)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	nombre.NombreID = id
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(nombre)
}

// SearchNombres busca registros en la tabla Nombres por nombre.
func (h *APIHandler) SearchNombres(w http.ResponseWriter, r *http.Request) {
	nombre := r.URL.Query().Get("nombre")
	if nombre == "" {
		http.Error(w, "Nombre parameter is required", http.StatusBadRequest)
		return
	}

	rows, err := h.DB.Query("SELECT NombreID, FamiliaID, Nombre, Fecha, ProveedorID, Precio, Inactivo FROM Nombres WHERE Nombre = ?", nombre)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	defer rows.Close()

	var nombres []Nombre
	for rows.Next() {
		var nombre Nombre
		if err := rows.Scan(&nombre.NombreID, &nombre.FamiliaID, &nombre.Nombre, &nombre.Fecha, &nombre.ProveedorID, &nombre.Precio, &nombre.Inactivo); err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		nombres = append(nombres, nombre)
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(nombres)
}

// DeleteNombre elimina un registro de la tabla Nombres por su ID.
func (h *APIHandler) DeleteNombre(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	idStr, ok := vars["id"]
	if !ok {
		http.Error(w, "Invalid ID", http.StatusBadRequest)
		return
	}
	id, err := strconv.Atoi(idStr)
	if err != nil {
		http.Error(w, "Invalid ID", http.StatusBadRequest)
		return
	}

	_, err = h.DB.Exec("DELETE FROM Nombres WHERE NombreID = ?", id)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string]string{"message": "Nombre deleted"})
}

// GetNombresHTML recupera todos los registros de la tabla Nombres y los muestra en una página HTML.
func (h *APIHandler) GetNombresHTML(w http.ResponseWriter, r *http.Request) {
	log.Println("GetNombresHTML called")
	rows, err := h.DB.Query("SELECT NombreID, FamiliaID, Nombre, Fecha, ProveedorID, Precio, Inactivo FROM Nombres")
	if err != nil {
		log.Println("Database query error:", err)
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	defer rows.Close()

	var nombres []Nombre
	for rows.Next() {
		var nombre Nombre
		if err := rows.Scan(&nombre.NombreID, &nombre.FamiliaID, &nombre.Nombre, &nombre.Fecha, &nombre.ProveedorID, &nombre.Precio, &nombre.Inactivo); err != nil {
			log.Println("Row scan error:", err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		nombres = append(nombres, nombre)
	}

	log.Println("Retrieved nombres:", nombres)
	if err := h.template.ExecuteTemplate(w, "nombres.html", nombres); err != nil {
		log.Println("Template execution error:", err)
		http.Error(w, "Failed to render HTML", http.StatusInternalServerError)
		return
	}
	log.Println("nombres.html rendered")
}

// GetNombreByIDHTML recupera un registro de la tabla Nombres por su ID, el nombre de su familia,
// y el nombre del proveedor, luego los muestra en una página HTML.
func (h *APIHandler) GetNombreByIDHTML(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	idStr, ok := vars["id"]
	if !ok {
		http.Error(w, "Invalid ID", http.StatusBadRequest)
		return
	}
	id, err := strconv.Atoi(idStr)
	if err != nil {
		http.Error(w, "Invalid ID", http.StatusBadRequest)
		return
	}

	var nombreDetalle struct {
		Nombre        Nombre
		FamiliaName   string
		ProveedorName string
	}

	// Join nombres, familias, and proveedores tables
	err = h.DB.QueryRow(`
		SELECT
			n.NombreID,
			n.FamiliaID,
			n.Nombre,
			n.Fecha,
			n.ProveedorID,
			n.Precio,
			n.Inactivo,
			f.Familia,
			p.Nombre
		FROM nombres n
		INNER JOIN familias f ON n.FamiliaID = f.FamiliaID
		INNER JOIN proveedores p ON n.ProveedorID = p.ProveedorID
		WHERE n.NombreID = ?
	`, id).Scan(
		&nombreDetalle.Nombre.NombreID,
		&nombreDetalle.Nombre.FamiliaID,
		&nombreDetalle.Nombre.Nombre,
		&nombreDetalle.Nombre.Fecha,
		&nombreDetalle.Nombre.ProveedorID,
		&nombreDetalle.Nombre.Precio,
		&nombreDetalle.Nombre.Inactivo,
		&nombreDetalle.FamiliaName,
		&nombreDetalle.ProveedorName,
	)
	if err != nil {
		if err == sql.ErrNoRows {
			http.Error(w, "Nombre not found", http.StatusNotFound)
		} else {
			log.Println("Database query error:", err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
		}
		return
	}

	if err := h.template.ExecuteTemplate(w, "nombre.html", nombreDetalle); err != nil {
		log.Println("Template execution error:", err)
		http.Error(w, "Failed to render HTML", http.StatusInternalServerError)
		return
	}
}

func (h *APIHandler) EditNombreHTML(w http.ResponseWriter, r *http.Request) {
	log.Println("EditNombreHTML called")
	vars := mux.Vars(r)
	idStr, ok := vars["id"]
	log.Printf("Extracted ID string: %s, ok: %v", idStr, ok)
	if !ok {
		http.Error(w, "Invalid ID", http.StatusBadRequest)
		return
	}
	id, err := strconv.Atoi(idStr)
	log.Printf("Converted ID: %d, error: %v", id, err)
	if err != nil {
		http.Error(w, "Invalid ID", http.StatusBadRequest)
		return
	}

	var nombre Nombre
	err = h.DB.QueryRow("SELECT NombreID, FamiliaID, Nombre, Fecha, ProveedorID, Precio, Inactivo FROM Nombres WHERE NombreID = ?", id).Scan(
		&nombre.NombreID, &nombre.FamiliaID, &nombre.Nombre, &nombre.Fecha, &nombre.ProveedorID, &nombre.Precio, &nombre.Inactivo)
	log.Printf("Database query result: %+v, error: %v", nombre, err)
	if err != nil {
		if err == sql.ErrNoRows {
			http.Error(w, "Nombre not found", http.StatusNotFound)
		} else {
			log.Println("Database query error:", err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
		}
		return
	}

	log.Printf("Data passed to template: %+v", nombre)

	w.Header().Set("Content-Type", "text/html; charset=utf-8") // Set header BEFORE executing template

	if err := h.template.ExecuteTemplate(w, "edit_nombre.html", nombre); err != nil {
		log.Println("Template execution error:", err)
		http.Error(w, "Failed to render HTML", http.StatusInternalServerError)
		return
	}
	log.Println("edit_nombre.html rendered")
}

// UpdateNombreHTML actualiza un registro en la tabla Nombres desde una página HTML.
func (h *APIHandler) UpdateNombreHTML(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	idStr, ok := vars["id"]
	if !ok {
		http.Error(w, "Invalid ID", http.StatusBadRequest)
		return
	}
	id, err := strconv.Atoi(idStr)
	if err != nil {
		log.Println("Invalid ID:", err)
		http.Error(w, "Invalid ID", http.StatusBadRequest)
		return
	}

	if err := r.ParseForm(); err != nil {
		log.Println("Form parsing error:", err)
		http.Error(w, "Failed to parse form", http.StatusBadRequest)
		return
	}

	nombre := Nombre{
		NombreID:    id,
		FamiliaID:   atoi(r.FormValue("FamiliaID")),
		Nombre:      r.FormValue("Nombre"),
		Fecha:       r.FormValue("Fecha"),
		ProveedorID: atoi(r.FormValue("ProveedorID")),
		Precio:      atof64(r.FormValue("Precio")),
		Inactivo:    r.FormValue("Inactivo") == "on",
	}

	log.Println("Updating nombre:", nombre)

	fecha := nombre.Fecha
	if fecha == "" {
		fecha = "0000-00-00"
	}

	_, err = h.DB.Exec("UPDATE Nombres SET FamiliaID = ?, Nombre = ?, Fecha = ?, ProveedorID = ?, Precio = ?, Inactivo = ? WHERE NombreID = ?",
		nombre.FamiliaID, nombre.Nombre, fecha, nombre.ProveedorID, nombre.Precio, nombre.Inactivo, id)
	if err != nil {
		log.Println("Database update error:", err)
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	log.Println("Nombre updated successfully")
	http.Redirect(w, r, "/nombres/html/"+strconv.Itoa(id), http.StatusFound)
}

func atoi(s string) int {
	i, _ := strconv.Atoi(s) // Ignore error for simplicity in this context
	return i
}

func atof64(s string) float64 {
	f, _ := strconv.ParseFloat(s, 64) // Ignore error for simplicity
	return f
}