package com.example.demo.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 自定义权限控制注解
 * 用于标记在方法上，声明访问该方法所需要的权限。
 */
@Target(ElementType.METHOD) // 1. 元注解：声明此注解只能用于方法上
@Retention(RetentionPolicy.RUNTIME) // 2. 元注解：声明此注解在运行时依然可见，AOP 才能读取到它
public @interface RequiresPermission {

    /**
     * 定义一个名为 value 的属性，用于接收所需的权限编码。
     * 这是注解的默认属性，在使用时可以直接写 @RequiresPermission("user: delete")，
     * 而无需写 @RequiresPermission(value = "user: delete")。
     * @return 所需的权限编码字符串
     */
    String value();
}

package com.example.demo.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.time.LocalDateTime;

@Data
@TableName("sys_user")
public class User {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String username;
    private String password;
    private LocalDateTime createTime;
}

package com.example.demo.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@Data
@TableName("sys_role")
public class Role {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String roleCode;
    private String roleName;
    private String description;
}

package com.example.demo.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@Data
@TableName("sys_permission")
public class Permission {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String permissionCode;
    private String permissionName;
    private String resourceType;
}

package com.example.demo.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@Data
@TableName("sys_user_role")
public class UserRole {
    @TableId(type = IdType.AUTO)
    private Long id;
    private Long userId;
    private Long roleId;
}

package com.example.demo.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@Data
@TableName("sys_role_permission")
public class RolePermission {
    @TableId(type = IdType.AUTO)
    private Long id;
    private Long roleId;
    private Long permissionId;
}

package com.example.demo.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.demo.entity.User;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface UserMapper extends BaseMapper<User> {
}

package com.example.demo.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.demo.entity.Role;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface RoleMapper extends BaseMapper<Role> {
}

package com.example.demo.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.demo.entity.Permission;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import java.util.List;

@Mapper
public interface PermissionMapper extends BaseMapper<Permission> {

    /**
     * 根据用户 ID 查询该用户拥有的所有权限编码
     * 这是一个多表关联查询，需要连接 user_role、role_permission、permission 三张表
     */
    @Select("SELECT DISTINCT p.permission_code " +
            "FROM sys_permission p " +
            "INNER JOIN sys_role_permission rp ON p.id = rp.permission_id " +
            "INNER JOIN sys_user_role ur ON rp.role_id = ur.role_id " +
            "WHERE ur.user_id = #{userId}")
    List<String> selectPermissionsByUserId(@Param("userId") Long userId);
}

package com.example.demo.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.demo.entity.UserRole;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface UserRoleMapper extends BaseMapper<UserRole> {
}

package com.example.demo.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.demo.entity.RolePermission;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface RolePermissionMapper extends BaseMapper<RolePermission> {
}

package com.example.demo.aspect;

import com.example.demo.annotation.RequiresPermission;
import com.example.demo.mapper.PermissionMapper;
import com.example.demo.mapper.UserMapper;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect      // 1. 声明这是一个切面类
@Component   // 2. 将其注册为 Spring Bean，交由容器管理
@Slf4j       // 3. Lombok 注解，提供日志功能
@RequiredArgsConstructor // 4. Lombok 注解，为 final 字段生成构造函数，用于依赖注入
public class PermissionCheckAspect {

    // 依赖注入 UserMapper，用于查询用户信息
    private final UserMapper userMapper;

    // 依赖注入 PermissionMapper，用于查询用户权限
    private final PermissionMapper permissionMapper;

    /**
     * 定义前置通知，切点表达式为 @annotation(requiresPermission)。
     * - @annotation(...)：这是切点指示符，表示匹配那些被指定注解标记的方法。
     * - requiresPermission：这是参数名，Spring AOP 会将匹配到的注解对象本身，注入到这个参数中。
     * 这种写法极为强大，让我们可以在通知方法内部直接获取到注解实例及其属性值。
     */
    @Before("@annotation(requiresPermission)")
    public void checkPermission(JoinPoint joinPoint, RequiresPermission requiresPermission) {
        log.info("====== 进入 AOP 权限校验 ======");

        // 权限校验逻辑将在下面实现
    }
}

// 在 PermissionCheckAspect.java 的 checkPermission 方法内添加以下逻辑

// 1. 从 AOP 的上下文中获取当前 HTTP 请求对象
ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
if (attributes == null) {
    // 如果不是在 HTTP 请求上下文中（例如，执行定时任务），则直接跳过校验
    log.warn("非 HTTP 请求上下文，跳过权限校验");
    return;
}
HttpServletRequest request = attributes.getRequest();

