use std;
use std::io;

use ::Time;

use ::parse_error;
use ::errors::*;
use ::errors::Result;
use ::errors::ErrorKind::*;

use ::read_le16;
use ::read_le32;

use std::collections::HashMap;

use crc;

use byteorder::{ReadBytesExt, LittleEndian, ByteOrder};

use std::io::Read;
use std::io::Seek;

const EXT4_SUPER_MAGIC: u16 = 0xEF53;
const INODE_BASE_LEN: usize = 128;
const XATTR_MAGIC: u32 = 0xEA020000;

bitflags! {
    struct CompatibleFeature: u32 {
        const DIR_PREALLOC  = 0x0001;
        const IMAGIC_INODES = 0x0002;
        const HAS_JOURNAL   = 0x0004;
        const EXT_ATTR      = 0x0008;
        const RESIZE_INODE  = 0x0010;
        const DIR_INDEX     = 0x0020;
        const SPARSE_SUPER2 = 0x0200;
    }
}

bitflags! {
    struct CompatibleFeatureReadOnly: u32 {
        const SPARSE_SUPER  = 0x0001;
        const LARGE_FILE    = 0x0002;
        const BTREE_DIR     = 0x0004;
        const HUGE_FILE     = 0x0008;
        const GDT_CSUM      = 0x0010;
        const DIR_NLINK     = 0x0020;
        const EXTRA_ISIZE   = 0x0040;
        const QUOTA         = 0x0100;
        const BIGALLOC      = 0x0200;
        const METADATA_CSUM = 0x0400;
        const READONLY      = 0x1000;
        const PROJECT       = 0x2000;

    }
}

bitflags! {
    struct IncompatibleFeature: u32 {
       const INCOMPAT_COMPRESSION = 0x0001;
       const INCOMPAT_FILETYPE    = 0x0002;
       const INCOMPAT_RECOVER     = 0x0004; /* Needs recovery */
       const INCOMPAT_JOURNAL_DEV = 0x0008; /* Journal device */
       const INCOMPAT_META_BG     = 0x0010;
       const INCOMPAT_EXTENTS     = 0x0040; /* extents support */
       const INCOMPAT_64BIT       = 0x0080;
       const INCOMPAT_MMP         = 0x0100;
       const INCOMPAT_FLEX_BG     = 0x0200;
       const INCOMPAT_EA_INODE    = 0x0400; /* EA in inode */
       const INCOMPAT_DIRDATA     = 0x1000; /* data in dirent */
       const INCOMPAT_CSUM_SEED   = 0x2000;
       const INCOMPAT_LARGEDIR    = 0x4000; /* >2GB or 3-lvl htree */
       const INCOMPAT_INLINE_DATA = 0x8000; /* data in inode */
       const INCOMPAT_ENCRYPT     = 0x10000;
    }
}

