use zr_protocol::{
    codec::{decode::Decode, encode::Encode},
    types::prefix::count::CountPrefix,
};

fn encode_to_bytes<T: Encode>(value: T) -> Vec<u8> {
    let mut buf = Vec::new();
    value.encode(&mut buf).unwrap();
    buf
}

// ────────────────────── Vecteur vide ────────────

#[test]
fn empty_vec_u8_with_u8_count() {
    let cp = CountPrefix::<u8, u8, Vec<u8>>::new(vec![]);
    let buf = encode_to_bytes(cp);
    assert_eq!(buf, vec![0x00]);
}

#[test]
fn empty_vec_u32_with_u16_count() {
    let cp = CountPrefix::<u32, u16, Vec<u32>>::new(vec![]);
    let buf = encode_to_bytes(cp);
    assert_eq!(buf, vec![0x00, 0x00]);
}

#[test]
fn empty_vec_u8_with_u32_count() {
    let cp = CountPrefix::<u8, u32, Vec<u8>>::new(vec![]);
    let buf = encode_to_bytes(cp);
    assert_eq!(buf, vec![0x00, 0x00, 0x00, 0x00]);
}

// ────────────────────── Un seul élément ─────────

#[test]
fn single_u8_u8_count() {
    let cp = CountPrefix::<u8, u8, Vec<u8>>::new(vec![42]);
    let buf = encode_to_bytes(cp);
    assert_eq!(buf, vec![0x01, 0x2A]);
}

#[test]
fn single_u32_u8_count() {
    let cp = CountPrefix::<u32, u8, Vec<u32>>::new(vec![0x01020304]);
    let buf = encode_to_bytes(cp);
    assert_eq!(buf, vec![0x01, 0x01, 0x02, 0x03, 0x04]);
}

// ────────────────────── Plusieurs éléments ──────

#[test]
fn multiple_u8_u8_count() {
    let cp = CountPrefix::<u8, u8, Vec<u8>>::new(vec![1, 2, 3]);
    let buf = encode_to_bytes(cp);
    assert_eq!(buf, vec![0x03, 0x01, 0x02, 0x03]);
}

#[test]
fn multiple_u16_u8_count() {
    let cp = CountPrefix::<u16, u8, Vec<u16>>::new(vec![256, 512, 1024]);
    let buf = encode_to_bytes(cp);
    assert_eq!(
        buf,
        vec![
            0x03, // count = 3
            0x01, 0x00, // 256
            0x02, 0x00, // 512
            0x04, 0x00, // 1024
        ]
    );
}

#[test]
fn multiple_u32_u16_count() {
    let cp = CountPrefix::<u32, u16, Vec<u32>>::new(vec![100, 200, 300]);
    let buf = encode_to_bytes(cp);
    assert_eq!(
        buf,
        vec![
            0x00, 0x03, // count = 3 (u16)
            0x00, 0x00, 0x00, 0x64, // 100
            0x00, 0x00, 0x00, 0xC8, // 200
            0x00, 0x00, 0x01, 0x2C, // 300
        ]
    );
}

// ────────────────────── Valeurs extrêmes ────────

#[test]
fn u8_count_max_255() {
    let data: Vec<u8> = (0..255).collect();
    let cp = CountPrefix::<u8, u8, Vec<u8>>::new(data.clone());
    let buf = encode_to_bytes(cp);
    assert_eq!(buf[0], 0xFF);
    assert_eq!(buf.len(), 1 + 255);
}

#[test]
fn large_u32_items_u16_count() {
    let data: Vec<u32> = vec![u32::MAX, 0, u32::MIN + 1];
    let cp = CountPrefix::<u32, u16, Vec<u32>>::new(data);
    let buf = encode_to_bytes(cp);
    assert_eq!(buf.len(), 2 + 3 * 4);
    assert_eq!(&buf[0..2], &[0x00, 0x03]); // count = 3
}

