use crate::disk::block::{DataBlock, DoubleIndirectBlock, IndirectBlock};
use crate::disk::inode::InodeMode;
use crate::tests::common;

#[test]
fn test_basic_lru() {
    let mut fs = common::setup();

    let v: Vec<usize> = (1..=256)
        .map(|_| {
            let index = fs.data_bitmap.allocate().unwrap();
            fs.get_block::<DataBlock>(index).unwrap();
            index
        })
        .collect();
    assert!(fs.peek_block::<DataBlock>(v[0]).is_some());

    for i in 0..256 {
        let index = fs.data_bitmap.allocate().unwrap();
        fs.get_block::<DataBlock>(index).unwrap();
        assert!(fs.peek_block::<DataBlock>(v[i]).is_none());
    }
}

#[test]
fn test_inode() {
    let mut fs = common::setup();

    let inode_index = fs.create_inode(0o755, InodeMode::IFDIR, 0, 0, 0).unwrap();
    let mut inode = fs.get_inode(inode_index).unwrap().clone();

    const DIRECT_NUMBER: u32 = 15;
    const INDIRECT_NUMBER: u32 = 1024;
    const DOUBLE_INDIRECT_NUMBER: u32 = 1024 * 1024;

    for i in 0..DIRECT_NUMBER {
        fs.allocate_block_for(&mut inode).unwrap();
        assert!(fs.data_bitmap.query(inode.direct[i as usize] as usize))
    }

    for i in 0..INDIRECT_NUMBER {
        fs.allocate_block_for(&mut inode).unwrap();
    }

    for i in 0..DOUBLE_INDIRECT_NUMBER {
        fs.allocate_block_for(&mut inode).unwrap();
    }

    let single_indirect = inode.single_indirect;
    let double_indirect = inode.double_indirect;
    let triple_indirect = inode.triple_indirect;

    fs.update_inode(inode_index, inode);

    let indirect_block = fs
        .peek_block::<IndirectBlock>(single_indirect as usize)
        .unwrap();
    for entry in indirect_block.block.entries {
        assert_ne!(entry, 0);
        assert!(fs.data_bitmap.query(entry as usize));
    }

    // let double_indirect_block = fs
    //     .peek_block::<DoubleIndirectBlock>(double_indirect as usize)
    //     .unwrap();
    // for indirect_entry in double_indirect_block.block.indirect {
    //     let indirect_block = fs
    //         .peek_block::<IndirectBlock>(indirect_entry as usize)
    //         .unwrap();
    //     for entry in indirect_block.block.entries {
    //         assert_ne!(entry, 0);
    //         assert!(fs.data_bitmap.query(entry as usize));
    //     }
    // }

    assert_eq!(fs.data_bitmap.query(double_indirect as usize), false);

    assert_eq!(fs.data_bitmap.query(triple_indirect as usize), false);
}