backend/internal/handler/sticker_handler.go

package handler

import (
	"errors"
	"net/http"

	"github.com/gin-gonic/gin"

	"with_you/internal/pkg/response"
	"with_you/internal/service"
)

// StickerHandler 自定义表情处理器
type StickerHandler struct {
	stickerService service.StickerService
}

// NewStickerHandler 创建自定义表情处理器
func NewStickerHandler(stickerService service.StickerService) *StickerHandler {
	return &StickerHandler{
		stickerService: stickerService,
	}
}

// GetStickersRequest 获取表情列表请求
type GetStickersRequest struct {
	UserID string `form:"user_id" binding:"required"`
}

// AddStickerRequest 添加表情请求
type AddStickerRequest struct {
	URL    string `json:"url" binding:"required"`
	Width  int    `json:"width"`
	Height int    `json:"height"`
}

// DeleteStickerRequest 删除表情请求
type DeleteStickerRequest struct {
	StickerID string `json:"sticker_id" binding:"required"`
}

// ReorderStickersRequest 重新排序请求
type ReorderStickersRequest struct {
	Orders map[string]int `json:"orders" binding:"required"`
}

// CheckStickerRequest 检查表情是否存在请求
type CheckStickerRequest struct {
	URL string `form:"url" binding:"required"`
}

// GetStickers 获取用户的表情列表
func (h *StickerHandler) GetStickers(c *gin.Context) {
	userID := c.GetString("user_id")
	if userID == "" {
		response.Unauthorized(c, "")
		return
	}

	stickers, err := h.stickerService.GetUserStickers(userID)
	if err != nil {
		response.InternalServerError(c, "failed to get stickers")
		return
	}

	response.Success(c, gin.H{"stickers": stickers})
}

// AddSticker 添加表情
func (h *StickerHandler) AddSticker(c *gin.Context) {
	userID := c.GetString("user_id")
	if userID == "" {
		response.Unauthorized(c, "")
		return
	}

	var req AddStickerRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.BadRequest(c, err.Error())
		return
	}

	sticker, err := h.stickerService.AddSticker(userID, req.URL, req.Width, req.Height)
	if err != nil {
		if errors.Is(err, service.ErrStickerAlreadyExists) {
			response.Error(c, http.StatusConflict, "sticker already exists")
			return
		}
		if errors.Is(err, service.ErrInvalidStickerURL) {
			response.BadRequest(c, "invalid sticker url, only http/https is allowed")
			return
		}
		response.InternalServerError(c, err.Error())
		return
	}

	response.Success(c, gin.H{"sticker": sticker})
}

// DeleteSticker 删除表情
func (h *StickerHandler) DeleteSticker(c *gin.Context) {
	userID := c.GetString("user_id")
	if userID == "" {
		response.Unauthorized(c, "")
		return
	}

	var req DeleteStickerRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.BadRequest(c, err.Error())
		return
	}

	if err := h.stickerService.DeleteSticker(userID, req.StickerID); err != nil {
		response.InternalServerError(c, err.Error())
		return
	}

	response.SuccessWithMessage(c, "sticker deleted successfully", nil)
}

// ReorderStickers 重新排序表情
func (h *StickerHandler) ReorderStickers(c *gin.Context) {
	userID := c.GetString("user_id")
	if userID == "" {
		response.Unauthorized(c, "")
		return
	}

	var req ReorderStickersRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.BadRequest(c, err.Error())
		return
	}

	if err := h.stickerService.ReorderStickers(userID, req.Orders); err != nil {
		response.InternalServerError(c, err.Error())
		return
	}

	response.SuccessWithMessage(c, "stickers reordered successfully", nil)
}

// CheckStickerExists 检查表情是否存在
func (h *StickerHandler) CheckStickerExists(c *gin.Context) {
	userID := c.GetString("user_id")
	if userID == "" {
		response.Unauthorized(c, "")
		return
	}

	url := c.Query("url")
	if url == "" {
		response.BadRequest(c, "url is required")
		return
	}

	exists, err := h.stickerService.CheckExists(userID, url)
	if err != nil {
		response.InternalServerError(c, err.Error())
		return
	}

	response.Success(c, gin.H{"exists": exists})
}