pub fn superblock<R>(mut reader: R, options: &::Options) -> Result<::SuperBlock<R>>
where R: io::Read + io::Seek {

    let mut entire_superblock = [0u8; 1024];
    reader.read_exact(&mut entire_superblock)?;

    let mut inner = io::Cursor::new(&mut entire_superblock[..]);

    // <a cut -c 9- | fgrep ' s_' | fgrep -v ERR_ | while read ty nam comment; do printf "let %s =\n  inner.read_%s::<LittleEndian>()?; %s\n" $(echo $nam | tr -d ';') $(echo $ty | sed 's/__le/u/; s/__//') $comment; done
//    let s_inodes_count =
        inner.read_u32::<LittleEndian>()?; /* Inodes count */
    let s_blocks_count_lo =
        inner.read_u32::<LittleEndian>()?; /* Blocks count */
//    let s_r_blocks_count_lo =
        inner.read_u32::<LittleEndian>()?; /* Reserved blocks count */
//    let s_free_blocks_count_lo =
        inner.read_u32::<LittleEndian>()?; /* Free blocks count */
//    let s_free_inodes_count =
        inner.read_u32::<LittleEndian>()?; /* Free inodes count */
    let s_first_data_block =
        inner.read_u32::<LittleEndian>()?; /* First Data Block */
    let s_log_block_size =
        inner.read_u32::<LittleEndian>()?; /* Block size */
//    let s_log_cluster_size =
        inner.read_u32::<LittleEndian>()?; /* Allocation cluster size */
    let s_blocks_per_group =
        inner.read_u32::<LittleEndian>()?; /* # Blocks per group */
//    let s_clusters_per_group =
        inner.read_u32::<LittleEndian>()?; /* # Clusters per group */
    let s_inodes_per_group =
        inner.read_u32::<LittleEndian>()?; /* # Inodes per group */
//    let s_mtime =
        inner.read_u32::<LittleEndian>()?; /* Mount time */
//    let s_wtime =
        inner.read_u32::<LittleEndian>()?; /* Write time */
//    let s_mnt_count =
        inner.read_u16::<LittleEndian>()?; /* Mount count */
//    let s_max_mnt_count =
        inner.read_u16::<LittleEndian>()?; /* Maximal mount count */
    let s_magic =
        inner.read_u16::<LittleEndian>()?; /* Magic signature */

    ensure!(EXT4_SUPER_MAGIC == s_magic,
        NotFound(format!("invalid magic number: {:x}", s_magic)));

    let s_state =
        inner.read_u16::<LittleEndian>()?; /* File system state */
//    let s_errors =
        inner.read_u16::<LittleEndian>()?; /* Behaviour when detecting errors */
//    let s_minor_rev_level =
        inner.read_u16::<LittleEndian>()?; /* minor revision level */
//    let s_lastcheck =
        inner.read_u32::<LittleEndian>()?; /* time of last check */
//    let s_checkinterval =
        inner.read_u32::<LittleEndian>()?; /* max. time between checks */
    let s_creator_os =
        inner.read_u32::<LittleEndian>()?; /* OS */

    ensure!(0 == s_creator_os,
        UnsupportedFeature(format!("only support filesystems created on linux, not '{}'", s_creator_os)));

    let s_rev_level =
        inner.read_u32::<LittleEndian>()?; /* Revision level */
//    let s_def_resuid =
        inner.read_u16::<LittleEndian>()?; /* Default uid for reserved blocks */
//    let s_def_resgid =
        inner.read_u16::<LittleEndian>()?; /* Default gid for reserved blocks */
//    let s_first_ino =
        inner.read_u32::<LittleEndian>()?; /* First non-reserved inode */
    let s_inode_size =
        inner.read_u16::<LittleEndian>()?; /* size of inode structure */
//    let s_block_group_nr =
        inner.read_u16::<LittleEndian>()?; /* block group # of this superblock */
    let s_feature_compat =
        inner.read_u32::<LittleEndian>()?; /* compatible feature set */

    let compatible_features = CompatibleFeature::from_bits_truncate(s_feature_compat);

    let load_xattrs = compatible_features.contains(EXT_ATTR);

    let s_feature_incompat =
        inner.read_u32::<LittleEndian>()?; /* incompatible feature set */

    let incompatible_features = IncompatibleFeature::from_bits(s_feature_incompat)
        .ok_or_else(|| parse_error(format!("completely unsupported incompatible feature flag: {:b}", s_feature_incompat)))?;

    let supported_incompatible_features =
        INCOMPAT_FILETYPE
            | INCOMPAT_EXTENTS
            | INCOMPAT_FLEX_BG
            | INCOMPAT_RECOVER
            | INCOMPAT_64BIT;

    if incompatible_features.intersects(!supported_incompatible_features) {
        return Err(parse_error(format!("some unsupported incompatible feature flags: {:?}",
                                       incompatible_features & !supported_incompatible_features)));
    }

    let long_structs = incompatible_features.contains(INCOMPAT_64BIT);

    let s_feature_ro_compat =
        inner.read_u32::<LittleEndian>()?; /* readonly-compatible feature set */

    let compatible_features_read_only = CompatibleFeatureReadOnly::from_bits_truncate(s_feature_ro_compat);

    let has_checksums = compatible_features_read_only.contains(METADATA_CSUM);

    ensure!(!(has_checksums && compatible_features_read_only.contains(GDT_CSUM)),
        AssumptionFailed("metadata checksums are incompatible with the GDT checksum feature".to_string())
    );

    ensure!(has_checksums || ::Checksums::Required != options.checksums,
        NotFound("checksums are disabled, but required by options".to_string()));

    let mut s_uuid = [0; 16];
    inner.read_exact(&mut s_uuid)?; /* 128-bit uuid for volume */
    let mut s_volume_name = [0u8; 16];
    inner.read_exact(&mut s_volume_name)?; /* volume name */
    let mut s_last_mounted = [0u8; 64];
    inner.read_exact(&mut s_last_mounted)?; /* directory where last mounted */
//    let s_algorithm_usage_bitmap =
        inner.read_u32::<LittleEndian>()?; /* For compression */
//    let s_prealloc_blocks =
        inner.read_u8()?; /* Nr of blocks to try to preallocate*/
//    let s_prealloc_dir_blocks =
        inner.read_u8()?; /* Nr to preallocate for dirs */
//    let s_reserved_gdt_blocks =
        inner.read_u16::<LittleEndian>()?; /* Per group desc for online growth */
    let mut s_journal_uuid = [0u8; 16];
    inner.read_exact(&mut s_journal_uuid)?; /* uuid of journal superblock */
//    let s_journal_inum =
        inner.read_u32::<LittleEndian>()?; /* inode number of journal file */
//    let s_journal_dev =
        inner.read_u32::<LittleEndian>()?; /* device number of journal file */
//    let s_last_orphan =
        inner.read_u32::<LittleEndian>()?; /* start of list of inodes to delete */
    let mut s_hash_seed = [0u8; 4 * 4];
    inner.read_exact(&mut s_hash_seed)?; /* HTREE hash seed */
//    let s_def_hash_version =
        inner.read_u8()?; /* Default hash version to use */
//    let s_jnl_backup_type =
        inner.read_u8()?;
    let s_desc_size =
        inner.read_u16::<LittleEndian>()?; /* size of group descriptor */
//    let s_default_mount_opts =
        inner.read_u32::<LittleEndian>()?;
//    let s_first_meta_bg =
        inner.read_u32::<LittleEndian>()?; /* First metablock block group */
//    let s_mkfs_time =
        inner.read_u32::<LittleEndian>()?; /* When the filesystem was created */
    let mut s_jnl_blocks = [0; 17 * 4];
    inner.read_exact(&mut s_jnl_blocks)?; /* Backup of the journal inode */

    let s_blocks_count_hi =
        if !long_structs { None } else {
            Some(inner.read_u32::<LittleEndian>()?) /* Blocks count */
        };
////    let s_r_blocks_count_hi =
//        if !long_structs { None } else {
//            Some(inner.read_u32::<LittleEndian>()?) /* Reserved blocks count */
//        };
////    let s_free_blocks_count_hi =
//        if !long_structs { None } else {
//            Some(inner.read_u32::<LittleEndian>()?) /* Free blocks count */
//        };
////    let s_min_extra_isize =
//        if !long_structs { None } else {
//            Some(inner.read_u16::<LittleEndian>()?) /* All inodes have at least # bytes */
//        };
////    let s_want_extra_isize =
//        if !long_structs { None } else {
//            Some(inner.read_u16::<LittleEndian>()?) /* New inodes should reserve # bytes */
//        };
////    let s_flags =
//        if !long_structs { None } else {
//            Some(inner.read_u32::<LittleEndian>()?) /* Miscellaneous flags */
//        };

    // TODO: check s_checksum_type == 1 (crc32c)

    if has_checksums {
        inner.seek(io::SeekFrom::End(-4))?;
        let s_checksum = inner.read_u32::<LittleEndian>()?;
        let expected = ext4_style_crc32c_le(!0, &inner.into_inner()[..(1024-4)]);
        ensure!(s_checksum == expected,
            AssumptionFailed(format!("superblock reports checksums supported, but didn't match: {:x} != {:x}",
                s_checksum, expected)));
    }

    {
        const S_STATE_UNMOUNTED_CLEANLY: u16 = 0b01;
        const S_STATE_ERRORS_DETECTED: u16 = 0b10;

        if s_state & S_STATE_UNMOUNTED_CLEANLY == 0 || s_state & S_STATE_ERRORS_DETECTED != 0 {
            return Err(parse_error(format!("filesystem is not in a clean state: {:b}", s_state)));
        }
    }

    if 0 == s_inodes_per_group {
        return Err(parse_error("inodes per group cannot be zero".to_string()));
    }

    let block_size: u32 = match s_log_block_size {
        0 => 1024,
        1 => 2048,
        2 => 4096,
        6 => 65536,
        _ => {
            return Err(parse_error(format!("unexpected block size: 2^{}", s_log_block_size + 10)));
        }
    };

    if !long_structs {
        ensure!(0 == s_desc_size,
            AssumptionFailed(format!("outside long mode, block group desc size must be zero, not {}", s_desc_size)));
    }

    ensure!(1 == s_rev_level,
        UnsupportedFeature(format!("rev level {}", s_rev_level)));

    let group_table_pos = if 1024 == block_size {
        // for 1k blocks, the table is in the third block, after:
        1024   // boot sector
        + 1024 // superblock
    } else {
        // for other blocks, the boot sector is in the first 1k of the first block,
        // followed by the superblock (also in first block), and the group table is afterwards
        block_size
    };

    reader.seek(io::SeekFrom::Start(group_table_pos as u64))?;
    let blocks_count = (
        s_blocks_count_lo as u64
        + ((s_blocks_count_hi.unwrap_or(0) as u64) << 32)
        - s_first_data_block as u64 + s_blocks_per_group as u64 - 1
    ) / s_blocks_per_group as u64;

    let groups = ::block_groups::BlockGroups::new(&mut reader, blocks_count,
                                                s_desc_size, s_inodes_per_group,
                                                block_size, s_inode_size)?;

    let uuid_checksum = if has_checksums {
        // TODO: check s_checksum_seed
        Some(ext4_style_crc32c_le(!0, &s_uuid))
    } else {
        None
    };

    Ok(::SuperBlock {
        inner: reader,
        load_xattrs,
        uuid_checksum,
        groups,
    })
}