// 2. 模拟从请求头获取当前登录用户的 ID
// 在真实的企业级项目中，用户 ID 通常从 JWT (JSON Web Token) 或分布式 Session 中解析得到
String userIdStr = request.getHeader("X-User-Id");
if (userIdStr == null || userIdStr.isEmpty()) {
    // 如果请求头中没有用户信息，说明用户未登录，直接抛出异常
    log.error("权限校验失败：请求头缺少 X-User-Id");
    throw new RuntimeException("401 Unauthorized: 请求头缺少 X-User-Id，请先登录");
}

Long userId = Long.valueOf(userIdStr);
log.info("当前请求用户 ID: {}", userId);

// 接着上面的代码，继续在 checkPermission 方法内完善

// 3. 根据用户 ID 从数据库查询用户信息
User user = userMapper.selectById(userId);
if (user == null) {
    log.error("权限校验失败：用户不存在，ID: {}", userId);
    throw new RuntimeException("404 Not Found: 用户不存在，ID: " + userId);
}

log.info("查询到用户：{}", user.getUsername());

// 4. 查询该用户拥有的所有权限编码
// 这里调用我们在 PermissionMapper 中定义的多表关联查询方法
List<String> userPermissions = permissionMapper.selectPermissionsByUserId(userId);

log.info("用户 {} 拥有的权限列表: {}", user.getUsername(), userPermissions);

// 5. 从注解实例中获取接口要求的目标权限
String requiredPermission = requiresPermission.value();

log.info("目标接口需要的权限: {}", requiredPermission);

// 6. 核心校验逻辑：检查用户的权限列表中是否包含所需权限
if (userPermissions == null || !userPermissions.contains(requiredPermission)) {
    // 如果用户不具备所需权限，抛出运行时异常
    // Spring MVC 的全局异常处理器会捕获此异常，并向前端返回一个 HTTP 403 Forbidden 错误
    log.error("权限校验失败：用户 {} 缺少权限 {}", user.getUsername(), requiredPermission);
    throw new RuntimeException("403 Forbidden: 权限不足，需要权限: " + requiredPermission);
}

log.info("====== 权限校验通过！用户 {} 拥有权限 {} ======", user.getUsername(), requiredPermission);

package com.example.demo.aspect;

import com.example.demo.annotation.RequiresPermission;
import com.example.demo.entity.User;
import com.example.demo.mapper.PermissionMapper;
import com.example.demo.mapper.UserMapper;
import jakarta.servlet.http.HttpServletRequest;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import java.util.List;

@Aspect      // 1. 声明这是一个切面类
@Component   // 2. 将其注册为 Spring Bean，交由容器管理
@Slf4j       // 3. Lombok 注解，提供日志功能
@RequiredArgsConstructor // 4. Lombok 注解，为 final 字段生成构造函数，用于依赖注入
public class PermissionCheckAspect {

    // 依赖注入 UserMapper，用于查询用户信息
    private final UserMapper userMapper;

    // 依赖注入 PermissionMapper，用于查询用户权限
    private final PermissionMapper permissionMapper;

