#include "simplefs.h"
#include "disk_io.h"
#include "utils.h"    // 位图操作工具函数
// 如果位图工具在utils.h中，mkfs.cpp就不再直接需要metadata.h了

#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <cstring> // 字符串操作
#include <sys/stat.h> // stat, fstat
#include <fcntl.h>    // open
#include <unistd.h>   // close, ftruncate
#include <cmath>      // ceil
#include <numeric>    // std::fill
#include <algorithm>  // std::fill

#include <sys/ioctl.h>  // ioctl
#include <linux/fs.h>   // BLKGETSIZE64

// 默认参数(可通过选项覆盖)
const uint32_t DEFAULT_BLOCKS_PER_GROUP = SIMPLEFS_BLOCK_SIZE * 8; // 位图中每位对应一个块
const uint32_t DEFAULT_INODES_PER_GROUP = 1024; // 选定的默认值

// 静态位图辅助函数已移至metadata.cpp

void print_usage(const char* prog_name) {
    std::cerr << "用法: " << prog_name << " <设备文件> [块数量]" << std::endl;
    std::cerr << "  <设备文件>: 磁盘镜像文件或块设备路径" << std::endl;
    std::cerr << "  [块数量]: 可选，新镜像文件的总块数" << std::endl;
}

// 获取文件大小的函数
off_t get_file_size(int fd) {
    struct stat st;
    if (fstat(fd, &st) == -1) {
        perror("获取文件大小失败");
        return -1;
    }
    return st.st_size;
}


