/**
 * JWT 令牌操作工具类 (生产级版本)
 * 适配 jjwt 0.12.6+ 及 Spring Boot 环境
 *
 * @author YourName
 */
@Slf4j
@Component // 注册为 Spring Bean，以便注入配置
public class JwtUtils {

    // --- 配置属性 (从 application.yml 读取，若无则使用默认值) ---

    /**
     * 密钥字符串
     * 默认值: 一个安全的 32 字节随机密钥的 Base64 编码
     * 建议在 application.yml 中配置: jwt.secret-key
     */
    @Value("${jwt.secret-key:kG8sL9mP2nQ5rT6vW8xY0zA3bC4dE7fH}")
    private String secretKeyString;

    /**
     * 令牌过期时间 (毫秒)
     * 默认值: 12 小时 (43200000 ms)
     * 建议在 application.yml 中配置: jwt.expiration
     */
    @Value("${jwt.expiration:43200000}")
    private Long expirationMillis;

    // --- 内部运行时变量 ---

    private SecretKey secretKey;

    /**
     * 初始化方法
     * 在 Spring 容器加载 Bean 后执行，将字符串密钥转换为 SecretKey 对象
     */
    @PostConstruct
    public void init() {
        if (!StringUtils.hasText(secretKeyString)) {
            throw new IllegalArgumentException("JWT Secret Key 不能为空，请在配置文件中设置 jwt.secret-key");
        }
        // 将字符串转换为 SecretKey，如果长度不足 256 bits，这里会抛出 WeakKeyException
        try {
            this.secretKey = Keys.hmacShaKeyFor(secretKeyString.getBytes(StandardCharsets.UTF_8));
            log.info("JWT Utils 初始化成功，密钥长度: {} bits", secretKey.getEncoded().length * 8);
        } catch (Exception e) {
            log.error("JWT 密钥初始化失败，请检查密钥长度是否至少为 256 bits (32 字节)", e);
            throw new RuntimeException("JWT 密钥配置错误", e);
        }
    }

    // ================= 核心功能方法 =================

    /**
     * 生成 JWT 令牌 (通用版)
     *
     * @param claimsMap 自定义声明信息 (如 id, username, role 等)
     * @return JWT 字符串
     */
    public String generateToken(Map<String, Object> claimsMap) {
        if (claimsMap == null) {
            claimsMap = new HashMap<>();
        }

        Date now = new Date();
        Date expiryDate = new Date(now.getTime() + expirationMillis);

        try {
            return Jwts.builder()
                    .claims(claimsMap)          // 放入自定义数据
                    .issuedAt(now)              // 签发时间
                    .expiration(expiryDate)     // 过期时间
                    .signWith(secretKey)        // 签名
                    .compact();
        } catch (Exception e) {
            log.error("生成 JWT 令牌时发生错误", e);
            throw new RuntimeException("生成令牌失败", e);
        }
    }

    /**
     * 生成 JWT 令牌 (便捷版 - 常用场景)
     * 仅传入用户 ID 和用户名，自动构建 Claims
     *
     * @param id       用户 ID
     * @param username 用户名
     * @return JWT 字符串
     */
    public String generateToken(Integer id, String username) {
        Map<String, Object> claims = new HashMap<>();
        claims.put("id", id);
        claims.put("username", username);
        return generateToken(claims);
    }

    /**
     * 解析 JWT 令牌
     *
     * @param token JWT 字符串
     * @return Claims 对象 (包含所有声明信息)
     * @throws ExpiredJwtException      如果令牌已过期
     * @throws SignatureException       如果签名验证失败 (密钥错误或数据被篡改)
     * @throws MalformedJwtException    如果令牌格式不正确
     * @throws IllegalArgumentException 如果令牌为 null 或空
     */
    public Claims parseToken(String token) {
        if (!StringUtils.hasText(token)) {
            throw new IllegalArgumentException("JWT Token 不能为空");
        }

        try {
            return Jwts.parser()
                    .verifyWith(secretKey)    // 设置验证密钥
                    .build()                  // 构建解析器
                    .parseSignedClaims(token) // 解析并验证 (核心步骤)
                    .getPayload();            // 获取载荷
        } catch (ExpiredJwtException e) {
            log.warn("JWT 令牌已过期: {}", e.getMessage());
            throw e; // 向上抛出，让调用者知道是过期了
        } catch (SignatureException e) {
            log.error("JWT 签名验证失败 (可能密钥不匹配或数据被篡改): {}", e.getMessage());
            throw e;
        } catch (MalformedJwtException e) {
            log.error("JWT 格式错误: {}", e.getMessage());
            throw e;
        } catch (Exception e) {
            log.error("解析 JWT 令牌时发生未知错误", e);
            throw new RuntimeException("解析令牌失败", e);
        }
    }