    /**
     * 定义前置通知，切点表达式为 @annotation(requiresPermission)。
     * - @annotation(...)：这是切点指示符，表示匹配那些被指定注解标记的方法。
     * - requiresPermission：这是参数名，Spring AOP 会将匹配到的注解对象本身，注入到这个参数中。
     * 这种写法极为强大，让我们可以在通知方法内部直接获取到注解实例及其属性值。
     */
    @Before("@annotation(requiresPermission)")
    public void checkPermission(JoinPoint joinPoint, RequiresPermission requiresPermission) {
        log.info("====== 进入 AOP 权限校验 ======");

        // 1. 从 AOP 的上下文中获取当前 HTTP 请求对象
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        if (attributes == null) {
            // 如果不是在 HTTP 请求上下文中（例如，执行定时任务），则直接跳过校验
            log.warn("非 HTTP 请求上下文，跳过权限校验");
            return;
        }
        HttpServletRequest request = attributes.getRequest();
        // 2. 模拟从请求头获取当前登录用户的 ID
        // 在真实的企业级项目中，用户 ID 通常从 JWT (JSON Web Token) 或分布式 Session 中解析得到
        String userIdStr = request.getHeader("X-User-Id");
        if (userIdStr == null || userIdStr.isEmpty()) {
            // 如果请求头中没有用户信息，说明用户未登录，直接抛出异常
            log.error("权限校验失败：请求头缺少 X-User-Id");
            throw new RuntimeException("401 Unauthorized: 请求头缺少 X-User-Id，请先登录");
        }
        Long userId = Long.valueOf(userIdStr);
        log.info("当前请求用户 ID: {}", userId);

        // 3. 根据用户 ID 从数据库查询用户信息
        User user = userMapper.selectById(userId);
        if (user == null) {
            log.error("权限校验失败：用户不存在，ID: {}", userId);
            throw new RuntimeException("404 Not Found: 用户不存在，ID: " + userId);
        }
        log.info("查询到用户：{}", user.getUsername());
        // 4. 查询该用户拥有的所有权限编码
        // 这里调用我们在 PermissionMapper 中定义的多表关联查询方法
        List<String> userPermissions = permissionMapper.selectPermissionsByUserId(userId);
        log.info("用户 {} 拥有的权限列表: {}", user.getUsername(), userPermissions);

        // 5. 从注解实例中获取接口要求的目标权限
        String requiredPermission = requiresPermission.value();

        log.info("目标接口需要的权限: {}", requiredPermission);

        // 6. 核心校验逻辑：检查用户的权限列表中是否包含所需权限
        if (userPermissions == null || !userPermissions.contains(requiredPermission)) {
            // 如果用户不具备所需权限，抛出运行时异常
            // Spring MVC 的全局异常处理器会捕获此异常，并向前端返回一个 HTTP 403 Forbidden 错误
            log.error("权限校验失败：用户 {} 缺少权限 {}", user.getUsername(), requiredPermission);
            throw new RuntimeException("403 Forbidden: 权限不足，需要权限: " + requiredPermission);
        }
        log.info("====== 权限校验通过！用户 {} 拥有权限 {} ======", user.getUsername(), requiredPermission);

    }
}

package com.example.demo.controller;

import com.example.demo.annotation.RequiresPermission;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/admin")
public class AdminController {

    @GetMapping("/delete-user")
    @RequiresPermission("user:delete") // 声明：需要 "user: delete" 权限才能访问
    public String deleteUser() {
        // 这段代码只有在 AOP 权限校验通过后，才有机会执行
        return "【管理员专属】用户删除成功！";
    }

    @GetMapping("/delete-data")
    @RequiresPermission("data:delete") // 声明：需要 "data: delete" 权限才能访问
    public String deleteData() {
        return "【管理员专属】敏感数据删除成功！";
    }

    @GetMapping("/view-user")
    @RequiresPermission("user:view") // 声明：需要 "user: view" 权限才能访问
    public String viewUser() {
        return "【普通用户可访问】用户信息查看成功。";
    }

    @GetMapping("/view-data")
    @RequiresPermission("data:view") // 声明：需要 "data: view" 权限才能访问
    public String viewData() {
        return "【普通用户可访问】数据查看成功。";
    }

    @GetMapping("/public-info")
    // 此接口没有注解，任何人（只要提供了合法的 X-User-Id）都可以访问
    public String getPublicInfo() {
        return "这是一个公开接口，无需特定权限。";
    }
}

package com.example.demo.exception;

import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

import java.util.HashMap;
import java.util.Map;

/**
 * 全局异常处理器
 * 捕获应用中抛出的异常，返回统一格式的错误响应
 */
@RestControllerAdvice
@Slf4j
public class GlobalExceptionHandler {

    /**
     * 处理运行时异常
     * 根据异常消息中的状态码前缀，返回相应的 HTTP 状态码
     */
    @ExceptionHandler(RuntimeException.class)
    public ResponseEntity<Map<String, Object>> handleRuntimeException(RuntimeException e) {
        log.error("捕获到运行时异常: {}", e.getMessage());

        String message = e.getMessage();
        HttpStatus status = HttpStatus.INTERNAL_SERVER_ERROR;

        // 根据异常消息判断 HTTP 状态码
        if (message != null) {
            if (message.startsWith("401")) {
                status = HttpStatus.UNAUTHORIZED; // 401 未认证
            } else if (message.startsWith("403")) {
                status = HttpStatus.FORBIDDEN; // 403 权限不足
            } else if (message.startsWith("404")) {
                status = HttpStatus.NOT_FOUND; // 404 资源不存在
            }
        }

        // 构建统一的错误响应格式
        Map<String, Object> errorResponse = new HashMap<>();
        errorResponse.put("success", false);
        errorResponse.put("code", status.value());
        errorResponse.put("message", message);
        errorResponse.put("timestamp", System.currentTimeMillis());

        return new ResponseEntity<>(errorResponse, status);
    }
}

