use std::fmt;

use asterix_parser::asterix::uap::common::dataitems::{get_bitvec_subset_as_msb0, get_msb_bits};
use bitvec::prelude::*;

#[test]
pub(crate) fn test_bitvec() {
    let mut bv: BitVec = BitVec::new();
    bv.push(false);
    bv.push(true);
    bv.push(false);
    bv.push(false);
    bv.push(false);
    bv.push(false);
    bv.push(false);
    bv.push(false);

    assert_eq!(bv.len(), 8);
    assert_eq!(bv[0], false);

    // assert_eq!(bv.pop(), Some(true));
    // assert_eq!(bv.len(), 1);

    let mut bv_m = bitvec![u16, Msb0;];
    bv_m.push(false);
    bv_m.push(true);
    bv_m.push(false);
    bv_m.push(false);
    bv_m.push(false);
    bv_m.push(false);
    bv_m.push(false);
    bv_m.push(false);

    let mut bv_l = bitvec![u16, Lsb0;];
    bv_l.push(false);
    bv_l.push(true);
    bv_l.push(false);
    bv_l.push(false);
    bv_l.push(false);
    bv_l.push(false);
    bv_l.push(false);
    bv_l.push(false);

    println!("bv {}, bv_m {}, bv_l {}", bv, bv_m, bv_l);
    println!("bv {}, bv_m {}, bv_l {}", bv, bv_m, bv_l);

    print!("bv positions: ");
    for i in 0..8 {
        print!("{}", if bv[i] { "1" } else { "0" }); 
    }
    println!();

    print!("bv_m positions: ");
    for i in 0..8 {
        print!("{}", if bv_m[i] { "1" } else { "0" }); 
    }
    println!();

    print!("bv_l positions: ");
    for i in 0..8 {
        print!("{}", if bv_l[i] { "1" } else { "0" }); 
    }
    println!();

    let can_id: &[_] = &[0b10100000 as u8];
    // let mut can_id_bits = can_id.view_bits::<Msb0>().to_bitvec();
    let can_id_bits = get_msb_bits(&can_id);

    // used to debug
    // use std::fmt;
    // let strip_characters = &['[',']',' ',','];
    // let can_id_bits_str = fmt::format(format_args!("{0:b}", can_id_bits)).replace(strip_characters, "");

    assert_eq!(can_id_bits[0], true,  "bit 7 should be true");
    assert_eq!(can_id_bits[1], false, "bit 6 should be false");
    assert_eq!(can_id_bits[2], true,  "bit 5 should be true");
    assert_eq!(can_id_bits[7], false, "bit 0 should be false");
}

#[test]
pub(crate) fn test_bitvec_from_u8_vec() {

    let source = vec![0b1010_0101_u8, 0b11110000, 0b00001111];
    let bv: BitVec<u8, Msb0> = BitVec::<_, Msb0>::from_vec(source);
    
    let mut count = 0;
    println!("bv {}", bv);
    for bit in bv {
        println!("Bit {}: {}", count, bit);
        count += 1;
    }

}

#[test]
pub(crate) fn test_bitvec_split_off() {

    let mut bv = bitvec![0, 1, 0, 0, 1, 0, 0, 0];
    let bv2 = bv.split_off(2);
    assert_eq!((&*bv, &*bv2), (bits![0, 1], bits![0, 0, 1, 0, 0, 0]));

    let mut bv = bitvec![0, 1, 0, 0, 1, 0, 0, 0];
    let mut bv2 = bv.split_off(1);
    assert_eq!((&*bv, &*bv2), (bits![0], bits![1, 0, 0, 1, 0, 0, 0]));

    let bv3 = bv2.split_off(3);
    assert_eq!((&*bv2, &*bv3), (bits![1, 0, 0], bits![1, 0, 0, 0]));

    println!("Stringyfied {}", stringify!("Test"));
}

#[test]
pub(crate) fn test_bitvec_subset() {
    // I048_230
    // 0b00100000, 0b11110101

    let trim_characters: &[_]  = &['[', ']', ' ', ','][..];
    let octet_bits = get_expected_bits_from_u8_vec(&vec![0x20 as u8, 0xF5]); 
    
    let expected_bits = get_bitvec_subset_as_msb0(&octet_bits, 16, 14);
    let expected_bits_as_string = fmt::format(format_args!("{:b}", &expected_bits)).replace(trim_characters, "");

    let requested_subset = get_bitvec_subset_as_msb0(&octet_bits, 16, 14);
    let requested_subset_as_string = fmt::format(format_args!("{:b}", &requested_subset)).replace(trim_characters, "");

    println!("Expected  bits: {}", expected_bits_as_string);
    println!("Requested bits: {}", requested_subset_as_string);
    assert_eq!(expected_bits, requested_subset);
}

fn get_expected_bits_from_u8_vec(vec_u8: &Vec<u8>) -> BitVec<u8, Msb0> {
    // let mut bitvec = (vec_u8).view_bits::<Msb0>().to_bitvec();
    let bitvec = get_msb_bits(vec_u8.as_slice());
    bitvec
}