package handler

import (
	"net/http"
	"web-training/internal/model"
	"web-training/internal/service"
	"web-training/pkg/auth"
	"web-training/internal/utils"

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

// UserHandler 用户处理器
type UserHandler struct {
	userService *service.UserService
	jwtService  *auth.JWTService
}

// NewUserHandler 创建用户处理器
func NewUserHandler(db interface{}, jwtService *auth.JWTService) *UserHandler {
	// 这里应该注入UserService，暂时简化处理
	userService := service.NewUserService(db)
	return &UserHandler{
		userService: userService,
		jwtService:  jwtService,
	}
}

// Register 用户注册
// @Summary 用户注册
// @Tags 用户管理
// @Accept json
// @Produce json
// @Param user body model.CreateUserRequest true "用户信息"
// @Success 201 {object} utils.APIResponse{data=model.UserResponse}
// @Failure 400 {object} utils.APIResponse
// @Failure 500 {object} utils.APIResponse
// @Router /api/v1/register [post]
func (h *UserHandler) Register(c *gin.Context) {
	var req model.CreateUserRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		utils.ErrorResponse(c, http.StatusBadRequest, "请求参数错误", err.Error())
		return
	}

	user, err := h.userService.CreateUser(req)
	if err != nil {
		utils.ErrorResponse(c, http.StatusInternalServerError, "注册失败", err.Error())
		return
	}

	utils.SuccessResponse(c, http.StatusCreated, "注册成功", user.ToResponse())
}

// Login 用户登录
// @Summary 用户登录
// @Tags 用户管理
// @Accept json
// @Produce json
// @Param credentials body model.LoginRequest true "登录凭证"
// @Success 200 {object} utils.APIResponse{data=model.LoginResponse}
// @Failure 400 {object} utils.APIResponse
// @Failure 401 {object} utils.APIResponse
// @Failure 500 {object} utils.APIResponse
// @Router /api/v1/login [post]
func (h *UserHandler) Login(c *gin.Context) {
	var req model.LoginRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		utils.ErrorResponse(c, http.StatusBadRequest, "请求参数错误", err.Error())
		return
	}

	user, err := h.userService.Authenticate(req.Username, req.Password)
	if err != nil {
		utils.ErrorResponse(c, http.StatusUnauthorized, "用户名或密码错误", err.Error())
		return
	}

	// 生成JWT令牌
	token, err := h.jwtService.GenerateToken(user.ID, []string{user.Role})
	if err != nil {
		utils.ErrorResponse(c, http.StatusInternalServerError, "生成令牌失败", err.Error())
		return
	}

	loginResp := model.LoginResponse{
		Token: token,
		User:  user.ToResponse(),
	}

	utils.SuccessResponse(c, http.StatusOK, "登录成功", loginResp)
}

// ListUsers 获取用户列表
// @Summary 获取用户列表
// @Tags 用户管理
// @Accept json
// @Produce json
// @Param page query int false "页码" default(1)
// @Param page_size query int false "每页数量" default(10)
// @Param search query string false "搜索关键词"
// @Success 200 {object} utils.APIResponse{data=[]model.UserResponse,meta=utils.MetaInfo}
// @Failure 401 {object} utils.APIResponse
// @Failure 500 {object} utils.APIResponse
// @Router /api/v1/users [get]
func (h *UserHandler) ListUsers(c *gin.Context) {
	page, pageSize := utils.GetPaginationParams(c)
	search := c.Query("search")

	users, total, err := h.userService.ListUsers(page, pageSize, search)
	if err != nil {
		utils.ErrorResponse(c, http.StatusInternalServerError, "获取用户列表失败", err.Error())
		return
	}

	// 转换为响应格式
	userResponses := make([]model.UserResponse, len(users))
	for i, user := range users {
		userResponses[i] = user.ToResponse()
	}

	utils.PaginatedResponse(c, http.StatusOK, "获取成功", userResponses, page, pageSize, total)
}

// GetUser 获取用户详情
// @Summary 获取用户详情
// @Tags 用户管理
// @Accept json
// @Produce json
// @Param id path int true "用户ID"
// @Success 200 {object} utils.APIResponse{data=model.UserResponse}
// @Failure 400 {object} utils.APIResponse
// @Failure 404 {object} utils.APIResponse
// @Failure 500 {object} utils.APIResponse
// @Router /api/v1/users/{id} [get]
func (h *UserHandler) GetUser(c *gin.Context) {
	id, err := utils.GetIDParam(c)
	if err != nil {
		utils.ErrorResponse(c, http.StatusBadRequest, "无效的用户ID", err.Error())
		return
	}

	user, err := h.userService.GetUserByID(id)
	if err != nil {
		utils.ErrorResponse(c, http.StatusNotFound, "用户不存在", err.Error())
		return
	}

	utils.SuccessResponse(c, http.StatusOK, "获取成功", user.ToResponse())
}

// UpdateUser 更新用户信息
// @Summary 更新用户信息
// @Tags 用户管理
// @Accept json
// @Produce json
// @Param id path int true "用户ID"
// @Param user body model.UpdateUserRequest true "用户信息"
// @Success 200 {object} utils.APIResponse{data=model.UserResponse}
// @Failure 400 {object} utils.APIResponse
// @Failure 404 {object} utils.APIResponse
// @Failure 500 {object} utils.APIResponse
// @Router /api/v1/users/{id} [put]
func (h *UserHandler) UpdateUser(c *gin.Context) {
	id, err := utils.GetIDParam(c)
	if err != nil {
		utils.ErrorResponse(c, http.StatusBadRequest, "无效的用户ID", err.Error())
		return
	}

	var req model.UpdateUserRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		utils.ErrorResponse(c, http.StatusBadRequest, "请求参数错误", err.Error())
		return
	}

	user, err := h.userService.UpdateUser(id, req)
	if err != nil {
		utils.ErrorResponse(c, http.StatusInternalServerError, "更新用户失败", err.Error())
		return
	}

	utils.SuccessResponse(c, http.StatusOK, "更新成功", user.ToResponse())
}

// DeleteUser 删除用户
// @Summary 删除用户
// @Tags 用户管理
// @Accept json
// @Produce json
// @Param id path int true "用户ID"
// @Success 200 {object} utils.APIResponse
// @Failure 400 {object} utils.APIResponse
// @Failure 404 {object} utils.APIResponse
// @Failure 500 {object} utils.APIResponse
// @Router /api/v1/users/{id} [delete]
func (h *UserHandler) DeleteUser(c *gin.Context) {
	id, err := utils.GetIDParam(c)
	if err != nil {
		utils.ErrorResponse(c, http.StatusBadRequest, "无效的用户ID", err.Error())
		return
	}

	err = h.userService.DeleteUser(id)
	if err != nil {
		utils.ErrorResponse(c, http.StatusInternalServerError, "删除用户失败", err.Error())
		return
	}

	utils.SuccessResponse(c, http.StatusOK, "删除成功", nil)
}