synta 0.2.0

//! Tests for constructed types

use synta::types::constructed::{Element, Sequence, SequenceOf, Set, SetOf};
use synta::types::primitive::{Boolean, Integer, Null};
use synta::types::string::{
    BmpString, GeneralString, NumericString, OctetString, TeletexString, UniversalString,
    VisibleString,
};
use synta::{format_asn1_bytes, Asn1FormatMode};
use synta::{Decoder, Encoder, Encoding};

#[test]
fn test_element_boolean() {
    let elem = Element::Boolean(Boolean::new(true));

    let mut encoder = Encoder::new(Encoding::Der);
    encoder.encode(&elem).unwrap();
    let encoded = encoder.finish().unwrap();

    let mut decoder = Decoder::new(&encoded, Encoding::Der);
    let decoded: Element = decoder.decode().unwrap();

    match decoded {
        Element::Boolean(b) => assert!(b.value()),
        _ => panic!("Expected Boolean"),
    }
}

#[test]
fn test_element_integer() {
    let elem = Element::Integer(Integer::from(42));

    let mut encoder = Encoder::new(Encoding::Der);
    encoder.encode(&elem).unwrap();
    let encoded = encoder.finish().unwrap();

    let mut decoder = Decoder::new(&encoded, Encoding::Der);
    let decoded: Element = decoder.decode().unwrap();

    match decoded {
        Element::Integer(i) => assert_eq!(i.as_i64().unwrap(), 42),
        _ => panic!("Expected Integer"),
    }
}

#[test]
fn test_sequence_empty() {
    let seq = Sequence::new();
    assert!(seq.is_empty());

    let mut encoder = Encoder::new(Encoding::Der);
    encoder.encode(&seq).unwrap();
    let encoded = encoder.finish().unwrap();

    let mut decoder = Decoder::new(&encoded, Encoding::Der);
    let decoded: Sequence = decoder.decode().unwrap();

    assert!(decoded.is_empty());
}

#[test]
fn test_sequence_with_elements() {
    let mut seq = Sequence::new();
    seq.push(Element::Integer(Integer::from(1)));
    seq.push(Element::Boolean(Boolean::new(true)));
    seq.push(Element::Null(Null));

    let mut encoder = Encoder::new(Encoding::Der);
    encoder.encode(&seq).unwrap();
    let encoded = encoder.finish().unwrap();

    let mut decoder = Decoder::new(&encoded, Encoding::Der);
    let decoded: Sequence = decoder.decode().unwrap();

    let elements = decoded.into_elements().unwrap();
    assert_eq!(elements.len(), 3);

    match &elements[0] {
        Element::Integer(i) => assert_eq!(i.as_i64().unwrap(), 1),
        _ => panic!("Expected Integer"),
    }

    match &elements[1] {
        Element::Boolean(b) => assert!(b.value()),
        _ => panic!("Expected Boolean"),
    }

    match &elements[2] {
        Element::Null(_) => {}
        _ => panic!("Expected Null"),
    }
}

#[test]
fn test_nested_sequence() {
    let mut inner_seq = Sequence::new();
    inner_seq.push(Element::Integer(Integer::from(10)));
    inner_seq.push(Element::Integer(Integer::from(20)));

    let mut outer_seq = Sequence::new();
    outer_seq.push(Element::Integer(Integer::from(5)));
    outer_seq.push(Element::Sequence(inner_seq));
    outer_seq.push(Element::Integer(Integer::from(15)));

    let mut encoder = Encoder::new(Encoding::Der);
    encoder.encode(&outer_seq).unwrap();
    let encoded = encoder.finish().unwrap();

    let mut decoder = Decoder::new(&encoded, Encoding::Der);
    let decoded: Sequence = decoder.decode().unwrap();

    let outer_elements = decoded.into_elements().unwrap();
    assert_eq!(outer_elements.len(), 3);

    match &outer_elements[1] {
        Element::Sequence(inner) => {
            let inner_elements = inner.clone().into_elements().unwrap();
            assert_eq!(inner_elements.len(), 2);
            match &inner_elements[0] {
                Element::Integer(i) => assert_eq!(i.as_i64().unwrap(), 10),
                _ => panic!("Expected Integer"),
            }
        }
        _ => panic!("Expected Sequence"),
    }
}

#[test]
fn test_set_with_elements() {
    let mut set = Set::new();
    set.push(Element::Integer(Integer::from(1)));
    set.push(Element::Boolean(Boolean::new(true)));

    let mut encoder = Encoder::new(Encoding::Der);
    encoder.encode(&set).unwrap();
    let encoded = encoder.finish().unwrap();

    let mut decoder = Decoder::new(&encoded, Encoding::Der);
    let decoded: Set = decoder.decode().unwrap();

    assert_eq!(decoded.into_elements().unwrap().len(), 2);
}

