package handlers

import (
	"database/sql"
	"encoding/json"
	"net/http"
	"strconv"

	"code.springupsoftware.com/cmc/cmc-sales/internal/cmc/db"
	"github.com/gorilla/mux"
)

type StatusHandler struct {
	queries *db.Queries
}

func NewStatusHandler(queries *db.Queries) *StatusHandler {
	return &StatusHandler{queries: queries}
}

func (h *StatusHandler) List(w http.ResponseWriter, r *http.Request) {
	limit := 50
	offset := 0

	if l := r.URL.Query().Get("limit"); l != "" {
		if val, err := strconv.Atoi(l); err == nil {
			limit = val
		}
	}

	if o := r.URL.Query().Get("offset"); o != "" {
		if val, err := strconv.Atoi(o); err == nil {
			offset = val
		}
	}

	statuses, err := h.queries.ListStatuses(r.Context(), db.ListStatusesParams{
		Limit:  int32(limit),
		Offset: int32(offset),
	})
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

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

func (h *StatusHandler) Get(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	id, err := strconv.Atoi(vars["id"])
	if err != nil {
		http.Error(w, "Invalid status ID", http.StatusBadRequest)
		return
	}

	status, err := h.queries.GetStatus(r.Context(), int32(id))
	if err != nil {
		if err == sql.ErrNoRows {
			http.Error(w, "Status not found", http.StatusNotFound)
			return
		}
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

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

func (h *StatusHandler) Create(w http.ResponseWriter, r *http.Request) {
	// Parse form data for HTMX requests
	if err := r.ParseForm(); err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	params := db.CreateStatusParams{
		Name:  r.FormValue("name"),
		Color: sql.NullString{String: r.FormValue("color"), Valid: r.FormValue("color") != ""},
	}

	// Check if this is a JSON request
	if r.Header.Get("Content-Type") == "application/json" {
		if err := json.NewDecoder(r.Body).Decode(&params); err != nil {
			http.Error(w, err.Error(), http.StatusBadRequest)
			return
		}
	}

	result, err := h.queries.CreateStatus(r.Context(), params)
	if err != nil {
		if r.Header.Get("HX-Request") == "true" {
			w.Header().Set("Content-Type", "text/html")
			w.Write([]byte(`<div class="notification is-danger">Error creating status</div>`))
			return
		}
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

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

	// If HTMX request, return success message
	if r.Header.Get("HX-Request") == "true" {
		w.Header().Set("Content-Type", "text/html")
		w.Write([]byte(`<div class="notification is-success">Status created successfully</div>`))
		return
	}

	// JSON response for API
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusCreated)
	json.NewEncoder(w).Encode(map[string]interface{}{
		"id": id,
	})
}

func (h *StatusHandler) Update(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	id, err := strconv.Atoi(vars["id"])
	if err != nil {
		http.Error(w, "Invalid status ID", http.StatusBadRequest)
		return
	}

	var params db.UpdateStatusParams
	if r.Header.Get("Content-Type") == "application/json" {
		if err := json.NewDecoder(r.Body).Decode(&params); err != nil {
			http.Error(w, err.Error(), http.StatusBadRequest)
			return
		}
	} else {
		// Handle form data
		if err := r.ParseForm(); err != nil {
			http.Error(w, err.Error(), http.StatusBadRequest)
			return
		}
		
		params = db.UpdateStatusParams{
			Name:  r.FormValue("name"),
			Color: sql.NullString{String: r.FormValue("color"), Valid: r.FormValue("color") != ""},
		}
	}
	
	params.ID = int32(id)

	if err := h.queries.UpdateStatus(r.Context(), params); err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	w.WriteHeader(http.StatusNoContent)
}

func (h *StatusHandler) Delete(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	id, err := strconv.Atoi(vars["id"])
	if err != nil {
		http.Error(w, "Invalid status ID", http.StatusBadRequest)
		return
	}

	if err := h.queries.DeleteStatus(r.Context(), int32(id)); err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	w.WriteHeader(http.StatusNoContent)
}

func (h *StatusHandler) JsonList(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	selectedID := 0
	if sid := vars["selectedId"]; sid != "" {
		selectedID, _ = strconv.Atoi(sid)
	}

	statuses, err := h.queries.ListStatuses(r.Context(), db.ListStatusesParams{
		Limit:  100,
		Offset: 0,
	})
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	// Format for JSON list with selected indicator
	var results []map[string]interface{}
	for _, status := range statuses {
		results = append(results, map[string]interface{}{
			"id":       status.ID,
			"name":     status.Name,
			"color":    status.Color.String,
			"selected": status.ID == int32(selectedID),
		})
	}

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