    // ================= 辅助便捷方法 =================

    /**
     * 判断令牌是否有效 (不抛出异常，只返回布尔值)
     * 适用于拦截器中快速判断
     *
     * @param token JWT 字符串
     * @return true: 有效且未过期; false: 无效或已过期
     */
    public boolean isTokenValid(String token) {
        try {
            parseToken(token);
            return true;
        } catch (Exception e) {
            // 任何异常都视为无效
            return false;
        }
    }

    /**
     * 从令牌中获取用户 ID
     *
     * @param token JWT 字符串
     * @return 用户 ID，如果获取失败返回 null
     */
    public Integer getUserIdFromToken(String token) {
        try {
            Claims claims = parseToken(token);
            // 注意：根据生成时的类型，可能需要转换。如果是 Integer 存进去就是 Integer
            Object idObj = claims.get("id");
            if (idObj instanceof Integer) {
                return (Integer) idObj;
            } else if (idObj instanceof Number) {
                return ((Number) idObj).intValue();
            } else if (idObj instanceof String) {
                return Integer.parseInt((String) idObj);
            }
        } catch (Exception e) {
            // 静默失败，返回 null
        }
        return null;
    }

    /**
     * 从令牌中获取用户名
     *
     * @param token JWT 字符串
     * @return 用户名，如果获取失败返回 null
     */
    public String getUsernameFromToken(String token) {
        try {
            Claims claims = parseToken(token);
            return claims.get("username", String.class);
        } catch (Exception e) {
            return null;
        }
    }
    
    /**
     * 获取令牌的过期时间
     * @param token JWT 字符串
     * @return 过期时间，如果获取失败返回 null
     */
    public Date getExpirationDateFromToken(String token) {
        try {
            Claims claims = parseToken(token);
            return claims.getExpiration();
        } catch (Exception e) {
            return null;
        }
    }
}

@RestController
public class requestController {
    @RequestMapping("/request")
    public String request(HttpServletRequest request) {//获取前端请求数据封装好了对应的方法
        //获取请求行里面的请求地址
        String url = request.getRequestURL().toString();//这里获取的是完整的请求地址
        //获取请求uri地址
        String requestURI = request.getRequestURI();
        System.out.println(url);
        System.out.println(requestURI);
        //获取请求HTTP协议版本号
        String protocol = request.getProtocol();
        System.out.println(protocol);
        //获取请求行中的请求参数
        String name = request.getParameter("name");
        String age = request.getParameter("age");
        System.out.println(name);
        System.out.println(age);
        //获取请求头
        String accept = request.getHeader("Accept");
        System.out.println(accept);
        return "ok";
    }
}

@RestController // 标记为Spring MVC的控制器，负责处理HTTP请求
public class UserController {

    // 映射GET /list请求，返回用户列表
    @RequestMapping("/list")
    public List<User> list() {
        // 从类路径下加载user.txt文件，获取输入流
        InputStream in = this.getClass().getClassLoader().getResourceAsStream("user.txt");
        // 使用IoUtil工具类按行读取文件内容，默认UTF-8编码，结果存入ArrayList
        ArrayList<String> lines = IoUtil.readLines(in, StandardCharsets.UTF_8, new ArrayList<>());

        // 将每行文本解析成User对象：按逗号拆分字段并封装
        List<User> userList = lines.stream().map(line -> {
            String[] parts = line.split(",");                    // 拆分每行数据
            Integer id = Integer.parseInt(parts[0]);            // 解析用户ID
            String username = parts[1];                         // 用户名
            String password = parts[2];                         // 密码
            String name = parts[3];                             // 真实姓名
            Integer age = Integer.parseInt(parts[4]);            // 年龄
            // 解析更新时间，格式为yyyy-MM-dd HH:mm:ss
            LocalDateTime updateTime = LocalDateTime.parse(parts[5], DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
            return new User(id, username, password, name, age, updateTime); // 构造User对象
        }).toList(); // 收集为不可变List

        // 将封装好的用户列表返回给前端（Spring自动转为JSON）
        return userList;
    }
}

@RestController
public class UserController {
    @Autowired
    private UserService userService;
    