pub struct ParsedInode {
    pub stat: ::Stat,
    pub flags: ::InodeFlags,
    pub core: [u8; ::INODE_CORE_SIZE],
    pub checksum_prefix: Option<u32>,
}

pub fn inode<F>(mut data: Vec<u8>, load_block: F, uuid_checksum: Option<u32>, number: u32) -> Result<ParsedInode>
where F: FnOnce(u64) -> Result<Vec<u8>> {

    ensure!(data.len() >= INODE_BASE_LEN,
        AssumptionFailed("inode isn't bigger than the minimum length".to_string()));

    // generated from inode.spec by structs.py
    let i_mode            = read_le16(&data[0x00..0x02]); /* File mode */
    let i_uid             = read_le16(&data[0x02..0x04]); /* Low 16 bits of Owner Uid */
    let i_size_lo         = read_le32(&data[0x04..0x08]); /* Size in bytes */
    let i_atime           = read_le32(&data[0x08..0x0C]); /* Access time */
    let i_ctime           = read_le32(&data[0x0C..0x10]); /* Inode Change time */
    let i_mtime           = read_le32(&data[0x10..0x14]); /* Modification time */
//    let i_dtime           = read_le32(&data[0x14..0x18]); /* Deletion Time */
    let i_gid             = read_le16(&data[0x18..0x1A]); /* Low 16 bits of Group Id */
    let i_links_count     = read_le16(&data[0x1A..0x1C]); /* Links count */
//    let i_blocks_lo       = read_le32(&data[0x1C..0x20]); /* Blocks count */
    let i_flags           = read_le32(&data[0x20..0x24]); /* File flags */
//    let l_i_version       = read_le32(&data[0x24..0x28]);

    let mut i_block = [0u8; ::INODE_CORE_SIZE];
    i_block.clone_from_slice(&data[0x28..0x64]);   /* Pointers to blocks */

    let i_generation      = read_le32(&data[0x64..0x68]); /* File version (for NFS) */
    let i_file_acl_lo     = read_le32(&data[0x68..0x6C]); /* File ACL */
    let i_size_high       = read_le32(&data[0x6C..0x70]);
//    let i_obso_faddr      = read_le32(&data[0x70..0x74]); /* Obsoleted fragment address */
//    let l_i_blocks_high   = read_le16(&data[0x74..0x76]); /* were l_i_reserved1 */
    let l_i_file_acl_high = read_le16(&data[0x76..0x78]);
    let l_i_uid_high      = read_le16(&data[0x78..0x7A]); /* these 2 fields */
    let l_i_gid_high      = read_le16(&data[0x7A..0x7C]); /* were reserved2[0] */
    let l_i_checksum_lo   = read_le16(&data[0x7C..0x7E]); /* crc32c(uuid+inum+inode) LE */
//    let l_i_reserved      = read_le16(&data[0x7E..0x80]);

    let i_extra_isize     = if data.len() < 0x82 { 0 } else { read_le16(&data[0x80..0x82]) };
    let inode_end = INODE_BASE_LEN + i_extra_isize as usize;

    ensure!(inode_end <= data.len(),
        AssumptionFailed(format!("more extra inode ({}) than inode ({})", inode_end, data.len())));

    let i_checksum_hi     = if i_extra_isize <  2 + 2 { None } else { Some(read_le16(&data[0x82..0x84])) }; /* crc32c(uuid+inum+inode) BE */
    let i_ctime_extra     = if i_extra_isize <  6 + 2 { None } else { Some(read_le32(&data[0x84..0x88])) }; /* extra Change time      (nsec << 2 | epoch) */
    let i_mtime_extra     = if i_extra_isize < 10 + 2 { None } else { Some(read_le32(&data[0x88..0x8C])) }; /* extra Modification time(nsec << 2 | epoch) */
    let i_atime_extra     = if i_extra_isize < 14 + 2 { None } else { Some(read_le32(&data[0x8C..0x90])) }; /* extra Access time      (nsec << 2 | epoch) */
    let i_crtime          = if i_extra_isize < 18 + 2 { None } else { Some(read_le32(&data[0x90..0x94])) }; /* File Creation time */
    let i_crtime_extra    = if i_extra_isize < 22 + 2 { None } else { Some(read_le32(&data[0x94..0x98])) }; /* extra FileCreationtime (nsec << 2 | epoch) */
//    let i_version_hi      = if i_extra_isize < 26 { None } else { Some(read_le32(&data[0x98..0x9C])) }; /* high 32 bits for 64-bit version */
//    let i_projid          = if i_extra_isize < 30 { None } else { Some(read_le32(&data[0x9C..0xA0])) }; /* Project ID */

    let mut checksum_prefix = None;

    if let Some(uuid_checksum) = uuid_checksum {
        data[0x7C] = 0;
        data[0x7D] = 0;

        let mut bytes = [0u8; 8];
        LittleEndian::write_u32(&mut bytes[0..4], number);
        LittleEndian::write_u32(&mut bytes[4..8], i_generation);
        checksum_prefix = Some(ext4_style_crc32c_le(uuid_checksum, &bytes));

        if i_checksum_hi.is_some() {
            data[0x82] = 0;
            data[0x83] = 0;
        }

        let computed = ext4_style_crc32c_le(checksum_prefix.unwrap(), &data);

        if let Some(high) = i_checksum_hi {
            let expected = (l_i_checksum_lo as u32) | ((high as u32) << 16);
            ensure!(expected == computed,
                AssumptionFailed(format!("full checksum mismatch: on-disc: {:08x} computed: {:08x}",
                    expected, computed)));
        } else {
            let short_computed = computed as u16;
            ensure!(l_i_checksum_lo == short_computed,
                AssumptionFailed(format!("short checksum mismatch: on-disc: {:04x} computed: {:04x}",
                    l_i_checksum_lo, short_computed)));
        }
    }

    // extended attributes after the inode
    let mut xattrs = HashMap::new();

    if inode_end + 4 <= data.len() && XATTR_MAGIC == read_le32(&data[inode_end..(inode_end + 4)]) {
        let table_start = &data[inode_end + 4..];
        read_xattrs(&mut xattrs, table_start, table_start)?;
    }

    if 0 != i_file_acl_lo || 0 != l_i_file_acl_high {
        let block = i_file_acl_lo as u64 | ((l_i_file_acl_high as u64) << 32);

        xattr_block(&mut xattrs, load_block(block)?, uuid_checksum, block)
            .chain_err(|| format!("loading xattr block {}", block))?
    }

    let stat = ::Stat {
        extracted_type: ::FileType::from_mode(i_mode)
            .ok_or_else(|| UnsupportedFeature(format!("unexpected file type in mode: {:b}", i_mode)))?,
        file_mode: i_mode & 0b111_111_111_111,
        uid: i_uid as u32 | ((l_i_uid_high as u32) << 16),
        gid: i_gid as u32 | ((l_i_gid_high as u32) << 16),
        size: (i_size_lo as u64) | ((i_size_high as u64) << 32),
        atime: Time {
            epoch_secs: i_atime,
            nanos: i_atime_extra,
        },
        ctime: Time {
            epoch_secs: i_ctime,
            nanos: i_ctime_extra,
        },
        mtime: Time {
            epoch_secs: i_mtime,
            nanos: i_mtime_extra,
        },
        btime: i_crtime.map(|epoch_secs| Time {
            epoch_secs,
            nanos: i_crtime_extra,
        }),
        link_count: i_links_count,
        xattrs,
    };

    Ok(ParsedInode {
        stat,
        flags: ::InodeFlags::from_bits(i_flags)
            .ok_or_else(|| UnsupportedFeature(format!("unrecognised inode flags: {:b}", i_flags)))?,
        core: i_block,
        checksum_prefix,
    })
}

