package controller

import (
	"strconv"

	"seeyon-filesystem/dto"
	"seeyon-filesystem/middleware"
	"seeyon-filesystem/model"
	"seeyon-filesystem/service"
	"seeyon-filesystem/utils"

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

// PermissionController 权限管理控制器
type PermissionController struct {
	permService *service.PermissionService
}

func NewPermissionController() *PermissionController {
	return &PermissionController{
		permService: service.NewPermissionService(),
	}
}

// ========== 角色管理 ==========

// ListRoles 获取所有角色
// GET /api/admin/roles
func (c *PermissionController) ListRoles(ctx *gin.Context) {
	roles, err := c.permService.ListRoles()
	if err != nil {
		utils.ServerError(ctx, "获取角色列表失败")
		return
	}

	vos := make([]dto.RoleVO, 0, len(roles))
	for _, r := range roles {
		perms := make([]dto.PermissionVO, 0, len(r.Permissions))
		for _, p := range r.Permissions {
			perms = append(perms, dto.PermissionVO{
				ID:          p.ID,
				Code:        p.Code,
				Name:        p.Name,
				Resource:    p.Resource,
				Action:      p.Action,
				Description: p.Description,
			})
		}
		vos = append(vos, dto.RoleVO{
			ID:          r.ID,
			Name:        r.Name,
			DisplayName: r.DisplayName,
			Description: r.Description,
			IsSystem:    r.IsSystem,
			Status:      r.Status,
			Permissions: perms,
		})
	}

	utils.Success(ctx, vos)
}

// CreateRole 创建角色
// POST /api/admin/roles
func (c *PermissionController) CreateRole(ctx *gin.Context) {
	var req dto.RoleCreateRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.BadRequest(ctx, "参数错误: "+err.Error())
		return
	}

	role := &model.Role{
		Name:        req.Name,
		DisplayName: req.DisplayName,
		Description: req.Description,
	}

	if err := c.permService.CreateRole(role); err != nil {
		utils.BadRequest(ctx, err.Error())
		return
	}

	utils.SuccessWithMessage(ctx, "角色创建成功", nil)
}

// UpdateRole 更新角色
// PUT /api/admin/roles/:id
func (c *PermissionController) UpdateRole(ctx *gin.Context) {
	id, err := strconv.ParseUint(ctx.Param("id"), 10, 64)
	if err != nil {
		utils.BadRequest(ctx, "无效的角色ID")
		return
	}

	var req dto.RoleUpdateRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.BadRequest(ctx, "参数错误: "+err.Error())
		return
	}

	role := &model.Role{
		ID:          id,
		DisplayName: req.DisplayName,
		Description: req.Description,
	}

	if err := c.permService.UpdateRole(role); err != nil {
		utils.BadRequest(ctx, err.Error())
		return
	}

	utils.SuccessWithMessage(ctx, "更新成功", nil)
}

// DeleteRole 删除角色
// DELETE /api/admin/roles/:id
func (c *PermissionController) DeleteRole(ctx *gin.Context) {
	id, err := strconv.ParseUint(ctx.Param("id"), 10, 64)
	if err != nil {
		utils.BadRequest(ctx, "无效的角色ID")
		return
	}

	if err := c.permService.DeleteRole(id); err != nil {
		utils.BadRequest(ctx, err.Error())
		return
	}

	utils.SuccessWithMessage(ctx, "删除成功", nil)
}

// SetRolePermissions 设置角色权限
// PUT /api/admin/roles/:id/permissions
func (c *PermissionController) SetRolePermissions(ctx *gin.Context) {
	roleID, err := strconv.ParseUint(ctx.Param("id"), 10, 64)
	if err != nil {
		utils.BadRequest(ctx, "无效的角色ID")
		return
	}

	var req dto.SetRolePermissionsRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.BadRequest(ctx, "参数错误: "+err.Error())
		return
	}

	if err := c.permService.SetRolePermissions(roleID, req.PermissionIDs); err != nil {
		utils.BadRequest(ctx, err.Error())
		return
	}

	utils.SuccessWithMessage(ctx, "权限设置成功", nil)
}

