use crate::hufftree::canonical::convert_no_to_bit_vec;
use crate::hufftree::canonical::CanonicalHufftree;
use bit_vec::BitVec;
use std::io::Read;
use std::io::Write;

pub fn store_tree<F: Write>(tree: CanonicalHufftree, writer: &mut F) -> Result<(), String> {
    let mut buff = BitVec::new();
    let mut character_buff: [u8; 4] = [0; 4];

    for (character, code) in tree.get_character_codes() {
        let code_length: u32 = code.len().try_into().unwrap();
        let mut code_length_vec = convert_no_to_bit_vec(code_length);
        buff.append(&mut code_length_vec);
        buff.append(&mut BitVec::from_elem(8, false));
        character.encode_utf8(&mut character_buff);
        buff.append(&mut BitVec::from_bytes(&character_buff));

        character_buff.fill(0);
    }

    let buff = buff.to_bytes();
    let buff_len: u32 = buff.len().try_into().unwrap();

    writer.write_all(&buff_len.to_be_bytes()).unwrap();
    writer.write_all(&buff).unwrap();

    Ok(())
}

#[cfg(test)]
mod test {
    use std::collections::HashMap;
    use crate::hufftree::base::Hufftree;

    use super::*;

    #[test]
    fn stores_length_and_rest() {
        let mut chars_and_freq: HashMap<char, i32> = HashMap::new();
        chars_and_freq.insert('a', 25);
        chars_and_freq.insert('b', 14);
        chars_and_freq.insert('c', 5);

        let huff = Hufftree::new(chars_and_freq);
        let canonical = CanonicalHufftree::from_tree(huff);

        let mut virtual_buffer = Vec::new();
        store_tree(canonical, &mut virtual_buffer).unwrap();

        println!("Buffer:{:?}", virtual_buffer);

    }
}