#[test]
fn test_sequence_of_integers() {
    let mut seq = SequenceOf::<Integer>::new();
    seq.push(Integer::from(1));
    seq.push(Integer::from(2));
    seq.push(Integer::from(3));

    assert_eq!(seq.len(), 3);
    assert!(!seq.is_empty());

    let mut encoder = Encoder::new(Encoding::Der);
    encoder.encode(&seq).unwrap();
    let encoded = encoder.finish().unwrap();

    let mut decoder = Decoder::new(&encoded, Encoding::Der);
    let decoded: SequenceOf<Integer> = decoder.decode().unwrap();

    assert_eq!(decoded.len(), 3);
    assert_eq!(decoded.elements()[0].as_i64().unwrap(), 1);
    assert_eq!(decoded.elements()[1].as_i64().unwrap(), 2);
    assert_eq!(decoded.elements()[2].as_i64().unwrap(), 3);
}

#[test]
fn test_sequence_of_octet_strings() {
    let mut seq = SequenceOf::<OctetString>::new();
    seq.push(OctetString::new(vec![1, 2, 3]));
    seq.push(OctetString::new(vec![4, 5, 6]));

    let mut encoder = Encoder::new(Encoding::Der);
    encoder.encode(&seq).unwrap();
    let encoded = encoder.finish().unwrap();

    let mut decoder = Decoder::new(&encoded, Encoding::Der);
    let decoded: SequenceOf<OctetString> = decoder.decode().unwrap();

    assert_eq!(decoded.len(), 2);
    assert_eq!(decoded.elements()[0].as_bytes(), &[1, 2, 3]);
    assert_eq!(decoded.elements()[1].as_bytes(), &[4, 5, 6]);
}

#[test]
fn test_set_of_integers() {
    let mut set = SetOf::<Integer>::new();
    set.push(Integer::from(10));
    set.push(Integer::from(20));
    set.push(Integer::from(30));

    let mut encoder = Encoder::new(Encoding::Der);
    encoder.encode(&set).unwrap();
    let encoded = encoder.finish().unwrap();

    let mut decoder = Decoder::new(&encoded, Encoding::Der);
    let decoded: SetOf<Integer> = decoder.decode().unwrap();

    assert_eq!(decoded.len(), 3);
}

#[test]
fn test_sequence_of_empty() {
    let seq = SequenceOf::<Integer>::new();
    assert_eq!(seq.len(), 0);
    assert!(seq.is_empty());

    let mut encoder = Encoder::new(Encoding::Der);
    encoder.encode(&seq).unwrap();
    let encoded = encoder.finish().unwrap();

    let mut decoder = Decoder::new(&encoded, Encoding::Der);
    let decoded: SequenceOf<Integer> = decoder.decode().unwrap();

    assert_eq!(decoded.len(), 0);
    assert!(decoded.is_empty());
}

#[test]
fn test_complex_structure() {
    // Create a structure similar to a simple X.509-like certificate field:
    // SEQUENCE {
    //   INTEGER (version)
    //   INTEGER (serialNumber)
    //   SEQUENCE { ... } (signature algorithm)
    // }

    let mut sig_alg = Sequence::new();
    sig_alg.push(Element::Integer(Integer::from(1))); // algorithm OID as integer for simplicity
    sig_alg.push(Element::Null(Null)); // parameters

    let mut cert = Sequence::new();
    cert.push(Element::Integer(Integer::from(2))); // version
    cert.push(Element::Integer(Integer::from(123456))); // serial number
    cert.push(Element::Sequence(sig_alg)); // signature algorithm

    let mut encoder = Encoder::new(Encoding::Der);
    encoder.encode(&cert).unwrap();
    let encoded = encoder.finish().unwrap();

    let mut decoder = Decoder::new(&encoded, Encoding::Der);
    let decoded: Sequence = decoder.decode().unwrap();
    let elements = decoded.into_elements().unwrap();

    assert_eq!(elements.len(), 3);

    // Verify version
    match &elements[0] {
        Element::Integer(i) => assert_eq!(i.as_i64().unwrap(), 2),
        _ => panic!("Expected Integer for version"),
    }

    // Verify serial number
    match &elements[1] {
        Element::Integer(i) => assert_eq!(i.as_i64().unwrap(), 123456),
        _ => panic!("Expected Integer for serial"),
    }

    // Verify signature algorithm
    match &elements[2] {
        Element::Sequence(inner) => {
            assert_eq!(inner.clone().into_elements().unwrap().len(), 2);
        }
        _ => panic!("Expected Sequence for sig alg"),
    }
}