package com.example.demo.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 自定义权限控制注解（增强版）
 * 支持多权限校验和逻辑关系配置
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RequiresPermission {

    /**
     * 所需的权限列表
     * 当只有一个权限时，可以直接写 @RequiresPermission("user: delete")
     * 当有多个权限时，写 @RequiresPermission({"user: view", "user: edit"})
     */
    String[] value();

    /**
     * 权限逻辑关系
     * AND: 必须拥有所有权限
     * OR: 拥有任意一个权限即可
     */
    LogicalOperator logical() default LogicalOperator.AND;

    /**
     * 权限逻辑操作符枚举
     */
    enum LogicalOperator {
        AND, // 并且（所有权限都需要）
        OR   // 或者（任意一个权限即可）
    }
}

// 在 PermissionCheckAspect.java 的 checkPermission 方法中修改权限校验部分

// 5. 获取接口要求的权限列表和逻辑关系
String[] requiredPermissions = requiresPermission.value();
RequiresPermission.LogicalOperator logical = requiresPermission.logical();

log.info("目标接口需要的权限: {}, 逻辑关系: {}",
         String.join(", ", requiredPermissions), logical);

// 6. 根据逻辑关系进行权限校验
boolean hasPermission = false;

if (logical == RequiresPermission.LogicalOperator.AND) {
    // AND 逻辑：必须拥有所有权限
    hasPermission = userPermissions != null &&
                    userPermissions.containsAll(java.util.Arrays.asList(requiredPermissions));
} else {
    // OR 逻辑：拥有任意一个权限即可
    if (userPermissions != null) {
        for (String required : requiredPermissions) {
            if (userPermissions.contains(required)) {
                hasPermission = true;
                break;
            }
        }
    }
}

if (!hasPermission) {
    log.error("权限校验失败：用户 {} 缺少权限 {}",
              user.getUsername(), String.join(" " + logical + " ", requiredPermissions));
    throw new RuntimeException("403 Forbidden: 权限不足，需要权限: " +
                               String.join(" " + logical + " ", requiredPermissions));
}

log.info("====== 权限校验通过！======");

@RestController
@RequestMapping("/document")
public class DocumentController {

    // 需要同时拥有查看和编辑权限
    @GetMapping("/edit")
    @RequiresPermission(value = {"document:view", "document:edit"}, logical = RequiresPermission.LogicalOperator.AND)
    public String editDocument() {
        return "文档编辑成功";
    }

    // 拥有管理员权限或文档所有者权限即可
    @GetMapping("/delete")
    @RequiresPermission(value = {"document:delete", "admin:full"}, logical = RequiresPermission.LogicalOperator.OR)
    public String deleteDocument() {
        return "文档删除成功";
    }
}

// 1. 定义注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RequiresPermission {
    String value();
}

// 2. 创建切面
@Aspect
@Component
@RequiredArgsConstructor
public class PermissionAspect {
    private final PermissionMapper permissionMapper;

    @Before("@annotation(permission)")
    public void check(RequiresPermission permission) {
        Long userId = getCurrentUserId(); // 从请求上下文获取
        List<String> userPerms = permissionMapper.selectPermissionsByUserId(userId);
        if (!userPerms.contains(permission.value())) {
            throw new RuntimeException("403 Forbidden: 权限不足");
        }
    }
}

// 3. 使用注解
@DeleteMapping("/users/{id}")
@RequiresPermission("user:delete")
public void deleteUser(@PathVariable Long id) {
    // 业务逻辑
}

// 1. 增强注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RequiresPermission {
    String[] value();
    LogicalOperator logical() default LogicalOperator.AND;
    enum LogicalOperator { AND, OR }
}

// 2. 切面校验逻辑
if (logical == LogicalOperator.AND) {
    boolean pass = userPerms.containsAll(Arrays.asList(requiredPerms));
    if (!pass) throw new RuntimeException("403 Forbidden");
}

// 3. 使用注解
@PutMapping("/docs/{id}")
@RequiresPermission(value = {"doc:view", "doc:edit"}, logical = LogicalOperator.AND)
public void editDoc(@PathVariable Long id) {
    // 业务逻辑
}

// 切面校验逻辑
if (logical == LogicalOperator.OR) {
    boolean pass = false;
    for (String required : requiredPerms) {
        if (userPerms.contains(required)) {
            pass = true;
            break;
        }
    }
    if (!pass) throw new RuntimeException("403 Forbidden");
}

// 使用注解
@DeleteMapping("/docs/{id}")
@RequiresPermission(value = {"doc:delete", "admin:full"}, logical = LogicalOperator.OR)
public void deleteDoc(@PathVariable Long id) {
    // 业务逻辑
}