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 MessageHandler struct {
	*handler.Handler
}

func NewMessageHandler(h *handler.Handler) *MessageHandler {
	return &MessageHandler{h}
}

func (h *MessageHandler) RegisterRoutes(rg *gin.RouterGroup) {
	rg.GET("/", h.getMessages)
	rg.GET("/:id/", h.getMessage)
	rg.POST("/", h.addMessage)
	rg.PUT("/:id/", h.updateMessage)
	rg.DELETE("/:id/", h.deleteMessage)
}

func (h *MessageHandler) getMessages(c *gin.Context) {
	var messages []models.Message
	result := h.DB.Find(&messages)
	if result.Error != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": result.Error.Error()})
		return
	}
	c.JSON(http.StatusOK, messages)
}

func (h *MessageHandler) getMessage(c *gin.Context) {
	id := c.Param("id")
	var message models.Message
	result := h.DB.First(&message, "id = ?", id)
	if result.Error != nil {
		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
			c.JSON(http.StatusNotFound, gin.H{"error": "Message not found"})
			return
		}
		c.JSON(http.StatusInternalServerError, gin.H{"error": result.Error.Error()})
		return
	}
	c.JSON(http.StatusOK, message)
}

func (h *MessageHandler) addMessage(c *gin.Context) {
	var req CreateMessageRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	message := models.Message{
		ChannelID: req.ChannelID,
		UserID:    req.UserID,
		Content:   req.Content,
		ReplyToID: req.ReplyToID,
	}

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

	c.JSON(http.StatusCreated, message)
}

func (h *MessageHandler) updateMessage(c *gin.Context) {
	id := c.Param("id")

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

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

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

	c.JSON(http.StatusOK, message)
}

func (h *MessageHandler) deleteMessage(c *gin.Context) {
	id := c.Param("id")
	var message models.Message
	result := h.DB.First(&message, "id = ?", id)
	if result.Error != nil {
		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
			c.JSON(http.StatusNotFound, gin.H{"error": "Message not found"})
			return
		}
		c.JSON(http.StatusInternalServerError, gin.H{"error": result.Error.Error()})
		return
	}

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

	c.Status(http.StatusNoContent)
}