const std = @import("std");
const dbos = @import("../dbos.zig");

// DBOS示例程序
pub fn main() !void {
 std.debug.print("DBOS示例程序启动\n", .{});

 var gpa = std.heap.GeneralPurposeAllocator(.{}){};
 defer _ = gpa.deinit();
 const allocator = gpa.allocator();

 // 初始化DBOS
 const dbos_system = try dbos.DBOS.init(allocator);
 defer dbos_system.deinit();

 std.debug.print("DBOS系统初始化完成\n", .{});

 // 测试1: 事务性文件操作
 try testFileOperations(dbos_system);

 // 测试2: 事务性内存管理
 try testMemoryManagement(dbos_system);

 // 测试3: 事务性进程管理
 try testProcessManagement(dbos_system);

 // 测试4: 系统快照和恢复
 try testSnapshotAndRecovery(dbos_system);

 std.debug.print("所有测试通过!\n", .{});
}

fn testFileOperations(dbos_system: *dbos.DBOS) !void {
 std.debug.print("开始文件操作测试...\n", .{});

 const tx = try dbos_system.beginSystemTransaction();
 defer tx.deinit();

 // 创建测试文件
 const test_file = "/test_example.txt";
 const inode = try dbos_system.createFile(tx, test_file, 0o644);
 std.debug.print("创建文件: {}, inode: {}\n", .{ test_file, inode });

 // 写入数据
 const test_data = "这是DBOS示例程序的测试数据";
 try dbos_system.writeFile(tx, inode, 0, test_data);
 std.debug.print("写入数据: {s}\n", .{test_data});

 // 读取数据
 var buffer: [100]u8 = undefined;
 const bytes_read = try dbos_system.readFile(tx, inode, 0, &buffer);
 const read_data = buffer[0..bytes_read];

 if (std.mem.eql(u8, test_data, read_data)) {
 std.debug.print("文件读写测试通过\n", .{});
 } else {
 std.debug.print("文件读写测试失败\n", .{});
 return error.TestFailed;
 }

 // 提交事务
 try dbos_system.commitSystemTransaction(tx);
 std.debug.print("文件操作事务提交成功\n", .{});
}

fn testMemoryManagement(dbos_system: *dbos.DBOS) !void {
 std.debug.print("开始内存管理测试...\n", .{});

 const tx = try dbos_system.beginSystemTransaction();
 defer tx.deinit();

 const test_pid: dbos.ProcessId = 1001;
 const allocation_size = 4096; // 4KB

 // 分配内存
 const memory_region = try dbos_system.allocateMemory(tx, test_pid, allocation_size);
 std.debug.print("分配内存: 0x{x}-0x{x} ({}字节)\n", .{ memory_region.start, memory_region.start + memory_region.size, memory_region.size });

 // 检查内存使用统计
 const usage_stats = try dbos_system.getMemoryUsage();
 std.debug.print("内存使用统计:\n", .{});
 std.debug.print(" 总内存: {}字节\n", .{usage_stats.total_memory});
 std.debug.print(" 已使用: {}字节\n", .{usage_stats.used_memory});
 std.debug.print(" 空闲内存: {}字节\n", .{usage_stats.free_memory});
 std.debug.print(" 分配次数: {}\n", .{usage_stats.allocation_count});
 std.debug.print(" 释放次数: {}\n", .{usage_stats.free_count});
 std.debug.print(" 碎片率: {d:.2}%\n", .{usage_stats.fragmentation * 100});

 // 释放内存
 try dbos_system.freeMemory(tx, test_pid, memory_region);
 std.debug.print("内存释放成功\n", .{});

 try dbos_system.commitSystemTransaction(tx);
 std.debug.print("内存管理测试完成\n", .{});
}

fn testProcessManagement(dbos_system: *dbos.DBOS) !void {
 std.debug.print("开始进程管理测试...\n", .{});

 const tx = try dbos_system.beginSystemTransaction();
 defer tx.deinit();

 // 创建测试进程
 const test_image = "/bin/test_app";
 const test_args = [_][]const u8{ "test_app", "--verbose" };
 const pid = try dbos_system.createProcess(tx, test_image, &test_args);
 std.debug.print("创建进程: PID={}, 镜像={s}\n", .{ pid, test_image });

 // 获取进程信息
 const process_info = try dbos_system.getProcessInfo(pid);
 std.debug.print("进程信息:\n", .{});
 std.debug.print(" PID: {}\n", .{process_info.pid});
 std.debug.print(" 状态: {s}\n", .{@tagName(process_info.state)});
 std.debug.print(" 内存区域数: {}\n", .{process_info.memory_regions.items.len});

 // 终止进程
 try dbos_system.terminateProcess(tx, pid);
 std.debug.print("进程终止: PID={}\n", .{pid});

 try dbos_system.commitSystemTransaction(tx);
 std.debug.print("进程管理测试完成\n", .{});
}

fn testSnapshotAndRecovery(dbos_system: *dbos.DBOS) !void {
 std.debug.print("开始快照和恢复测试...\n", .{});

 // 创建系统快照
 const snapshot = try dbos_system.createSnapshot();
 std.debug.print("系统快照创建完成,时间戳: {}\n", .{snapshot.timestamp});

 // 模拟一些系统操作
 const tx = try dbos_system.beginSystemTransaction();
 defer tx.deinit();

 const test_file = "/snapshot_test.txt";
 const inode = try dbos_system.createFile(tx, test_file, 0o644);
 try dbos_system.writeFile(tx, inode, 0, "快照测试数据");

 try dbos_system.commitSystemTransaction(tx);
 std.debug.print("快照后操作完成\n", .{});

 // 从快照恢复系统
 try dbos_system.restoreFromSnapshot(snapshot);
 std.debug.print("系统从快照恢复完成\n", .{});

 // 验证恢复后的状态
 const tx2 = try dbos_system.beginSystemTransaction();
 defer tx2.deinit();

 // 检查快照测试文件是否不存在(因为恢复到了快照之前的状态)
 const files = try dbos_system.queryFiles(tx2, dbos.FilePredicate.modifiedAfter(snapshot.timestamp));
 defer dbos_system.allocator.free(files);

 if (files.len == 0) {
 std.debug.print("快照恢复验证通过: 快照后创建的文件已正确回滚\n", .{});
 } else {
 std.debug.print("快照恢复验证失败: 发现{}个快照后创建的文件\n", .{files.len});
 return error.TestFailed;
 }

 try dbos_system.commitSystemTransaction(tx2);
 std.debug.print("快照和恢复测试完成\n", .{});
}