public class EnhancedVirtualThreadExample {
    public static void main(String[] args) throws Exception {
        // 创建虚拟线程
        Thread.Builder.OfVirtual builder = Thread.ofVirtual();
        Thread vThread = builder.start(() -> {
            System.out.println("在虚拟线程中运行");
        });
        
        // 使用虚拟线程执行器处理大量任务
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            List<Future<String>> futures = new ArrayList<>();
            
            // 提交多个任务
            for (int i = 0; i < 1000; i++) {
                final int taskId = i;
                futures.add(executor.submit(() -> {
                    // 模拟 IO 操作
                    Thread.sleep(Duration.ofMillis(100));
                    return "任务 " + taskId + " 完成";
                }));
            }
            
            // 收集结果
            for (Future<String> future : futures) {
                System.out.println(future.get());
            }
        }
        
        // 使用结构化并发
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            // 并行执行多个操作
            Future<String> auth = scope.fork(() -> authenticateUser("user123"));
            Future<List<String>> perms = scope.fork(() -> fetchPermissions("user123"));
            Future<UserProfile> profile = scope.fork(() -> loadUserProfile("user123"));
            
            scope.join();           // 等待所有任务完成
            scope.throwIfFailed();  // 检查失败
            
            // 处理结果
            processUserData(
                auth.resultNow(),
                perms.resultNow(),
                profile.resultNow()
            );
        }
    }
    
    // 模拟用户认证
    private static String authenticateUser(String userId) throws Exception {
        Thread.sleep(100);
        return "TOKEN_" + userId;
    }
    
    // 模拟权限获取
    private static List<String> fetchPermissions(String userId) throws Exception {
        Thread.sleep(150);
        return List.of("READ", "WRITE", "EXECUTE");
    }
    
    // 模拟用户档案加载
    private static UserProfile loadUserProfile(String userId) throws Exception {
        Thread.sleep(200);
        return new UserProfile(userId, "张三", "zhang@example.com");
    }
    
    // 处理用户数据
    private static void processUserData(
        String token,
        List<String> permissions,
        UserProfile profile
    ) {
        System.out.printf(
            "用户 %s 已认证，权限：%s，邮箱：%s%n",
            profile.name(),
            String.join(",", permissions),
            profile.email()
        );
    }
    
    record UserProfile(String id, String name, String email) {}
}

// 创建并启动一个虚拟线程
Thread.startVirtualThread(() -> {
    System.out.println("在虚拟线程中运行");
});

// 使用虚拟线程执行器
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    IntStream.range(0, 10_000).forEach(i -> {
        executor.submit(() -> {
            Thread.sleep(Duration.ofSeconds(1));
            return i;
        });
    });
}

// 在 JDK 18 之前
System.out.println(Charset.defaultCharset()); // 可能输出 windows-1252、GBK 等

// 在 JDK 18 中
System.out.println(Charset.defaultCharset()); // 始终输出 UTF-8

public sealed interface Shape 
    permits Circle, Rectangle, Triangle {
    double area();
}

public final class Circle implements Shape {
    private final double radius;
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
}

// sealed 实现类
public sealed class Rectangle implements Shape 
    permits Square {
    private final double width;
    private final double height;
    
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }
    
    @Override
    public double area() {
        return width * height;
    }
}

// non-sealed 实现类
public non-sealed class Triangle implements Shape {
    private final double base;
    private final double height;
    
    public Triangle(double base, double height) {
        this.base = base;
        this.height = height;
    }
    
    @Override
    public double area() {
        return 0.5 * base * height;
    }
}

public record Person(String name, int age) {
    // 可以添加静态字段
    public static final String UNKNOWN = "Unknown";
    
    // 可以添加额外的构造器
    public Person {
        if (age < 0) {
            throw new IllegalArgumentException("Age cannot be negative");
        }
    }
    
    // 可以添加实例方法
    public String getDescription() {
        return name + " is " + age + " years old";
    }
}

public record Point(int x, int y) {
    // 编译器自动生成：
    // - 构造方法
    // - equals() 和 hashCode()
    // - toString()
    // - getter 方法
}

String html = """
              <html>
                  <body>
                      <h1>Hello, World!</h1>
                  </body>
              </html>
              """;

var dayType = switch (day) {
    case MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY -> "工作日";
    case SATURDAY, SUNDAY -> "周末";
    default -> throw new IllegalArgumentException("无效的日期: " + day);
};

var result = switch (status) {
    case PENDING -> {
        System.out.println("处理中...");
        yield "等待处理";
    }
    case APPROVED -> {
        System.out.println("已批准");
        yield "处理完成";
    }
    default -> "未知状态";
};

// 创建 HTTP 客户端
var client = HttpClient.newBuilder()
    .version(HttpClient.Version.HTTP_2)
    .connectTimeout(Duration.ofSeconds(10))
    .build();

// 构建请求
var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.example.com/data"))
    .timeout(Duration.ofMinutes(1))
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString("{\"name\":\"test\"}"))
    .build();

// 发送请求
var response = client.send(request, 
    HttpResponse.BodyHandlers.ofString());
System.out.println(response.statusCode());
System.out.println(response.body());

// 异步请求
client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
    .thenApply(HttpResponse::body)
    .thenAccept(System.out::println);