fn xattr_block(xattrs: &mut HashMap<String, Vec<u8>>, mut data: Vec<u8>,
               uuid_checksum: Option<u32>, block_number: u64) -> Result<()> {

    ensure!(data.len() > 0x20,
        AssumptionFailed("xattr block is way too short".to_string()));

    ensure!(XATTR_MAGIC == read_le32(&data[0x00..0x04]),
        AssumptionFailed("xattr block contained invalid magic number".to_string()));

//  let x_refcount    = read_le32(&data[0x04..0x08]);
    let x_blocks_used = read_le32(&data[0x08..0x0C]);
//    let x_hash        = read_le32(&data[0x0C..0x10]);
    let x_checksum    = read_le32(&data[0x10..0x14]);
    // [some reserved fields]

    if let Some(uuid_checksum) = uuid_checksum {
        data[0x10] = 0;
        data[0x11] = 0;
        data[0x12] = 0;
        data[0x13] = 0;

        let mut bytes = [0u8; 8];
        LittleEndian::write_u64(&mut bytes[0..8], block_number);

        let base = ext4_style_crc32c_le(uuid_checksum, &bytes);
        let computed = ext4_style_crc32c_le(base, &data);
        ensure!(x_checksum == computed,
            AssumptionFailed(format!("xattr block checksum invalid: on-disk: {:08x}, computed: {:08x}",
                x_checksum, computed)));
    }

    ensure!(1 == x_blocks_used,
        UnsupportedFeature(format!("must have exactly one xattr block, not {}", x_blocks_used)));

    read_xattrs(xattrs, &data[0x20..], &data[..])
}

