hfb_sys/backend/internal/modules/mohong/handler.go

package mohong

import (
	"errors"
	"strconv"
	"strings"

	"hfb_sys/backend/internal/middleware"
	"hfb_sys/backend/pkg/response"

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

type Handler struct {
	service *Service
}

func NewHandler(service *Service) *Handler {
	return &Handler{service: service}
}

func (h *Handler) ListCategories(c *gin.Context) {
	items, err := h.service.ListPublicCategories(c.Request.Context())
	if err != nil {
		response.RecordError(c, err)
		response.InternalServerError(c, "获取分类失败")
		return
	}
	response.OK(c, items)
}

func (h *Handler) ListProducts(c *gin.Context) {
	query := ProductListQuery{Keyword: c.Query("keyword")}
	if catID, err := strconv.ParseUint(c.Query("category_id"), 10, 64); err == nil {
		query.CategoryID = catID
	}
	query.Page, query.PageSize = parsePagination(c)
	result, err := h.service.ListPublicProducts(c.Request.Context(), query)
	if err != nil {
		response.RecordError(c, err)
		response.InternalServerError(c, "获取商品列表失败")
		return
	}
	response.OK(c, result)
}

func (h *Handler) GetProduct(c *gin.Context) {
	id, ok := parseID(c)
	if !ok {
		return
	}
	item, err := h.service.FindPublicProduct(c.Request.Context(), id)
	if err != nil {
		writeError(c, err)
		return
	}
	response.OK(c, item)
}

func (h *Handler) CreateOrder(c *gin.Context) {
	userID, ok := currentUserID(c)
	if !ok {
		response.Unauthorized(c, "缺少用户上下文")
		return
	}
	var req CreateOrderRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.BadRequest(c, "请求参数不正确")
		return
	}
	item, err := h.service.CreateOrder(c.Request.Context(), userID, req)
	if err != nil {
		writeError(c, err)
		return
	}
	response.OK(c, item)
}

func (h *Handler) ListMyOrders(c *gin.Context) {
	userID, ok := currentUserID(c)
	if !ok {
		response.Unauthorized(c, "缺少用户上下文")
		return
	}
	query := OrderListQuery{Status: c.Query("status"), Keyword: c.Query("keyword")}
	query.Page, query.PageSize = parsePagination(c)
	result, err := h.service.ListOrdersForUser(c.Request.Context(), userID, query)
	if err != nil {
		response.RecordError(c, err)
		response.InternalServerError(c, "获取订单列表失败")
		return
	}
	response.OK(c, result)
}

func (h *Handler) GetMyOrder(c *gin.Context) {
	userID, ok := currentUserID(c)
	if !ok {
		response.Unauthorized(c, "缺少用户上下文")
		return
	}
	id, ok := parseID(c)
	if !ok {
		return
	}
	item, err := h.service.FindOrderForUser(c.Request.Context(), userID, id)
	if err != nil {
		writeError(c, err)
		return
	}
	response.OK(c, item)
}

func (h *Handler) CancelMyOrder(c *gin.Context) {
	userID, ok := currentUserID(c)
	if !ok {
		response.Unauthorized(c, "缺少用户上下文")
		return
	}
	id, ok := parseID(c)
	if !ok {
		return
	}
	var body struct {
		Reason string `json:"reason"`
	}
	_ = c.ShouldBindJSON(&body)
	item, err := h.service.CancelOrder(c.Request.Context(), userID, id, body.Reason)
	if err != nil {
		writeError(c, err)
		return
	}
	response.OK(c, item)
}

func (h *Handler) AdminListCategories(c *gin.Context) {
	items, err := h.service.AdminListCategories(c.Request.Context())
	if err != nil {
		response.RecordError(c, err)
		response.InternalServerError(c, "获取分类失败")
		return
	}
	response.OK(c, items)
}

func (h *Handler) AdminCreateCategory(c *gin.Context) {
	var req CreateCategoryRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.BadRequest(c, "请求参数不正确")
		return
	}
	item, err := h.service.CreateCategory(c.Request.Context(), req)
	if err != nil {
		writeError(c, err)
		return
	}
	response.OK(c, item)
}

