package api

import (
	"errors"
	"go_oxspeak_server/models"
	"go_oxspeak_server/network/http/handler"
	"net/http"

	"github.com/gin-gonic/gin"
	"gorm.io/gorm"
)

type ServerHandler struct {
	*handler.Handler
}

func NewServerHandler(h *handler.Handler) *ServerHandler {
	return &ServerHandler{h}
}

func (h *ServerHandler) RegisterRoutes(rg *gin.RouterGroup) {
	server := rg.Group("/server")
	server.GET("/", h.serverList)
	server.GET("/:id/", h.serverDetail)
	server.POST("/", h.serverAdd)
	server.PUT("/:id/", h.serverUpdate)
	server.DELETE("/:id/", h.serverDelete)
}

func (h *ServerHandler) serverList(c *gin.Context) {
	var servers []models.Server
	result := h.DB.Find(&servers)
	if result.Error != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": result.Error.Error()})
		return
	}

	c.JSON(http.StatusOK, servers)
}

func (h *ServerHandler) serverDetail(c *gin.Context) {
	id := c.Param("id")

	var server models.Server
	result := h.DB.First(&server, "id = ?", id)
	if result.Error != nil {
		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
			c.JSON(http.StatusNotFound, gin.H{"error": "Server not found"})
			return
		}
		c.JSON(http.StatusInternalServerError, gin.H{"error": result.Error.Error()})
		return
	}

	c.JSON(http.StatusOK, server)
}

func (h *ServerHandler) serverAdd(c *gin.Context) {

	var req CreateServerRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	// construire le modèle
	server := models.Server{
		Name:     req.Name,
		Password: req.Password,
	}

	if err := h.DB.Create(&server).Error; err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	c.JSON(http.StatusCreated, server)
}

func (h *ServerHandler) serverUpdate(c *gin.Context) {
	id := c.Param("id")

	var server models.Server
	result := h.DB.First(&server, "id = ?", id)
	if result.Error != nil {
		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
			c.JSON(http.StatusNotFound, gin.H{"error": "Server not found"})
			return
		}
		c.JSON(http.StatusInternalServerError, gin.H{"error": result.Error.Error()})
		return
	}

	var req UpdateServerRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	if err := h.DB.Model(&server).Updates(req).Error; err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to update server"})
		return
	}

	c.JSON(http.StatusOK, server)
}

func (h *ServerHandler) serverDelete(c *gin.Context) {
	id := c.Param("id")

	var server models.Server
	result := h.DB.First(&server, "id = ?", id)
	if result.Error != nil {
		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
			c.JSON(http.StatusNotFound, gin.H{"error": "Server not found"})
			return
		}
		c.JSON(http.StatusInternalServerError, gin.H{"error": result.Error.Error()})
		return
	}

	if err := h.DB.Delete(&server).Error; err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to delete server"})
		return
	}

	c.Status(http.StatusNoContent)
}