fn read_xattrs(xattrs: &mut HashMap<String, Vec<u8>>, mut reading: &[u8], block_offset_start: &[u8]) -> Result<()> {

    loop {
        ensure!(reading.len() > 0x10,
            AssumptionFailed("out of block while reading xattr header".to_string()));

        let e_name_len          = reading[0x00];
        let e_name_prefix_magic = reading[0x01];
        let e_value_offset      = read_le16(&reading[0x02..0x04]);
        let e_block             = read_le32(&reading[0x04..0x08]);

        if 0 == e_name_len && 0 == e_name_prefix_magic && 0 == e_value_offset && 0 == e_block {
            break;
        }

        let e_value_size        = read_le32(&reading[0x08..0x0C]);
//        let e_hash              = read_le32(&reading[0x0C..0x10]);

        let end_of_name = 0x10 + e_name_len as usize;

        ensure!(reading.len() > end_of_name,
            AssumptionFailed("out of block while reading xattr name".to_string()));

        let name_suffix         = &reading[0x10..end_of_name];

        let name = format!("{}{}",
            match e_name_prefix_magic {
                0 => "",
                1 => "user.",
                2 => "system.posix_acl_access",
                3 => "system.posix_acl_default",
                4 => "trusted.",
                6 => "security.",
                7 => "system.",
                _ => bail!(UnsupportedFeature(format!("unsupported name prefix encoding: {}", e_name_prefix_magic))),
            },
            std::str::from_utf8(name_suffix).chain_err(|| "name is invalid utf-8")?
        );

        let start = e_value_offset as usize;
        let end = start + e_value_size as usize;

        ensure!(start <= block_offset_start.len() && end <= block_offset_start.len(),
            AssumptionFailed(format!("xattr value out of range: {}-{} > {}", start, end, block_offset_start.len())));

        xattrs.insert(name, block_offset_start[start..end].to_vec());

        let next_record = end_of_name + ((4 - (end_of_name % 4)) % 4);
        reading = &reading[next_record..];
    }

    Ok(())
}

