QuoteForge/internal/handlers/configuration.go

package handlers

import (
	"io"
	"net/http"
	"strconv"

	"github.com/gin-gonic/gin"
	"git.mchus.pro/mchus/quoteforge/internal/middleware"
	"git.mchus.pro/mchus/quoteforge/internal/services"
)

type ConfigurationHandler struct {
	configService *services.ConfigurationService
	exportService *services.ExportService
}

func NewConfigurationHandler(
	configService *services.ConfigurationService,
	exportService *services.ExportService,
) *ConfigurationHandler {
	return &ConfigurationHandler{
		configService: configService,
		exportService: exportService,
	}
}

func (h *ConfigurationHandler) List(c *gin.Context) {
	userID := middleware.GetUserID(c)
	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
	perPage, _ := strconv.Atoi(c.DefaultQuery("per_page", "20"))

	configs, total, err := h.configService.ListByUser(userID, page, perPage)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"configurations": configs,
		"total":          total,
		"page":           page,
		"per_page":       perPage,
	})
}

func (h *ConfigurationHandler) Create(c *gin.Context) {
	userID := middleware.GetUserID(c)

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

	config, err := h.configService.Create(userID, &req)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	c.JSON(http.StatusCreated, config)
}

func (h *ConfigurationHandler) Get(c *gin.Context) {
	userID := middleware.GetUserID(c)
	uuid := c.Param("uuid")

	config, err := h.configService.GetByUUID(uuid, userID)
	if err != nil {
		status := http.StatusNotFound
		if err == services.ErrConfigForbidden {
			status = http.StatusForbidden
		}
		c.JSON(status, gin.H{"error": err.Error()})
		return
	}

	c.JSON(http.StatusOK, config)
}

func (h *ConfigurationHandler) Update(c *gin.Context) {
	userID := middleware.GetUserID(c)
	uuid := c.Param("uuid")

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

	config, err := h.configService.Update(uuid, userID, &req)
	if err != nil {
		status := http.StatusInternalServerError
		if err == services.ErrConfigNotFound {
			status = http.StatusNotFound
		} else if err == services.ErrConfigForbidden {
			status = http.StatusForbidden
		}
		c.JSON(status, gin.H{"error": err.Error()})
		return
	}

	c.JSON(http.StatusOK, config)
}

func (h *ConfigurationHandler) Delete(c *gin.Context) {
	userID := middleware.GetUserID(c)
	uuid := c.Param("uuid")

	err := h.configService.Delete(uuid, userID)
	if err != nil {
		status := http.StatusInternalServerError
		if err == services.ErrConfigNotFound {
			status = http.StatusNotFound
		} else if err == services.ErrConfigForbidden {
			status = http.StatusForbidden
		}
		c.JSON(status, gin.H{"error": err.Error()})
		return
	}

	c.JSON(http.StatusOK, gin.H{"message": "deleted"})
}

func (h *ConfigurationHandler) ExportJSON(c *gin.Context) {
	userID := middleware.GetUserID(c)
	uuid := c.Param("uuid")

	data, err := h.configService.ExportJSON(uuid, userID)
	if err != nil {
		c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
		return
	}

	c.Header("Content-Disposition", "attachment; filename=config.json")
	c.Data(http.StatusOK, "application/json", data)
}

func (h *ConfigurationHandler) ImportJSON(c *gin.Context) {
	userID := middleware.GetUserID(c)

	data, err := io.ReadAll(c.Request.Body)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "failed to read body"})
		return
	}

	config, err := h.configService.ImportJSON(userID, data)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	c.JSON(http.StatusCreated, config)
}