#[test]
fn test_sequence_into_vec() {
    let mut seq = Sequence::new();
    seq.push(Element::Integer(Integer::from(1)));
    seq.push(Element::Integer(Integer::from(2)));

    let vec = seq.into_elements().unwrap();
    assert_eq!(vec.len(), 2);
}

#[test]
fn test_sequence_of_from_vec() {
    let vec = vec![Integer::from(1), Integer::from(2), Integer::from(3)];
    let seq = SequenceOf::from_vec(vec);

    assert_eq!(seq.len(), 3);
    assert_eq!(seq.elements()[0].as_i64().unwrap(), 1);
}

// --- New string Element variants ---

#[test]
fn test_element_numeric_string() {
    let elem = Element::NumericString(NumericString::new("12345".to_string()).unwrap());

    let mut encoder = Encoder::new(Encoding::Der);
    encoder.encode(&elem).unwrap();
    let encoded = encoder.finish().unwrap();

    let mut decoder = Decoder::new(&encoded, Encoding::Der);
    let decoded: Element = decoder.decode().unwrap();

    match decoded {
        Element::NumericString(s) => assert_eq!(s.as_str(), "12345"),
        _ => panic!("Expected NumericString"),
    }
}

#[test]
fn test_element_teletex_string() {
    let data = b"hello\x80".to_vec();
    let elem = Element::TeletexString(TeletexString::new(data.clone()));

    let mut encoder = Encoder::new(Encoding::Der);
    encoder.encode(&elem).unwrap();
    let encoded = encoder.finish().unwrap();

    let mut decoder = Decoder::new(&encoded, Encoding::Der);
    let decoded: Element = decoder.decode().unwrap();

    match decoded {
        Element::TeletexString(s) => assert_eq!(s.as_bytes(), &data[..]),
        _ => panic!("Expected TeletexString"),
    }
}

#[test]
fn test_element_visible_string() {
    let elem = Element::VisibleString(VisibleString::new("visible".to_string()).unwrap());

    let mut encoder = Encoder::new(Encoding::Der);
    encoder.encode(&elem).unwrap();
    let encoded = encoder.finish().unwrap();

    let mut decoder = Decoder::new(&encoded, Encoding::Der);
    let decoded: Element = decoder.decode().unwrap();

    match decoded {
        Element::VisibleString(s) => assert_eq!(s.as_str(), "visible"),
        _ => panic!("Expected VisibleString"),
    }
}

#[test]
fn test_element_general_string() {
    let data = b"krbtgt".to_vec();
    let elem = Element::GeneralString(GeneralString::new(data.clone()));

    let mut encoder = Encoder::new(Encoding::Der);
    encoder.encode(&elem).unwrap();
    let encoded = encoder.finish().unwrap();

    let mut decoder = Decoder::new(&encoded, Encoding::Der);
    let decoded: Element = decoder.decode().unwrap();

    match decoded {
        Element::GeneralString(s) => assert_eq!(s.as_bytes(), &data[..]),
        _ => panic!("Expected GeneralString"),
    }
}

#[test]
fn test_element_universal_string() {
    let elem = Element::UniversalString(UniversalString::new("Hi".to_string()));

    let mut encoder = Encoder::new(Encoding::Der);
    encoder.encode(&elem).unwrap();
    let encoded = encoder.finish().unwrap();

    let mut decoder = Decoder::new(&encoded, Encoding::Der);
    let decoded: Element = decoder.decode().unwrap();

    match decoded {
        Element::UniversalString(s) => assert_eq!(s.as_str(), "Hi"),
        _ => panic!("Expected UniversalString"),
    }
}

#[test]
fn test_element_bmp_string() {
    let elem = Element::BmpString(BmpString::new("café".to_string()).unwrap());

    let mut encoder = Encoder::new(Encoding::Der);
    encoder.encode(&elem).unwrap();
    let encoded = encoder.finish().unwrap();

    let mut decoder = Decoder::new(&encoded, Encoding::Der);
    let decoded: Element = decoder.decode().unwrap();

    match decoded {
        Element::BmpString(s) => assert_eq!(s.as_str(), "café"),
        _ => panic!("Expected BmpString"),
    }
}

// --- Element::Raw for unknown tags ---

#[test]
fn test_element_raw_unknown_tag() {
    // Manually construct an element with a private / unknown universal tag.
    // Use tag 25 (0x19) which is not implemented — ObjectDescriptor.
    // TLV: 0x19 (tag), 0x03 (length), b"abc"
    let raw_tlv: &[u8] = &[0x19, 0x03, b'a', b'b', b'c'];
    let mut decoder = Decoder::new(raw_tlv, Encoding::Der);
    let decoded: Element = decoder.decode().unwrap();

    match decoded {
        Element::Raw(tag, bytes) => {
            assert_eq!(tag.number(), 25);
            assert_eq!(&bytes, b"abc");
        }
        _ => panic!("Expected Raw element for unknown tag"),
    }
}