/// This is what the function in the ext4 code does, based on its results. I'm so sorry.
pub fn ext4_style_crc32c_le(seed: u32, buf: &[u8]) -> u32 {
    crc::crc32::update(seed ^ (!0), &crc::crc32::CASTAGNOLI_TABLE, buf) ^ (!0u32)
}

#[cfg(test)]
mod tests {
    use super::ext4_style_crc32c_le;

    #[test]
    fn crcs() {
        /*
        Comparing with:
        % gcc m.c crc32c.c -I .. -o m && ./m
        e2fsprogs-1.43.4/lib/ext2fs% cat m.c
            int main() {
                printf("%08x\n", ext2fs_crc32c_le(SEED, DATA, DATA.len()));
            }

            typedef unsigned int __u32;

            __u32 ext2fs_swab32(__u32 val)
            {
                return ((val>>24) | ((val>>8)&0xFF00) |
                    ((val<<8)&0xFF0000) | (val<<24));
            }
        */

        assert_eq!(0xffff_ffffu32, !0);
        // e3069283 is the "standard" test vector that you can Google up.
        assert_eq!(0x1cf96d7cu32, 0xe3069283u32 ^ !0);
        assert_crc(0x1cf96d7c, !0, b"123456789");
        assert_crc(0x58e3fa20, 0, b"123456789");
    }

    fn assert_crc(ex: u32, seed: u32, input: &[u8]) {
        let ac = ext4_style_crc32c_le(seed, input);
        if ex != ac {
            panic!("CRC didn't match! ex: {:08x}, ac: {:08x}, len: {}", ex, ac, input.len());
        }
    }
}