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]) -> 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,
}

impl RecordHeader {
    fn from(raw: &[u8]) -> RecordHeader {
        RecordHeader {
            field_count: binary_loader::load_u8(&raw[0]),
            length: binary_loader::load_u8(&raw[1]),
            crc: binary_loader::load_u16(&raw[2..4]),
        }
    }
}

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

impl Field {
    fn from(raw: &[u8]) -> Field {
        let length = binary_loader::load_u16(&raw[1..3]);
        let mut lsize: usize = length.into();
        lsize += 3;
        let value = String::from_utf8_lossy(&raw[3..lsize]).to_string();
        println!("{}", value);
        println!("{}", lsize);
        Field {
            field_type: binary_loader::load_u8(&raw[0]),
            length: length,
            value: value,
        }
    }
}

#[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);

    }
    
    #[test]
    fn load_record_header() {
        let header: [u8; 4] = [0x3, 0x45, 0x12, 0x34];
        let record_header = RecordHeader::from(&header);
        assert_eq!(record_header.field_count, 3);
        assert_eq!(record_header.length, 0x45);
        assert_eq!(record_header.crc, 0x1234);
    }

    #[test]
    fn load_field() {
        let field: [u8; 6] = [0x01, 0x00, 0x03, 0x4a, 0x6f, 0x6e];
        let field = Field::from(&field);
        assert_eq!(0x01, field.field_type);
        assert_eq!(3, field.length);
        assert_eq!(String::from("Jon"), field.value);
    }
}