    @RequestMapping("/list")
    public List<User> list(){
        //1.调用service，查询用户信息
        List<User> userlist = userService.list();
        //2...
    }
}

@Component
public class UserServiceImpl implements UserService {
    @Autowired
    private UserDao userDao;
    
    @Override
    public List<User> list() {
        //1.调用dao获取数据
        List<String> lines = userDao.list();
        //2...
    }
}

@Component
public class UserDaoImpl implements UserDao {
    
    @Override
    public List<String> list() {
        InputStream in = this.getClass().getClassLoader().getResourceAsStream("user.txt");
        return IOUtil.readLines(in, StandardCharsets.UTF_8, new ArrayList<>());
    }
}

@SpringBootApplication
public class TliasManagementApplication {
    public static void main(String[] args) {
        SpringApplication.run(TliasManagementApplication.class, args);
    }
}

@RestController
public class UserController {
    @Autowired
    private UserService userService;
    
    //......
}

@RestController
public class UserController {
    private final UserService userService;
    
    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }
}

@RestController
public class UserController {
    private UserService userService;
    
    @Autowired
    public void setUserService(UserService userService) {
        this.userService = userService;
    }
}

@Primary
@Service
public class UserServiceImpl implements UserService {
    @Override
    public List<User> list() {
        // 省略实现...
    }
}

@RestController
public class UserController {
    @Autowired
    @Qualifier("userServiceImpl")
    private UserService userService;
}

@RestController
public class UserController {
    @Resource(name = "userServiceImpl")
    private UserService userService;
}

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;

public class JdbcDemo {
    public static void main(String[] args) throws Exception {
        // 1. 注册驱动
        Class.forName("com.mysql.cj.jdbc.Driver");
        
        // 2. 获取连接
        String url = "jdbc:mysql://localhost:3306/web01";
        String username = "root";
        String password = "1234";
        Connection connection = DriverManager.getConnection(url, username, password);
        
        // 3. 获取SQL语句执行对象
        Statement statement = connection.createStatement();
        
        // 4. 执行SQL
        String sql = "update user set age = 25 where id = 1";
        int i = statement.executeUpdate(sql);
        
        // 5. 释放资源
        statement.close();
        connection.close();
        
        System.out.println("影响行数: " + i);
    }
}

// 注册驱动（JDBC 4.0后可省略）
Class.forName("com.mysql.cj.jdbc.Driver");

// 获取连接
String url = "jdbc:mysql://localhost:3306/web01";
String username = "root";
String password = "1234";
Connection connection = DriverManager.getConnection(url, username, password);

// 创建Statement对象
Statement statement = connection.createStatement();

// 创建PreparedStatement对象
String sql = "insert into user(name, age) values(?, ?)";
PreparedStatement preparedStatement = connection.prepareStatement(sql);

// 事务管理
connection.setAutoCommit(false); // 关闭自动提交
try {
    // 执行SQL语句
    // ...
    connection.commit(); // 提交事务
} catch (SQLException e) {
    connection.rollback(); // 回滚事务
    e.printStackTrace();
}

// 执行DML语句
String sql1 = "update user set age = 25 where id = 1";
int rows = statement.executeUpdate(sql1);

// 执行DQL语句
String sql2 = "select * from user";
ResultSet resultSet = statement.executeQuery(sql2);

String sql = "select id, name, age from user";
ResultSet resultSet = statement.executeQuery(sql);