// ────────────────────── Roundtrip ───────────────

#[test]
fn roundtrip_u8_u8() {
    let data = vec![10, 20, 30, 40, 50];
    let cp = CountPrefix::<u8, u8, Vec<u8>>::new(data.clone());
    let buf = encode_to_bytes(cp);

    let mut reader = &buf[..];
    let decoded = CountPrefix::<u8, u8, Vec<u8>>::decode(&mut reader).unwrap();
    assert_eq!(*decoded.as_ref(), data);
}

#[test]
fn roundtrip_u32_u16() {
    let data = vec![1, 2, 3, 4, 5];
    let cp = CountPrefix::<u32, u16, Vec<u32>>::new(data.clone());
    let buf = encode_to_bytes(cp);

    let mut reader = &buf[..];
    let decoded = CountPrefix::<u32, u16, Vec<u32>>::decode(&mut reader).unwrap();
    assert_eq!(*decoded.as_ref(), data);
}

#[test]
fn roundtrip_empty() {
    let cp = CountPrefix::<u32, u8, Vec<u32>>::new(vec![]);
    let buf = encode_to_bytes(cp);

    let mut reader = &buf[..];
    let decoded = CountPrefix::<u32, u8, Vec<u32>>::decode(&mut reader).unwrap();
    assert!(decoded.as_ref().is_empty());
}

#[test]
fn roundtrip_single_element() {
    let cp = CountPrefix::<u64, u8, Vec<u64>>::new(vec![u64::MAX]);
    let buf = encode_to_bytes(cp);

    let mut reader = &buf[..];
    let decoded = CountPrefix::<u64, u8, Vec<u64>>::decode(&mut reader).unwrap();
    assert_eq!(*decoded.as_ref(), vec![u64::MAX]);
}

#[test]
fn roundtrip_negative_i32() {
    let data = vec![-1, -100, 0, 100, 1];
    let cp = CountPrefix::<i32, u16, Vec<i32>>::new(data.clone());
    let buf = encode_to_bytes(cp);

    let mut reader = &buf[..];
    let decoded = CountPrefix::<i32, u16, Vec<i32>>::decode(&mut reader).unwrap();
    assert_eq!(*decoded.as_ref(), data);
}

#[test]
fn roundtrip_f64() {
    let data = vec![0.0, 3.14, -2.71, f64::INFINITY, f64::NEG_INFINITY];
    let cp = CountPrefix::<f64, u8, Vec<f64>>::new(data.clone());
    let buf = encode_to_bytes(cp);

    let mut reader = &buf[..];
    let decoded = CountPrefix::<f64, u8, Vec<f64>>::decode(&mut reader).unwrap();
    let decoded_data = decoded.as_ref().clone();
    assert_eq!(decoded_data.len(), data.len());
    for (a, b) in decoded_data.iter().zip(data.iter()) {
        if a.is_nan() {
            assert!(b.is_nan());
        } else {
            assert_eq!(a, b);
        }
    }
}

#[test]
fn roundtrip_bool() {
    let data = vec![true, false, true, true, false];
    let cp = CountPrefix::<bool, u8, Vec<bool>>::new(data.clone());
    let buf = encode_to_bytes(cp);

    let mut reader = &buf[..];
    let decoded = CountPrefix::<bool, u8, Vec<bool>>::decode(&mut reader).unwrap();
    assert_eq!(*decoded.as_ref(), data);
}

#[test]
fn roundtrip_large_dataset() {
    let data: Vec<u32> = (0..1000).collect();
    let cp = CountPrefix::<u32, u16, Vec<u32>>::new(data.clone());
    let buf = encode_to_bytes(cp);

    let mut reader = &buf[..];
    let decoded = CountPrefix::<u32, u16, Vec<u32>>::decode(&mut reader).unwrap();
    assert_eq!(*decoded.as_ref(), data);
}