int main(int argc, char* argv[]) {
    if (argc < 2 || argc > 3) {
        print_usage(argv[0]);
        return 1;
    }

    std::string device_path = argv[1];
    uint64_t total_blocks_on_device = 0;
    uint64_t device_size_bytes = 0;
    bool create_new_image = false;

    DeviceFd fd = open(device_path.c_str(), O_RDWR);

    if (fd == -1) {
        if (errno == ENOENT && argc == 3) { // 文件不存在，且提供了大小
            std::cout << "正在创建新镜像文件: " << device_path << std::endl;
            fd = open(device_path.c_str(), O_RDWR | O_CREAT | O_EXCL, 0666);
            if (fd == -1) {
                perror("创建镜像文件失败");
                return 1;
            }
            create_new_image = true;
            try {
                total_blocks_on_device = std::stoull(argv[2]);
                if (total_blocks_on_device == 0) {
                    std::cerr << "块数量必须为正数" << std::endl;
                    close(fd);
                    unlink(device_path.c_str()); // 清理已创建的文件
                    return 1;
                }
                device_size_bytes = total_blocks_on_device * SIMPLEFS_BLOCK_SIZE;
                if (ftruncate(fd, device_size_bytes) == -1) {
                    perror("设置镜像大小失败");
                    close(fd);
                    unlink(device_path.c_str()); // 清理
                    return 1;
                }
                std::cout << "已创建新镜像文件 " << device_path << " (大小: " 
                          << total_blocks_on_device << " 块, " << device_size_bytes << " 字节)" << std::endl;
            } catch (const std::exception& e) {
                std::cerr << "块数量参数无效: " << e.what() << std::endl;
                close(fd);
                unlink(device_path.c_str()); // 清理
                return 1;
            }
        } else if (errno == ENOENT) {
            std::cerr << "错误: 镜像文件 '" << device_path << "' 未找到，请提供块数量来创建" << std::endl;
            perror("打开设备/镜像失败");
            return 1;
        }
         else {
            perror("打开设备/镜像失败");
            return 1;
        }
    } else {
        bool is_blk_dev = is_block_device(fd);

        if (is_blk_dev) {
            std::cout << "检测到块设备" << std::endl;
            uint64_t size_from_ioctl = 0;
            if (ioctl(fd, BLKGETSIZE64, &size_from_ioctl) == 0) {
                 std::cout << "通过ioctl获取块设备大小: " << size_from_ioctl << " 字节" << std::endl;
                 if (size_from_ioctl % SIMPLEFS_BLOCK_SIZE != 0) {
                      std::cerr << "警告: 块设备大小不是文件系统块大小的整数倍" << std::endl;
                 }
                 device_size_bytes = size_from_ioctl;
                 total_blocks_on_device = device_size_bytes / SIMPLEFS_BLOCK_SIZE;
                 if (argc == 3) {
                     std::cout << "注意: 忽略[num_blocks]参数，已自动检测设备大小" << std::endl;
                 }
            } else {
                perror("ioctl获取设备大小失败");
                std::cerr << "无法自动检测块设备大小" << std::endl;
                if (argc != 3) {
                    std::cerr << "错误: 请手动提供[num_blocks]参数" << std::endl;
                    close(fd);
                    return 1;
                }
                 try {
                    total_blocks_on_device = std::stoull(argv[2]);
                    if (total_blocks_on_device == 0) {
                        std::cerr << "块数量必须为正数" << std::endl;
                        close(fd);
                        return 1;
                    }
                    device_size_bytes = total_blocks_on_device * SIMPLEFS_BLOCK_SIZE;
                } catch (const std::exception& e) {
                    std::cerr << "块数量参数无效: " << e.what() << std::endl;
                    close(fd);
                    return 1;
                }
            }
             std::cout << "格式化块设备 " << device_path << "，块数: " << total_blocks_on_device
                      << " (" << device_size_bytes << " 字节)" << std::endl;

        } else {
            // 这是常规文件，获取其大小
            off_t existing_size = get_file_size(fd);
            if (existing_size == -1) {
                close(fd);
                return 1;
            }
            if (existing_size == 0) {
                 if (argc == 3) { // 这是空文件但用户要用指定大小格式化
                    std::cout << "现有文件为空，按新镜像创建处理" << std::endl;
                    create_new_image = true;
                    try {
                        total_blocks_on_device = std::stoull(argv[2]);
                         if (total_blocks_on_device == 0) {
                            std::cerr << "块数量必须为正数" << std::endl;
                            close(fd);
                            return 1;
                        }
                        device_size_bytes = total_blocks_on_device * SIMPLEFS_BLOCK_SIZE;
                        if (ftruncate(fd, device_size_bytes) == -1) {
                            perror("设置镜像大小失败");
                            close(fd);
                            return 1;
                        }
                        std::cout << "设置镜像 " << device_path << " 大小为 " << total_blocks_on_device
                                  << " 块 (" << device_size_bytes << " 字节)" << std::endl;
                    } catch (const std::exception& e) {
                        std::cerr << "块数量参数无效: " << e.what() << std::endl;
                        close(fd);
                        return 1;
                    }
                } else {
                    std::cerr << "错误: 镜像文件为空" << std::endl;
                    std::cerr << "如需格式化，请提供num_blocks参数" << std::endl;
                    close(fd);
                    return 1;
                }
            } else {
                 if (existing_size % SIMPLEFS_BLOCK_SIZE != 0) {
                    std::cerr << "警告: 设备/镜像大小 (" << existing_size
                              << " 字节) 不是块大小 (" << SIMPLEFS_BLOCK_SIZE << " 字节) 的整数倍" << std::endl;
                }
                device_size_bytes = existing_size;
                total_blocks_on_device = device_size_bytes / SIMPLEFS_BLOCK_SIZE;
                std::cout << "Opened existing image " << device_path << ". Total blocks: " << total_blocks_on_device
                          << " (" << device_size_bytes << " bytes)." << std::endl;
                if (argc == 3 && !create_new_image) {
                    std::cout << "Note: [num_blocks] argument is ignored when using an existing, non-empty image file." << std::endl;
                }
            }
        }
    }

    if (total_blocks_on_device < 64) {
        std::cerr << "错误: 设备/镜像太小，至少需要64个块" << std::endl;
        close(fd);
        if (create_new_image) unlink(device_path.c_str());
        return 1;
    }

    std::cout << "正在格式化 " << device_path << " 为 SimpleFS..." << std::endl;

    uint32_t inodes_per_block = SIMPLEFS_BLOCK_SIZE / SIMPLEFS_INODE_SIZE;
    uint32_t sb_blocks_per_group = DEFAULT_BLOCKS_PER_GROUP;
    uint32_t sb_inodes_per_group = DEFAULT_INODES_PER_GROUP;
    if (sb_inodes_per_group > SIMPLEFS_BLOCK_SIZE * 8) {
        sb_inodes_per_group = SIMPLEFS_BLOCK_SIZE * 8;
        std::cout << "警告: 请求的每组inode数超过inode位图最大容量，调整为 "
                  << sb_inodes_per_group << std::endl;
    }

    uint32_t num_block_groups = static_cast<uint32_t>(std::ceil(static_cast<double>(total_blocks_on_device) / sb_blocks_per_group));
    if (num_block_groups == 0) num_block_groups = 1;

    uint64_t total_inodes_fs = static_cast<uint64_t>(num_block_groups) * sb_inodes_per_group;
    if (total_inodes_fs > UINT32_MAX) {
        total_inodes_fs = UINT32_MAX;
    }

    std::cout << "文件系统布局:" << std::endl;
    std::cout << "  总块数: " << total_blocks_on_device << std::endl;
    std::cout << "  每组inode数: " << sb_inodes_per_group << std::endl;
    std::cout << "  块组数: " << num_block_groups << std::endl;
    std::cout << "  总inode数: " << total_inodes_fs << std::endl;

    SimpleFS_SuperBlock sb;
    std::memset(&sb, 0, sizeof(SimpleFS_SuperBlock));
    sb.s_magic = SIMPLEFS_MAGIC;
    sb.s_blocks_count = total_blocks_on_device;
    sb.s_inodes_count = static_cast<uint32_t>(total_inodes_fs);
    sb.s_log_block_size = static_cast<uint32_t>(std::log2(SIMPLEFS_BLOCK_SIZE)) - 10;
    sb.s_blocks_per_group = sb_blocks_per_group;
    sb.s_inodes_per_group = sb_inodes_per_group;
    sb.s_inode_size = SIMPLEFS_INODE_SIZE;
    sb.s_root_inode = SIMPLEFS_ROOT_INODE_NUM;
    sb.s_first_ino = 11;
    sb.s_state = 1;
    sb.s_errors = 1;
    sb.s_max_mnt_count = 20;
    sb.s_mnt_count = 0;
    sb.s_wtime = time(nullptr);
    sb.s_block_group_nr = 0;

    uint32_t gdt_size_bytes = num_block_groups * sizeof(SimpleFS_GroupDesc);
    uint32_t gdt_blocks = static_cast<uint32_t>(std::ceil(static_cast<double>(gdt_size_bytes) / SIMPLEFS_BLOCK_SIZE));
    std::cout << "  GDT size: " << gdt_size_bytes << " bytes, requiring " << gdt_blocks << " blocks." << std::endl;

    uint32_t superblock_location_block = 1;
    uint32_t gdt_start_block = superblock_location_block + 1;

    std::vector<SimpleFS_GroupDesc> gdt(num_block_groups);
    std::memset(gdt.data(), 0, gdt_size_bytes);

    uint32_t running_total_free_blocks = total_blocks_on_device;
    uint32_t running_total_free_inodes = sb.s_inodes_count;

    if (superblock_location_block < total_blocks_on_device) running_total_free_blocks--; else { std::cerr << "No space for SB!" << std::endl; return 1; }
    for(uint32_t i = 0; i < gdt_blocks; ++i) {
        if ((gdt_start_block + i) < total_blocks_on_device) running_total_free_blocks--; else { std::cerr << "No space for GDT!" << std::endl; return 1; }
    }

    uint32_t current_group_meta_start_block = gdt_start_block + gdt_blocks;

    for (uint32_t i = 0; i < num_block_groups; ++i) {
        SimpleFS_GroupDesc& current_gd = gdt[i];
        uint32_t group_abs_start_block_for_data = i * sb.s_blocks_per_group;
        uint32_t inode_table_size_blocks = static_cast<uint32_t>(std::ceil(static_cast<double>(sb.s_inodes_per_group) * SIMPLEFS_INODE_SIZE / SIMPLEFS_BLOCK_SIZE));

        bool backup_here = is_backup_group(i);

        if (i == 0) {
            current_gd.bg_block_bitmap = current_group_meta_start_block;
            current_gd.bg_inode_bitmap = current_gd.bg_block_bitmap + 1;
            current_gd.bg_inode_table  = current_gd.bg_inode_bitmap + 1;
            sb.s_first_data_block = current_gd.bg_inode_table + inode_table_size_blocks;
        } else if (backup_here) {
            current_gd.bg_block_bitmap = group_abs_start_block_for_data + 1 + gdt_blocks;
            current_gd.bg_inode_bitmap = current_gd.bg_block_bitmap + 1;
            current_gd.bg_inode_table  = current_gd.bg_inode_bitmap + 1;
        } else {
            current_gd.bg_block_bitmap = group_abs_start_block_for_data;
            current_gd.bg_inode_bitmap = current_gd.bg_block_bitmap + 1;
            current_gd.bg_inode_table  = current_gd.bg_inode_bitmap + 1;
        }

        uint32_t last_meta_block_for_group = current_gd.bg_inode_table + inode_table_size_blocks -1;
        if (last_meta_block_for_group >= total_blocks_on_device || current_gd.bg_block_bitmap >= total_blocks_on_device) {
             std::cerr << "错误: 组 " << i << " 的元数据超出设备限制" << std::endl; close(fd); if(create_new_image) unlink(device_path.c_str()); return 1;
        }

        running_total_free_blocks--;  // 块位图
        running_total_free_blocks--;  // inode位图
        running_total_free_blocks -= inode_table_size_blocks;  // inode表
        // 注意：主组（组0）的超级块和GDT已在前面减去，这里不重复减去
        if (backup_here && i != 0) {  // 只有备份组且不是组0才减去
            running_total_free_blocks--; // 备份超级块
            running_total_free_blocks -= gdt_blocks;  // 备份GDT
        }

        uint32_t blocks_in_this_group_range = (i == num_block_groups - 1) ?
                                     (total_blocks_on_device - group_abs_start_block_for_data) :
                                     sb.s_blocks_per_group;

        current_gd.bg_free_blocks_count = blocks_in_this_group_range;
        current_gd.bg_free_blocks_count -= 1;  // 块位图
        current_gd.bg_free_blocks_count -= 1;  // inode位图
        current_gd.bg_free_blocks_count -= inode_table_size_blocks;  // inode表
        if (i == 0) {
            current_gd.bg_free_blocks_count--; // 超级块
            current_gd.bg_free_blocks_count -= gdt_blocks;  // GDT
        } else if (backup_here) {
            current_gd.bg_free_blocks_count--; // 备份超级块
            current_gd.bg_free_blocks_count -= gdt_blocks;  // 备份GDT
        }

        // 主要SB/GDT的额外空闲块调整已在前面完成
        current_gd.bg_free_inodes_count = sb.s_inodes_per_group;
        current_gd.bg_used_dirs_count = 0;
    }

    sb.s_free_blocks_count = running_total_free_blocks;
    sb.s_free_inodes_count = running_total_free_inodes;

    if (gdt_start_block + gdt_blocks > gdt[0].bg_block_bitmap) {
        std::cerr << "严重错误: GDT与组0块位图重叠，设备太小或计算错误" << std::endl;
        close(fd); if(create_new_image) unlink(device_path.c_str()); return 1;
    }

    std::cout << "超级块(根目录前的最终估计值):" << std::endl;
    std::cout << "  空闲块数: " << sb.s_free_blocks_count << std::endl;
    std::cout << "  空闲inode数: " << sb.s_free_inodes_count << std::endl;
    std::cout << "  首个数据块(全局): " << sb.s_first_data_block << std::endl;

    std::vector<uint8_t> fs_block_buffer(SIMPLEFS_BLOCK_SIZE, 0);
    std::memcpy(fs_block_buffer.data(), &sb, sizeof(sb));
    if (write_block(fd, superblock_location_block, fs_block_buffer.data()) != 0) {
        std::cerr << "超级块写入失败" << std::endl; close(fd); if (create_new_image) unlink(device_path.c_str()); return 1;
    }
    std::cout << "超级块已写入块 " << superblock_location_block << std::endl;

    uint8_t* gdt_write_ptr = reinterpret_cast<uint8_t*>(gdt.data());
    for (uint32_t i = 0; i < gdt_blocks; ++i) {
        std::fill(fs_block_buffer.begin(), fs_block_buffer.end(), 0);
        uint32_t bytes_to_copy_this_block = (gdt_size_bytes - (i * SIMPLEFS_BLOCK_SIZE) < SIMPLEFS_BLOCK_SIZE) ?
                                            (gdt_size_bytes % SIMPLEFS_BLOCK_SIZE == 0 && gdt_size_bytes > 0 ? SIMPLEFS_BLOCK_SIZE : gdt_size_bytes % SIMPLEFS_BLOCK_SIZE)
                                            : SIMPLEFS_BLOCK_SIZE;
        if (gdt_size_bytes == 0 && i==0) bytes_to_copy_this_block = 0;

        std::memcpy(fs_block_buffer.data(), gdt_write_ptr + (i * SIMPLEFS_BLOCK_SIZE), bytes_to_copy_this_block);
        if (write_block(fd, gdt_start_block + i, fs_block_buffer.data()) != 0) {
            std::cerr << "GDT块 " << (gdt_start_block + i) << " 写入失败" << std::endl; close(fd); if (create_new_image) unlink(device_path.c_str()); return 1;
        }
    }
    std::cout << "GDT已写入块 " << gdt_start_block << " 到 " << (gdt_start_block + gdt_blocks - 1) << std::endl;

    std::vector<uint8_t> group_block_bitmap_buffer(SIMPLEFS_BLOCK_SIZE, 0);
    std::vector<uint8_t> group_inode_bitmap_buffer(SIMPLEFS_BLOCK_SIZE, 0);

    for (uint32_t i = 0; i < num_block_groups; ++i) {
        SimpleFS_GroupDesc& current_gd_ref = gdt[i];
        uint32_t group_abs_data_start_block = i * sb.s_blocks_per_group; // 这是该组位图中位0的块号
        uint32_t inode_table_size_blocks = static_cast<uint32_t>(std::ceil(static_cast<double>(sb.s_inodes_per_group) * SIMPLEFS_INODE_SIZE / SIMPLEFS_BLOCK_SIZE));

        std::cout << "Processing Group " << i << ":" << std::endl;
        std::cout << "  BB@" << current_gd_ref.bg_block_bitmap << ", IB@" << current_gd_ref.bg_inode_bitmap << ", IT@" << current_gd_ref.bg_inode_table << " (" << inode_table_size_blocks << " blocks)" << std::endl;

        std::fill(group_block_bitmap_buffer.begin(), group_block_bitmap_buffer.end(), 0);
        std::fill(group_inode_bitmap_buffer.begin(), group_inode_bitmap_buffer.end(), 0);

        // 在其块位图中将组自己的元数据块标记为已使用
        // 组位图中的位索引相对于该组管理的块起始位置
        set_bitmap_bit(group_block_bitmap_buffer, current_gd_ref.bg_block_bitmap - group_abs_data_start_block);
        set_bitmap_bit(group_block_bitmap_buffer, current_gd_ref.bg_inode_bitmap - group_abs_data_start_block);
        for (uint32_t j = 0; j < inode_table_size_blocks; ++j) {
            set_bitmap_bit(group_block_bitmap_buffer, (current_gd_ref.bg_inode_table + j) - group_abs_data_start_block);
        }

        bool backup_here = is_backup_group(i);
        if (backup_here) {
            uint32_t sb_blk = (i == 0) ? superblock_location_block : group_abs_data_start_block;
            set_bitmap_bit(group_block_bitmap_buffer, sb_blk - group_abs_data_start_block);
            for (uint32_t gdt_idx = 0; gdt_idx < gdt_blocks; ++gdt_idx) {
                uint32_t abs_gdt_block = (i == 0) ? (gdt_start_block + gdt_idx)
                                                 : (group_abs_data_start_block + 1 + gdt_idx);
                set_bitmap_bit(group_block_bitmap_buffer, abs_gdt_block - group_abs_data_start_block);
            }


        }
        if (i == 0) {
            if (!is_bitmap_bit_set(group_block_bitmap_buffer, 0)) {
                set_bitmap_bit(group_block_bitmap_buffer, 0);
                bool block0_was_sb = (superblock_location_block == 0);
                bool block0_was_gdt = false;
                for(uint32_t gdt_idx=0; gdt_idx < gdt_blocks; ++gdt_idx) if((gdt_start_block + gdt_idx) == 0) block0_was_gdt = true;
                bool block0_was_group0_bb = (current_gd_ref.bg_block_bitmap == 0);
                bool block0_was_group0_ib = (current_gd_ref.bg_inode_bitmap == 0);
                bool block0_was_group0_it = (current_gd_ref.bg_inode_table == 0);
                if (!block0_was_sb && !block0_was_gdt && !block0_was_group0_bb && !block0_was_group0_ib && !block0_was_group0_it) {
                    if (current_gd_ref.bg_free_blocks_count > 0) current_gd_ref.bg_free_blocks_count--;
                    if (sb.s_free_blocks_count > 0) sb.s_free_blocks_count--;
                }
            }
            set_bitmap_bit(group_inode_bitmap_buffer, 0);
            set_bitmap_bit(group_inode_bitmap_buffer, 1);
            if (current_gd_ref.bg_free_inodes_count >= 2) current_gd_ref.bg_free_inodes_count -= 2; else current_gd_ref.bg_free_inodes_count = 0;
            if (sb.s_free_inodes_count >= 2) sb.s_free_inodes_count -= 2; else sb.s_free_inodes_count = 0;
        }

        if (write_block(fd, current_gd_ref.bg_block_bitmap, group_block_bitmap_buffer.data()) != 0) { /* error */ return 1; }
        std::cout << "    Written Block Bitmap. Group free blocks: " << current_gd_ref.bg_free_blocks_count << std::endl;

        if (write_block(fd, current_gd_ref.bg_inode_bitmap, group_inode_bitmap_buffer.data()) != 0) { /* error */ return 1; }
        std::cout << "    Written Inode Bitmap. Group free inodes: " << current_gd_ref.bg_free_inodes_count << std::endl;

        if (write_zero_blocks(fd, current_gd_ref.bg_inode_table, inode_table_size_blocks) != 0) { /* error */ return 1; }
        std::cout << "    Zeroed Inode Table." << std::endl;
    }

    std::cout << "Re-writing Superblock and GDT (final pre-root dir)..." << std::endl;
    std::memcpy(fs_block_buffer.data(), &sb, sizeof(sb));
    if (write_block(fd, superblock_location_block, fs_block_buffer.data()) != 0) { /* error */ return 1;}

    gdt_write_ptr = reinterpret_cast<uint8_t*>(gdt.data());
    for (uint32_t i = 0; i < gdt_blocks; ++i) {
        std::fill(fs_block_buffer.begin(), fs_block_buffer.end(), 0);
        uint32_t bytes_to_copy_this_block = (gdt_size_bytes - (i * SIMPLEFS_BLOCK_SIZE) < SIMPLEFS_BLOCK_SIZE) ?
                                            (gdt_size_bytes % SIMPLEFS_BLOCK_SIZE == 0 && gdt_size_bytes > 0 ? SIMPLEFS_BLOCK_SIZE : gdt_size_bytes % SIMPLEFS_BLOCK_SIZE)
                                            : SIMPLEFS_BLOCK_SIZE;
        if (gdt_size_bytes == 0 && i==0) bytes_to_copy_this_block = 0;
        std::memcpy(fs_block_buffer.data(), gdt_write_ptr + (i * SIMPLEFS_BLOCK_SIZE), bytes_to_copy_this_block);
        if (write_block(fd, gdt_start_block + i, fs_block_buffer.data()) != 0) { /* error */ return 1; }
    }

    // 将超级块和GDT的备份副本写入指定组
    for (uint32_t grp = 1; grp < num_block_groups; ++grp) {
        if (!is_backup_group(grp)) continue;
        uint32_t grp_start = grp * sb.s_blocks_per_group;
        std::memcpy(fs_block_buffer.data(), &sb, sizeof(sb));
        if (write_block(fd, grp_start, fs_block_buffer.data()) != 0) { /* error */ return 1; }
        for (uint32_t i = 0; i < gdt_blocks; ++i) {
            std::fill(fs_block_buffer.begin(), fs_block_buffer.end(), 0);
            uint32_t bytes_to_copy_this_block = (gdt_size_bytes - (i * SIMPLEFS_BLOCK_SIZE) < SIMPLEFS_BLOCK_SIZE) ?
                                                (gdt_size_bytes % SIMPLEFS_BLOCK_SIZE == 0 && gdt_size_bytes > 0 ? SIMPLEFS_BLOCK_SIZE : gdt_size_bytes % SIMPLEFS_BLOCK_SIZE)
                                                : SIMPLEFS_BLOCK_SIZE;
            if (gdt_size_bytes == 0 && i==0) bytes_to_copy_this_block = 0;
            std::memcpy(fs_block_buffer.data(), gdt_write_ptr + (i * SIMPLEFS_BLOCK_SIZE), bytes_to_copy_this_block);
            if (write_block(fd, grp_start + 1 + i, fs_block_buffer.data()) != 0) { /* error */ return 1; }
        }
    }

    std::cout << "Creating root directory..." << std::endl;

    SimpleFS_GroupDesc& group0_gd = gdt[0];
    // 根inode（SIMPLEFS_ROOT_INODE_NUM，通常为2）和inode 1（位0）
    // 已在inode位图中标记，以及超级块/组描述符
    // 在组0的初始设置循环中已减少了空闲inode计数
    // 因此，此处不需要再次调用set_bitmap_bit或减少计数
    // 只需为组0增加used_dirs_count
    group0_gd.bg_used_dirs_count++;

    std::cout << "  Root inode " << SIMPLEFS_ROOT_INODE_NUM << " allocation accounted for (marked in bitmap and counts updated earlier)." << std::endl;
    std::cout << "  Incremented used_dirs_count for group 0." << std::endl;

    // 如果后续决策依赖于最新状态，重新读取inode位图是好习惯
    // 但此处不对根inode号本身做分配决策，只分配其数据块，故继续进行
    // 如有疑问，可重新读取：
    // if (read_block(fd, group0_gd.bg_inode_bitmap, group_inode_bitmap_buffer.data()) != 0) {
    //     std::cerr << "根目录数据分配前重新读取组0 inode位图失败" << std::endl; return 1;
    // }

    uint32_t root_dir_data_block_num = 0;
    if (read_block(fd, group0_gd.bg_block_bitmap, group_block_bitmap_buffer.data()) != 0) {
         std::cerr << "组0块位图读取失败，无法分配根目录数据块" << std::endl; return 1;
    }

    uint32_t group0_abs_start_block = 0 * sb.s_blocks_per_group;
    uint32_t search_start_offset_in_group0 = 0;
    if (sb.s_first_data_block >= group0_abs_start_block && sb.s_first_data_block < (group0_abs_start_block + sb.s_blocks_per_group) ) {
        search_start_offset_in_group0 = sb.s_first_data_block - group0_abs_start_block;
    } else if (sb.s_first_data_block < group0_abs_start_block) {
         search_start_offset_in_group0 = (gdt[0].bg_inode_table + static_cast<uint32_t>(std::ceil(static_cast<double>(sb.s_inodes_per_group) * SIMPLEFS_INODE_SIZE / SIMPLEFS_BLOCK_SIZE))) - group0_abs_start_block;
    }

    for (uint32_t block_offset_in_group = search_start_offset_in_group0;
         block_offset_in_group < sb.s_blocks_per_group; ++block_offset_in_group) {
        if (!is_bitmap_bit_set(group_block_bitmap_buffer, block_offset_in_group)) {
            root_dir_data_block_num = group0_abs_start_block + block_offset_in_group;
            set_bitmap_bit(group_block_bitmap_buffer, block_offset_in_group);
            group0_gd.bg_free_blocks_count--;
            sb.s_free_blocks_count--;
            break;
        }
    }

    if (root_dir_data_block_num == 0) {
        std::cerr << "错误: 组0中找不到根目录的空闲数据块" << std::endl; return 1;
    }
    if (write_block(fd, group0_gd.bg_block_bitmap, group_block_bitmap_buffer.data()) != 0) {
        std::cerr << "组0块位图更新失败" << std::endl; return 1;
    }
    std::cout << "  已为根目录分配数据块 " << root_dir_data_block_num << std::endl;

    std::vector<uint8_t> root_dir_data_buffer(SIMPLEFS_BLOCK_SIZE, 0);
    uint16_t current_offset = 0;

    SimpleFS_DirEntry dot_entry;
    dot_entry.inode = SIMPLEFS_ROOT_INODE_NUM;
    dot_entry.name_len = 1;
    dot_entry.file_type = S_IFDIR >> 12;
    std::strncpy(dot_entry.name, ".", 1);
    dot_entry.rec_len = calculate_dir_entry_len(dot_entry.name_len);
    std::memcpy(root_dir_data_buffer.data() + current_offset, &dot_entry, (size_t)8 + dot_entry.name_len);
    current_offset += dot_entry.rec_len;

    SimpleFS_DirEntry dotdot_entry;
    dotdot_entry.inode = SIMPLEFS_ROOT_INODE_NUM;
    dotdot_entry.name_len = 2;
    dotdot_entry.file_type = S_IFDIR >> 12;
    std::strncpy(dotdot_entry.name, "..", 2);
    dotdot_entry.rec_len = SIMPLEFS_BLOCK_SIZE - current_offset;
    std::memcpy(root_dir_data_buffer.data() + current_offset, &dotdot_entry, (size_t)8 + dotdot_entry.name_len);

    if (write_block(fd, root_dir_data_block_num, root_dir_data_buffer.data()) != 0) {
        std::cerr << "根目录数据块写入失败" << std::endl; return 1;
    }
    std::cout << "  已向根目录数据块写入'.'和'..'项" << std::endl;

    SimpleFS_Inode root_inode;
    std::memset(&root_inode, 0, sizeof(SimpleFS_Inode));
    root_inode.i_mode = S_IFDIR | 0777; // 从0755改为0777便于测试
    root_inode.i_uid = 0;
    root_inode.i_gid = 0;
    root_inode.i_size = SIMPLEFS_BLOCK_SIZE;
    root_inode.i_links_count = 2;
    root_inode.i_blocks = SIMPLEFS_BLOCK_SIZE / 512;
    root_inode.i_atime = root_inode.i_ctime = root_inode.i_mtime = time(nullptr);
    root_inode.i_block[0] = root_dir_data_block_num;

    // 基于1的inode编号的修正计算
    uint32_t root_inode_idx_in_group = SIMPLEFS_ROOT_INODE_NUM - 1; 
    uint32_t root_inode_block_in_table = group0_gd.bg_inode_table + (root_inode_idx_in_group / inodes_per_block);
    uint32_t root_inode_offset_in_block = (root_inode_idx_in_group % inodes_per_block) * SIMPLEFS_INODE_SIZE;

    std::vector<uint8_t> inode_table_block_buffer(SIMPLEFS_BLOCK_SIZE);
    if (read_block(fd, root_inode_block_in_table, inode_table_block_buffer.data()) != 0) {
        std::cerr << "根inode的inode表块读取失败" << std::endl; return 1;
    }
    std::memcpy(inode_table_block_buffer.data() + root_inode_offset_in_block, &root_inode, sizeof(SimpleFS_Inode));
    if (write_block(fd, root_inode_block_in_table, inode_table_block_buffer.data()) != 0) {
        std::cerr << "根inode写入inode表失败" << std::endl; return 1;
    }
    std::cout << "  Initialized and written root inode (inode " << SIMPLEFS_ROOT_INODE_NUM << ")." << std::endl;

    std::cout << "Finalizing Superblock and GDT..." << std::endl;
    std::memcpy(fs_block_buffer.data(), &sb, sizeof(sb));
    if (write_block(fd, superblock_location_block, fs_block_buffer.data()) != 0) { /* error */ return 1;}

    gdt_write_ptr = reinterpret_cast<uint8_t*>(gdt.data());
    for (uint32_t i = 0; i < gdt_blocks; ++i) {
        std::fill(fs_block_buffer.begin(), fs_block_buffer.end(), 0);
        uint32_t bytes_to_copy_this_block = (gdt_size_bytes - (i * SIMPLEFS_BLOCK_SIZE) < SIMPLEFS_BLOCK_SIZE) ?
                                            (gdt_size_bytes % SIMPLEFS_BLOCK_SIZE == 0 && gdt_size_bytes > 0 ? SIMPLEFS_BLOCK_SIZE : gdt_size_bytes % SIMPLEFS_BLOCK_SIZE)
                                            : SIMPLEFS_BLOCK_SIZE;
        if (gdt_size_bytes == 0 && i==0) bytes_to_copy_this_block = 0;
        std::memcpy(fs_block_buffer.data(), gdt_write_ptr + (i * SIMPLEFS_BLOCK_SIZE), bytes_to_copy_this_block);
        if (write_block(fd, gdt_start_block + i, fs_block_buffer.data()) != 0) { /* error */ return 1; }
    }
    std::cout << "超级块和GDT已完成" << std::endl;

    std::cout << "文件系统格式化成功" << std::endl;

    if (close(fd) == -1) {
        perror("关闭设备/镜像失败");
    }

    std::cout << "SimpleFS格式化工具完成" << std::endl;
    return 0;
}