// 遍历结果集
while (resultSet.next()) {
    int id = resultSet.getInt("id"); // 或 resultSet.getInt(1)
    String name = resultSet.getString("name"); // 或 resultSet.getString(2)
    int age = resultSet.getInt("age"); // 或 resultSet.getInt(3)
    
    System.out.println("id: " + id + ", name: " + name + ", age: " + age);
}

// 释放资源
resultSet.close();
statement.close();
connection.close();

// 创建PreparedStatement对象
String sql = "insert into user(name, age) values(?, ?)";
PreparedStatement preparedStatement = connection.prepareStatement(sql);

// 设置参数
preparedStatement.setString(1, "张三"); // 第一个参数，索引从1开始
preparedStatement.setInt(2, 25); // 第二个参数

// 执行SQL语句
int rows = preparedStatement.executeUpdate();
System.out.println("插入了" + rows + "条记录");

// 查询示例
String sql2 = "select * from user where age > ?";
PreparedStatement preparedStatement2 = connection.prepareStatement(sql2);
preparedStatement2.setInt(1, 20);
ResultSet resultSet = preparedStatement2.executeQuery();

// 遍历结果集
while (resultSet.next()) {
    int id = resultSet.getInt("id");
    String name = resultSet.getString("name");
    int age = resultSet.getInt("age");
    System.out.println("id: " + id + ", name: " + name + ", age: " + age);
}

// 释放资源
resultSet.close();
preparedStatement2.close();
preparedStatement.close();
connection.close();

// 不安全的做法
String username = "admin' or '1'='1";
String password = "任意密码";
String sql = "select * from user where username = '" + username + "' and password = '" + password + "'";
// 生成的SQL：select * from user where username = 'admin' or '1'='1' and password = '任意密码'
// 由于'1'='1'永远为真，这条SQL会查询出所有用户记录

// 安全的做法
String username = "admin' or '1'='1";
String password = "任意密码";
String sql = "select * from user where username = ? and password = ?";
PreparedStatement preparedStatement = connection.prepareStatement(sql);
preparedStatement.setString(1, username);
preparedStatement.setString(2, password);
// PreparedStatement会将参数中的特殊字符进行转义，防止SQL注入

Connection connection = null;
PreparedStatement preparedStatement = null;

String url = "jdbc:mysql://localhost:3306/web01";
String username = "root";
String password = "1234";

try {
    // 获取连接
    connection = DriverManager.getConnection(url, username, password);
    
    // 关闭自动提交，开启事务
    connection.setAutoCommit(false);
    
    // 执行第一条SQL语句：转账（转出）
    String sql1 = "update account set balance = balance - ? where id = ?";
    preparedStatement = connection.prepareStatement(sql1);
    preparedStatement.setDouble(1, 1000.0);
    preparedStatement.setInt(2, 1);
    int rows1 = preparedStatement.executeUpdate();
    
    // 执行第二条SQL语句：转账（转入）
    String sql2 = "update account set balance = balance + ? where id = ?";
    preparedStatement = connection.prepareStatement(sql2);
    preparedStatement.setDouble(1, 1000.0);
    preparedStatement.setInt(2, 2);
    int rows2 = preparedStatement.executeUpdate();
    
    // 模拟异常
    // int i = 1 / 0;
    
    // 提交事务
    connection.commit();
    System.out.println("转账成功");
    
} catch (SQLException e) {
    // 发生异常，回滚事务
    if (connection != null) {
        try {
            connection.rollback();
            System.out.println("转账失败，事务已回滚");
        } catch (SQLException ex) {
            ex.printStackTrace();
        }
    }
    e.printStackTrace();
} finally {
    // 释放资源
    if (preparedStatement != null) {
        try {
            preparedStatement.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    if (connection != null) {
        try {
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

// 获取当前隔离级别
int isolationLevel = connection.getTransactionIsolation();
System.out.println("当前隔离级别: " + isolationLevel);

// 设置隔离级别
connection.setTransactionIsolation(Connection.TRANSACTION_REPEATABLE_READ);

@Mapper
public interface UserMapper {
    @Select("select * from user")
    public List<User> findAll();
}