package user

import (
	coupon2 "cls-server/internal/application/coupon"
	gift_log2 "cls-server/internal/application/gift_log"
	"cls-server/internal/application/user"
	middleware "cls-server/internal/infrastructure/middleware/auth"
	"cls-server/internal/interfaces"
	"cls-server/pkg/logger"
	"cls-server/pkg/util/page"
	"fmt"
	"github.com/gin-gonic/gin"
	"net/http"
	"strconv"
)

// UserHandler 处理请求阶段的逻辑
type UserHandler struct {
	service        *user.UserService
	authMiddleware *middleware.AuthMiddleware
	log            logger.Logger
}

var _ interfaces.Handler = (*UserHandler)(nil)

func NewUserHandler(userService *user.UserService, authMiddleware *middleware.AuthMiddleware, logger logger.New) *UserHandler {
	return &UserHandler{
		service:        userService,
		authMiddleware: authMiddleware,
		log:            logger("cls:interfaces:user"),
	}
}

func (u *UserHandler) RegisterRouters(router gin.IRouter) {
	userGroup := router.Group("/user")
	{
		userGroup.GET("/page", u.listUsers) // 获取用户列表
		userGroup.POST("/give-gift", u.gift)
		userGroup.POST("/give-coupon", u.coupon)
		userGroup.POST("/disable/:uid", u.disable) // 禁用用户
		userGroup.POST("/enable/:uid", u.enable)   // 启用用户
	}
}

func (u *UserHandler) gift(c *gin.Context) {
	giftLog := &gift_log2.GiftLogDto{}
	err := c.ShouldBindJSON(giftLog)
	if err != nil {
		u.log.Error(err)
		return
	}
	err = u.service.GiveGift(giftLog)
	if err != nil {
		c.AbortWithStatus(http.StatusInternalServerError)
	} else {
		c.AbortWithStatus(http.StatusOK)
	}
}

func (u *UserHandler) coupon(c *gin.Context) {

	uc := &coupon2.CouponDto{}
	err := c.ShouldBindJSON(uc)
	if err != nil {
		u.log.Error(err)
		c.AbortWithStatus(http.StatusBadRequest)
		return
	}
	fmt.Println("发放优惠券", uc)
	err = u.service.GiveCoupon(uc)
	if err != nil {
		c.AbortWithStatus(http.StatusInternalServerError)
	} else {
		c.AbortWithStatus(http.StatusOK)
	}
}

// listUsers 获取用户列表
func (u *UserHandler) listUsers(c *gin.Context) {
	p := &page.Page{}
	if err := c.ShouldBindQuery(p); err != nil {
		u.log.Errorf("解析用户列表分页参数失败: %v", err)
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	if err := u.service.ListUsers(p, map[string]string{
		"search_like_username": c.Query("search_like_name")}); err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	c.JSON(http.StatusOK, p)
}

// disable 禁用用户
func (u *UserHandler) disable(c *gin.Context) {
	uid, err := strconv.ParseInt(c.Param("uid"), 10, 64)
	if err != nil {
		u.log.Error(err.Error())
		c.AbortWithStatus(http.StatusInternalServerError)
		return
	}
	if err := u.service.DisableUser(uint64(uid)); err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	c.JSON(http.StatusOK, gin.H{"message": "用户已禁用"})
}

// enable 启用用户
func (u *UserHandler) enable(c *gin.Context) {
	uid, err := strconv.ParseInt(c.Param("uid"), 10, 64)
	if err != nil {
		u.log.Error(err.Error())
		c.AbortWithStatus(http.StatusInternalServerError)
		return
	}
	if err := u.service.EnableUser(uint64(uid)); err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	c.JSON(http.StatusOK, gin.H{"message": "用户已启用"})
}