// ────────────────────── Imbrication ─────────────

#[test]
fn nested_count_prefix() {
    let inner1 = CountPrefix::<u8, u8, Vec<u8>>::new(vec![1, 2, 3]);
    let inner2 = CountPrefix::<u8, u8, Vec<u8>>::new(vec![4, 5]);
    let outer =
        CountPrefix::<CountPrefix<u8, u8, Vec<u8>>, u8, Vec<CountPrefix<u8, u8, Vec<u8>>>>::new(
            vec![inner1, inner2],
        );

    let buf = encode_to_bytes(outer);

    let mut reader = &buf[..];
    let decoded_outer =
        CountPrefix::<CountPrefix<u8, u8, Vec<u8>>, u8, Vec<CountPrefix<u8, u8, Vec<u8>>>>::decode(
            &mut reader,
        )
        .unwrap();

    let outer_data: Vec<_> = decoded_outer
        .as_ref()
        .iter()
        .map(|c| c.as_ref().clone())
        .collect();
    assert_eq!(outer_data.len(), 2);
    assert_eq!(outer_data[0], vec![1, 2, 3]);
    assert_eq!(outer_data[1], vec![4, 5]);
}

// ────────────────────── Erreurs de décodage ─────

#[test]
fn decode_empty_buffer_fails() {
    let result = CountPrefix::<u8, u8, Vec<u8>>::decode(&mut &[][..]);
    assert!(result.is_err());
}

#[test]
fn decode_truncated_data_fails() {
    let cp = CountPrefix::<u32, u8, Vec<u32>>::new(vec![1, 2, 3]);
    let buf = encode_to_bytes(cp);
    let truncated = &buf[..buf.len() - 1];
    let result = CountPrefix::<u32, u8, Vec<u32>>::decode(&mut &truncated[..]);
    assert!(result.is_err());
}

#[test]
fn decode_wrong_count_fails() {
    let cp = CountPrefix::<u32, u8, Vec<u32>>::new(vec![1, 2]);
    let mut buf = encode_to_bytes(cp);
    buf[0] = 0x05;
    let result = CountPrefix::<u32, u8, Vec<u32>>::decode(&mut &buf[..]);
    assert!(result.is_err());
}

// ────────────────────── AsRef / AsMut ───────────

#[test]
fn as_ref_returns_inner_data() {
    let data = vec![10u32, 20, 30];
    let cp = CountPrefix::<u32, u8, Vec<u32>>::new(data.clone());
    assert_eq!(*cp.as_ref(), data);
}

#[test]
fn as_mut_allows_mutation() {
    let mut cp = CountPrefix::<u32, u8, Vec<u32>>::new(vec![1, 2, 3]);
    cp.as_mut().push(4);
    assert_eq!(*cp.as_ref(), vec![1, 2, 3, 4]);
}

// ────────────────────── Counts byte exactitude ──

#[test]
fn u8_count_header() {
    let cp = CountPrefix::<u8, u8, Vec<u8>>::new(vec![1; 10]);
    let buf = encode_to_bytes(cp);
    assert_eq!(buf[0], 10);
    assert_eq!(buf.len(), 1 + 10);
}

#[test]
fn u16_count_header() {
    let cp = CountPrefix::<u8, u16, Vec<u8>>::new(vec![1; 300]);
    let buf = encode_to_bytes(cp);
    assert_eq!(buf[0], 0x01);
    assert_eq!(buf[1], 0x2C);
    assert_eq!(buf.len(), 2 + 300);
}

#[test]
fn u32_count_header() {
    let data: Vec<u8> = vec![0xAA; 300];
    let len = data.len();
    let cp = CountPrefix::<u8, u32, Vec<u8>>::new(data);
    let buf = encode_to_bytes(cp);
    assert_eq!(buf.len(), 4 + len);
    assert_eq!(&buf[0..4], &[0x00, 0x00, 0x01, 0x2C]);
}