use binary_loader;

struct DBHeader {
    magic: u8,
    major_version: u8, // actually u4 in data
    minor_version: u8, // actually u4 in data 
    reserved: u16,
    record_count: u32,
}

impl DBHeader {
    fn from(raw: [u8; 8]) -> DBHeader {
        
        DBHeader {
            magic: binary_loader::load_u8(&raw[0]),
            major_version: binary_loader::load_high_u4(&raw[1]),
            minor_version: binary_loader::load_low_u4(&raw[1]),
            reserved: binary_loader::load_u16(&raw[2..4]),
            record_count: binary_loader::load_u32(&raw[4..8]),
        }
    }
}

struct RecordHeader {
    field_count: u8,
    length: u8,
    crc: u16,
}

struct Field {
    field_type: u8,
    value: String,
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn it_works() {
        assert_eq!(2 + 2, 4);
    }
    
    #[test]
    fn load_empty_db_header() {
        let header = [0xDB, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
        let db_header = DBHeader::from(header);
        assert_eq!(db_header.magic, 0xDB);
        assert_eq!(db_header.major_version, 0);
        assert_eq!(db_header.minor_version, 1);
        assert_eq!(db_header.reserved, 0);
        assert_eq!(db_header.record_count, 0);

    }
}