#[test]
fn test_element_raw_roundtrip() {
    // Construct a Raw element, encode it, decode it back.
    let tag = synta::Tag::new(synta::TagClass::Universal, false, 25);
    let elem = Element::Raw(tag, b"data");

    let mut encoder = Encoder::new(Encoding::Der);
    encoder.encode(&elem).unwrap();
    let encoded = encoder.finish().unwrap();

    // Should produce: 0x19 (tag 25 universal primitive), 0x04 (length), b"data"
    assert_eq!(encoded[0], 0x19);
    assert_eq!(encoded[1], 0x04);
    assert_eq!(&encoded[2..], b"data");

    let mut decoder = Decoder::new(&encoded, Encoding::Der);
    let decoded: Element = decoder.decode().unwrap();
    match decoded {
        Element::Raw(t, bytes) => {
            assert_eq!(t.number(), 25);
            assert_eq!(&bytes, b"data");
        }
        _ => panic!("Expected Raw element"),
    }
}

// ── format_asn1_bytes tests ──────────────────────────────────────────────────

#[test]
fn test_format_hex_integer() {
    // INTEGER 42 → 02 01 2A
    let bytes = &[0x02u8, 0x01, 0x2A];
    let hex = format_asn1_bytes(bytes, Asn1FormatMode::Hex);
    assert_eq!(hex, "02 01 2A");
}

#[test]
fn test_format_text_integer() {
    let bytes = &[0x02u8, 0x01, 0x2A]; // INTEGER 42
    let text = format_asn1_bytes(bytes, Asn1FormatMode::Text);
    assert_eq!(text, "INTEGER 42");
}

#[test]
fn test_format_text_boolean_true() {
    let bytes = &[0x01u8, 0x01, 0xFF]; // BOOLEAN TRUE
    let text = format_asn1_bytes(bytes, Asn1FormatMode::Text);
    assert_eq!(text, "BOOLEAN TRUE");
}

#[test]
fn test_format_text_null() {
    let bytes = &[0x05u8, 0x00]; // NULL
    let text = format_asn1_bytes(bytes, Asn1FormatMode::Text);
    assert_eq!(text, "NULL");
}

#[test]
fn test_format_text_octet_string() {
    let bytes = &[0x04u8, 0x03, 0xDE, 0xAD, 0xBE]; // OCTET STRING DE AD BE
    let text = format_asn1_bytes(bytes, Asn1FormatMode::Text);
    assert_eq!(text, "OCTET STRING DE:AD:BE");
}

#[test]
fn test_format_text_utf8_string() {
    // UTF8String "hi" → 0C 02 68 69
    let bytes = &[0x0Cu8, 0x02, 0x68, 0x69];
    let text = format_asn1_bytes(bytes, Asn1FormatMode::Text);
    assert_eq!(text, "UTF8String \"hi\" [68:69]");
}

#[test]
fn test_format_text_sequence_with_integer() {
    // SEQUENCE { INTEGER 42 } → 30 03 02 01 2A
    let bytes = &[0x30u8, 0x03, 0x02, 0x01, 0x2A];
    let text = format_asn1_bytes(bytes, Asn1FormatMode::Text);
    assert_eq!(text, "SEQUENCE {\n  INTEGER 42\n}");
}

#[test]
fn test_format_text_empty_sequence() {
    // SEQUENCE {} → 30 00
    let bytes = &[0x30u8, 0x00];
    let text = format_asn1_bytes(bytes, Asn1FormatMode::Text);
    assert_eq!(text, "SEQUENCE {}");
}

#[test]
fn test_format_text_nested_sequence() {
    // SEQUENCE { SEQUENCE { INTEGER 1 } }
    // 30 05 30 03 02 01 01
    let bytes = &[0x30u8, 0x05, 0x30, 0x03, 0x02, 0x01, 0x01];
    let text = format_asn1_bytes(bytes, Asn1FormatMode::Text);
    assert_eq!(text, "SEQUENCE {\n  SEQUENCE {\n    INTEGER 1\n  }\n}");
}

#[test]
fn test_format_hex_empty() {
    let hex = format_asn1_bytes(&[], Asn1FormatMode::Hex);
    assert_eq!(hex, "");
}

#[test]
fn test_format_hex_single_byte() {
    let hex = format_asn1_bytes(&[0xAB], Asn1FormatMode::Hex);
    assert_eq!(hex, "AB");
}