func (h *Handler) AdminUpdateCategory(c *gin.Context) {
	id, ok := parseID(c)
	if !ok {
		return
	}
	var req UpdateCategoryRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.BadRequest(c, "请求参数不正确")
		return
	}
	item, err := h.service.UpdateCategory(c.Request.Context(), id, req)
	if err != nil {
		writeError(c, err)
		return
	}
	response.OK(c, item)
}

func (h *Handler) AdminDeleteCategory(c *gin.Context) {
	id, ok := parseID(c)
	if !ok {
		return
	}
	if err := h.service.DeleteCategory(c.Request.Context(), id); err != nil {
		writeError(c, err)
		return
	}
	response.OK(c, gin.H{"message": "删除成功"})
}

func (h *Handler) AdminListProducts(c *gin.Context) {
	query := ProductListQuery{
		Keyword: c.Query("keyword"),
		Status:  c.Query("status"),
	}
	if catID, err := strconv.ParseUint(c.Query("category_id"), 10, 64); err == nil {
		query.CategoryID = catID
	}
	query.Page, query.PageSize = parsePagination(c)
	result, err := h.service.AdminListProducts(c.Request.Context(), query)
	if err != nil {
		response.RecordError(c, err)
		response.InternalServerError(c, "获取商品列表失败")
		return
	}
	response.OK(c, result)
}

func (h *Handler) AdminGetProduct(c *gin.Context) {
	id, ok := parseID(c)
	if !ok {
		return
	}
	item, err := h.service.AdminFindProduct(c.Request.Context(), id)
	if err != nil {
		writeError(c, err)
		return
	}
	response.OK(c, item)
}

func (h *Handler) AdminCreateProduct(c *gin.Context) {
	adminID, ok := currentAdminID(c)
	if !ok {
		response.Unauthorized(c, "未授权")
		return
	}
	var req CreateProductRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.BadRequest(c, "请求参数不正确")
		return
	}
	item, err := h.service.CreateProduct(c.Request.Context(), adminID, req)
	if err != nil {
		writeError(c, err)
		return
	}
	response.OK(c, item)
}

func (h *Handler) AdminUpdateProduct(c *gin.Context) {
	id, ok := parseID(c)
	if !ok {
		return
	}
	var req UpdateProductRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.BadRequest(c, "请求参数不正确")
		return
	}
	item, err := h.service.UpdateProduct(c.Request.Context(), id, req)
	if err != nil {
		writeError(c, err)
		return
	}
	response.OK(c, item)
}

func (h *Handler) AdminDeleteProduct(c *gin.Context) {
	id, ok := parseID(c)
	if !ok {
		return
	}
	if err := h.service.DeleteProduct(c.Request.Context(), id); err != nil {
		writeError(c, err)
		return
	}
	response.OK(c, gin.H{"message": "删除成功"})
}

func (h *Handler) AdminListOrders(c *gin.Context) {
	query := OrderListQuery{
		Status:  c.Query("status"),
		Keyword: c.Query("keyword"),
	}
	if userID, err := strconv.ParseUint(c.Query("user_id"), 10, 64); err == nil {
		query.UserID = userID
	}
	query.Page, query.PageSize = parsePagination(c)
	result, err := h.service.AdminListOrders(c.Request.Context(), query)
	if err != nil {
		response.RecordError(c, err)
		response.InternalServerError(c, "获取订单列表失败")
		return
	}
	response.OK(c, result)
}

func (h *Handler) AdminGetOrder(c *gin.Context) {
	id, ok := parseID(c)
	if !ok {
		return
	}
	item, err := h.service.AdminFindOrder(c.Request.Context(), id)
	if err != nil {
		writeError(c, err)
		return
	}
	response.OK(c, item)
}

func (h *Handler) AdminReceiveOrder(c *gin.Context) {
	id, ok := parseID(c)
	if !ok {
		return
	}
	var req AdminReceiveOrderRequest
	_ = c.ShouldBindJSON(&req)
	item, err := h.service.AdminReceiveOrder(c.Request.Context(), id, req.Remark)
	if err != nil {
		writeError(c, err)
		return
	}
	response.OK(c, item)
}

