package handlers

import (
	"goalfymax-admin/internal/models"
	"goalfymax-admin/internal/services"
	"goalfymax-admin/pkg/utils"
	"strconv"

	"github.com/gin-gonic/gin"
	"go.uber.org/zap"
)

// UserHandler 用户处理器
type UserHandler struct {
	userService services.UserService
	rbacService services.RBACService
	response    *utils.Response
	logger      *utils.Logger
}

// NewUserHandler 创建用户处理器
func NewUserHandler(userService services.UserService, rbacService services.RBACService, logger *utils.Logger) *UserHandler {
	return &UserHandler{
		userService: userService,
		rbacService: rbacService,
		response:    utils.NewResponse(),
		logger:      logger,
	}
}

// Create 创建用户
func (h *UserHandler) Create(c *gin.Context) {
	var req models.UserCreateRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		h.response.ValidateError(c, err)
		return
	}

	user, err := h.userService.Create(&req)
	if err != nil {
		h.logger.Error("创建用户失败", zap.Error(err))
		h.response.InternalServerError(c, err.Error())
		return
	}

	h.response.Success(c, user)
}

// GetByID 获取用户详情
func (h *UserHandler) GetByID(c *gin.Context) {
	idStr := c.Param("id")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		h.response.BadRequest(c, "无效的用户ID")
		return
	}

	user, err := h.userService.GetByID(uint(id))
	if err != nil {
		h.logger.Error("获取用户失败", zap.Error(err))
		h.response.InternalServerError(c, err.Error())
		return
	}

	h.response.Success(c, user)
}

// Update 更新用户
func (h *UserHandler) Update(c *gin.Context) {
	idStr := c.Param("id")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		h.response.BadRequest(c, "无效的用户ID")
		return
	}

	var req models.UserUpdateRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		h.response.ValidateError(c, err)
		return
	}

	user, err := h.userService.Update(uint(id), &req)
	if err != nil {
		h.logger.Error("更新用户失败", zap.Error(err))
		h.response.InternalServerError(c, err.Error())
		return
	}

	h.response.Success(c, user)
}

// Delete 删除用户
func (h *UserHandler) Delete(c *gin.Context) {
	idStr := c.Param("id")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		h.response.BadRequest(c, "无效的用户ID")
		return
	}

	err = h.userService.Delete(uint(id))
	if err != nil {
		h.logger.Error("删除用户失败", zap.Error(err))
		h.response.InternalServerError(c, err.Error())
		return
	}

	h.response.Success(c, gin.H{"message": "用户删除成功"})
}

// List 获取用户列表
func (h *UserHandler) List(c *gin.Context) {
	var req models.UserListRequest
	if err := c.ShouldBindQuery(&req); err != nil {
		h.response.ValidateError(c, err)
		return
	}

	users, total, err := h.userService.ListWithRoles(&req)
	if err != nil {
		h.logger.Error("获取用户列表失败", zap.Error(err))
		h.response.InternalServerError(c, err.Error())
		return
	}

	h.response.Success(c, gin.H{
		"users": users,
		"total": total,
		"page":  req.Page,
		"size":  req.Size,
	})
}

// UpdateStatus 更新用户状态
func (h *UserHandler) UpdateStatus(c *gin.Context) {
	idStr := c.Param("id")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		h.response.BadRequest(c, "无效的用户ID")
		return
	}

	var req struct {
		Status int `json:"status" binding:"required"`
	}
	if err := c.ShouldBindJSON(&req); err != nil {
		h.response.ValidateError(c, err)
		return
	}

	err = h.userService.UpdateStatus(uint(id), req.Status)
	if err != nil {
		h.logger.Error("更新用户状态失败", zap.Error(err))
		h.response.InternalServerError(c, err.Error())
		return
	}

	h.response.Success(c, gin.H{"message": "用户状态更新成功"})
}

// UpdateRoles 更新用户角色
func (h *UserHandler) UpdateRoles(c *gin.Context) {
	idStr := c.Param("id")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		h.response.BadRequest(c, "无效的用户ID")
		return
	}

	var req models.UserRoleAssignRequest
	req.UserID = uint(id)
	if err := c.ShouldBindJSON(&req); err != nil {
		h.response.ValidateError(c, err)
		return
	}

	// 现在用户只有一个角色，直接更新用户的role_id
	err = h.userService.UpdateRole(uint(id), req.RoleIDs[0])
	if err != nil {
		h.logger.Error("更新用户角色失败", zap.Error(err))
		h.response.InternalServerError(c, err.Error())
		return
	}

	h.response.Success(c, gin.H{"message": "用户角色更新成功"})
}

// GetUserRoles 获取用户角色
func (h *UserHandler) GetUserRoles(c *gin.Context) {
	idStr := c.Param("id")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		h.response.BadRequest(c, "无效的用户ID")
		return
	}

	// 现在用户只有一个角色，直接获取用户信息
	user, err := h.userService.GetByID(uint(id))
	if err != nil {
		h.logger.Error("获取用户信息失败", zap.Error(err))
		h.response.InternalServerError(c, err.Error())
		return
	}

	// 获取角色信息
	role, err := h.rbacService.GetRoleByID(user.RoleID)
	if err != nil {
		h.logger.Error("获取角色信息失败", zap.Error(err))
		h.response.InternalServerError(c, err.Error())
		return
	}

	h.response.Success(c, gin.H{"roles": []models.Role{*role}})
}

// GetUserPermissions 获取用户权限
func (h *UserHandler) GetUserPermissions(c *gin.Context) {
	idStr := c.Param("id")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		h.response.BadRequest(c, "无效的用户ID")
		return
	}

	permissions, err := h.rbacService.GetUserPermissionsResponse(uint(id))
	if err != nil {
		h.logger.Error("获取用户权限失败", zap.Error(err))
		h.response.InternalServerError(c, err.Error())
		return
	}

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

// CheckUserRole 检查用户当前系统角色
// GET /admin/users/check-role/:user_id
func (h *UserHandler) CheckUserRole(c *gin.Context) {
	userIDStr := c.Param("user_id")
	userID, err := strconv.Atoi(userIDStr)
	if err != nil {
		h.response.BadRequest(c, "无效的用户ID")
		return
	}

	isSystemAdmin, err := h.userService.CheckUserSystemRole(userID)
	if err != nil {
		h.logger.Error("检查用户系统角色失败", zap.Int("user_id", userID), zap.Error(err))
		h.response.InternalServerError(c, err.Error())
		return
	}

	currentRole := "custom"
	if isSystemAdmin {
		currentRole = "sys_admin"
	}

	h.response.Success(c, gin.H{
		"is_system_admin": isSystemAdmin,
		"current_role":    currentRole,
	})
}

// ChangeUserSystemRole 变更用户系统角色
// POST /admin/users/change-system-role
func (h *UserHandler) ChangeUserSystemRole(c *gin.Context) {
	var req struct {
		UserID     int    `json:"user_id" binding:"required"`
		SystemRole string `json:"system_role" binding:"required,oneof=sys_admin custom"`
	}

	if err := c.ShouldBindJSON(&req); err != nil {
		h.response.ValidateError(c, err)
		return
	}

	err := h.userService.ChangeUserSystemRole(req.UserID, req.SystemRole)
	if err != nil {
		h.logger.Error("变更用户系统角色失败", zap.Int("user_id", req.UserID), zap.String("system_role", req.SystemRole), zap.Error(err))
		h.response.InternalServerError(c, err.Error())
		return
	}

	h.response.Success(c, gin.H{"message": "角色变更成功"})
}