// ========== 权限管理 ==========

// ListPermissions 获取所有权限
// GET /api/admin/permissions
func (c *PermissionController) ListPermissions(ctx *gin.Context) {
	perms, err := c.permService.ListPermissions()
	if err != nil {
		utils.ServerError(ctx, "获取权限列表失败")
		return
	}

	vos := make([]dto.PermissionVO, 0, len(perms))
	for _, p := range perms {
		vos = append(vos, dto.PermissionVO{
			ID:          p.ID,
			Code:        p.Code,
			Name:        p.Name,
			Resource:    p.Resource,
			Action:      p.Action,
			Description: p.Description,
		})
	}

	utils.Success(ctx, vos)
}

// CreatePermission 创建权限
// POST /api/admin/permissions
func (c *PermissionController) CreatePermission(ctx *gin.Context) {
	var req dto.PermissionCreateRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.BadRequest(ctx, "参数错误: "+err.Error())
		return
	}

	perm := &model.Permission{
		Code:        req.Code,
		Name:        req.Name,
		Resource:    req.Resource,
		Action:      req.Action,
		Description: req.Description,
	}

	if err := c.permService.CreatePermission(perm); err != nil {
		utils.BadRequest(ctx, err.Error())
		return
	}

	utils.SuccessWithMessage(ctx, "权限创建成功", nil)
}

// DeletePermission 删除权限
// DELETE /api/admin/permissions/:id
func (c *PermissionController) DeletePermission(ctx *gin.Context) {
	id, err := strconv.ParseUint(ctx.Param("id"), 10, 64)
	if err != nil {
		utils.BadRequest(ctx, "无效的权限ID")
		return
	}

	if err := c.permService.DeletePermission(id); err != nil {
		utils.BadRequest(ctx, err.Error())
		return
	}

	utils.SuccessWithMessage(ctx, "删除成功", nil)
}

// ========== 用户角色管理 ==========

// SetUserRoles 设置用户角色
// PUT /api/admin/users/:id/roles
func (c *PermissionController) SetUserRoles(ctx *gin.Context) {
	userID, err := strconv.ParseUint(ctx.Param("id"), 10, 64)
	if err != nil {
		utils.BadRequest(ctx, "无效的用户ID")
		return
	}

	var req dto.SetUserRolesRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.BadRequest(ctx, "参数错误: "+err.Error())
		return
	}

	if err := c.permService.SetUserRoles(userID, req.RoleIDs); err != nil {
		utils.BadRequest(ctx, err.Error())
		return
	}

	utils.SuccessWithMessage(ctx, "角色设置成功", nil)
}

// GetUserPermissions 获取当前用户的权限信息
// GET /api/auth/permissions
func (c *PermissionController) GetUserPermissions(ctx *gin.Context) {
	userID := middleware.GetCurrentUserID(ctx)
	if userID == 0 {
		utils.Unauthorized(ctx, "未登录")
		return
	}

	// 获取用户角色
	roles, err := c.permService.GetUserRoles(userID)
	if err != nil {
		utils.ServerError(ctx, "获取角色失败")
		return
	}

	// 获取用户权限
	permissions, err := c.permService.GetUserPermissions(userID)
	if err != nil {
		utils.ServerError(ctx, "获取权限失败")
		return
	}

	roleVOs := make([]dto.RoleVO, 0, len(roles))
	for _, r := range roles {
		roleVOs = append(roleVOs, dto.RoleVO{
			ID:          r.ID,
			Name:        r.Name,
			DisplayName: r.DisplayName,
		})
	}

	utils.Success(ctx, dto.UserPermissionVO{
		Roles:       roleVOs,
		Permissions: permissions,
	})
}