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"
)

// RoleHandler 角色处理器
type RoleHandler struct {
	roleService services.RoleService
	rbacService services.RBACService
	response    *utils.Response
	logger      *utils.Logger
}

// NewRoleHandler 创建角色处理器
func NewRoleHandler(roleService services.RoleService, rbacService services.RBACService, logger *utils.Logger) *RoleHandler {
	return &RoleHandler{
		roleService: roleService,
		rbacService: rbacService,
		response:    utils.NewResponse(),
		logger:      logger,
	}
}

// Create 创建角色
func (h *RoleHandler) Create(c *gin.Context) {
	var req models.RoleCreateRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		h.response.ValidateError(c, err)
		return
	}

	role, err := h.roleService.Create(&req)
	if err != nil {
		h.logger.Error("创建角色失败", zap.Error(err))
		h.response.InternalServerError(c, err.Error())
		return
	}

	h.response.Success(c, role)
}

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

	role, err := h.roleService.GetByID(uint(id))
	if err != nil {
		h.logger.Error("获取角色失败", zap.Error(err))
		h.response.InternalServerError(c, err.Error())
		return
	}

	h.response.Success(c, role)
}

// Update 更新角色
func (h *RoleHandler) 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.RoleUpdateRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		h.response.ValidateError(c, err)
		return
	}

	role, err := h.roleService.Update(uint(id), &req)
	if err != nil {
		h.logger.Error("更新角色失败", zap.Error(err))
		h.response.InternalServerError(c, err.Error())
		return
	}

	h.response.Success(c, role)
}

// Delete 删除角色
func (h *RoleHandler) 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.roleService.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 *RoleHandler) List(c *gin.Context) {
	var req models.RoleListRequest
	if err := c.ShouldBindQuery(&req); err != nil {
		h.response.ValidateError(c, err)
		return
	}

	roles, total, err := h.roleService.List(&req)
	if err != nil {
		h.logger.Error("获取角色列表失败", zap.Error(err))
		h.response.InternalServerError(c, err.Error())
		return
	}

	// 为每个角色获取页面权限
	rolesWithPermissions := make([]gin.H, len(roles))
	for i, role := range roles {
		// 获取角色的页面权限
		pages, err := h.rbacService.GetRolePagePermissions(role.ID)
		if err != nil {
			h.logger.Warn("获取角色页面权限失败", zap.Uint("roleId", role.ID), zap.Error(err))
			pages = []models.Page{} // 如果获取失败，返回空数组
		}

		rolesWithPermissions[i] = gin.H{
			"id":          role.ID,
			"name":        role.Name,
			"level":       role.Level,
			"description": role.Description,
			"isDefault":   role.IsDefault,
			"createdAt":   role.CreatedAt,
			"updatedAt":   role.UpdatedAt,
			"deletedAt":   role.DeletedAt,
			"pages":       pages, // 添加页面权限信息
		}
	}

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

// UpdateStatus 更新角色状态
func (h *RoleHandler) 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.roleService.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": "角色状态更新成功"})
}

// UpdatePermissions 更新角色权限
func (h *RoleHandler) UpdatePermissions(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.RolePagePermissionAssignRequest
	req.RoleID = uint(id)
	if err := c.ShouldBindJSON(&req); err != nil {
		h.response.ValidateError(c, err)
		return
	}

	err = h.rbacService.AssignRolePagePermissions(&req)
	if err != nil {
		h.logger.Error("更新角色权限失败", zap.Error(err))
		h.response.InternalServerError(c, err.Error())
		return
	}

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

// GetRolePermissions 获取角色权限
func (h *RoleHandler) GetRolePermissions(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.GetRolePagePermissions(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})
}