func (h *Handler) AdminCompleteOrder(c *gin.Context) {
	id, ok := parseID(c)
	if !ok {
		return
	}
	var req AdminCompleteOrderRequest
	_ = c.ShouldBindJSON(&req)
	item, err := h.service.AdminCompleteOrder(c.Request.Context(), id, req.Remark)
	if err != nil {
		writeError(c, err)
		return
	}
	response.OK(c, item)
}

func (h *Handler) AdminCancelOrder(c *gin.Context) {
	id, ok := parseID(c)
	if !ok {
		return
	}
	var req AdminCancelOrderRequest
	_ = c.ShouldBindJSON(&req)
	item, err := h.service.AdminCancelOrder(c.Request.Context(), id, req.Reason)
	if err != nil {
		writeError(c, err)
		return
	}
	response.OK(c, item)
}

func (h *Handler) AdminGetConfig(c *gin.Context) {
	item, err := h.service.GetConfig(c.Request.Context())
	if err != nil {
		response.RecordError(c, err)
		response.InternalServerError(c, "获取配置失败")
		return
	}
	response.OK(c, item)
}

func (h *Handler) AdminUpdateConfig(c *gin.Context) {
	var req UpdateConfigRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.BadRequest(c, "请求参数不正确")
		return
	}
	item, err := h.service.UpdateConfig(c.Request.Context(), req)
	if err != nil {
		response.RecordError(c, err)
		response.InternalServerError(c, "更新配置失败")
		return
	}
	response.OK(c, item)
}

func writeError(c *gin.Context, err error) {
	response.RecordError(c, err)
	switch {
	case errors.Is(err, ErrProductNotFound), errors.Is(err, ErrOrderNotFound):
		response.NotFound(c, err.Error())
	case errors.Is(err, ErrProductUnavailable):
		response.Error(c, 409, "product_unavailable", "商品不可购买")
	case errors.Is(err, ErrStockInsufficient):
		response.Error(c, 409, "stock_insufficient", "库存不足")
	case errors.Is(err, ErrOrderCannotPay):
		response.Error(c, 409, "order_cannot_pay", "订单无法支付")
	case errors.Is(err, ErrOrderCannotCancel):
		response.Error(c, 409, "order_cannot_cancel", "订单无法取消")
	case errors.Is(err, ErrOrderCannotReceive):
		response.Error(c, 409, "order_cannot_receive", "订单无法标记为接待中")
	case errors.Is(err, ErrOrderCannotComplete):
		response.Error(c, 409, "order_cannot_complete", "订单无法完成")
	case errors.Is(err, ErrInvalidRequest):
		response.BadRequest(c, "请求参数不正确")
	case errors.Is(err, ErrUnauthorized):
		response.Unauthorized(c, "未授权")
	default:
		msg := strings.TrimSpace(err.Error())
		if msg == "" {
			msg = "操作失败"
		}
		response.InternalServerError(c, msg)
	}
}

func parseID(c *gin.Context) (uint64, bool) {
	id, err := strconv.ParseUint(c.Param("id"), 10, 64)
	if err != nil || id == 0 {
		response.BadRequest(c, "ID不正确")
		return 0, false
	}
	return id, true
}

func parsePagination(c *gin.Context) (int, int) {
	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
	pageSize, _ := strconv.Atoi(c.DefaultQuery("page_size", "20"))
	if page < 1 {
		page = 1
	}
	if pageSize < 1 {
		pageSize = 20
	}
	if pageSize > 100 {
		pageSize = 100
	}
	return page, pageSize
}

func currentUserID(c *gin.Context) (uint64, bool) {
	value, ok := c.Get(middleware.ContextUserID)
	if !ok {
		return 0, false
	}
	id, ok := value.(uint64)
	return id, ok
}

func currentAdminID(c *gin.Context) (uint64, bool) {
	value, ok := c.Get(middleware.ContextAdminID)
	if !ok {
		return 0, false
	}
	id, ok := value.(uint64)
	return id, ok
}