synta 0.1.6

//! Primitive ASN.1 types

#[cfg(all(not(feature = "std"), feature = "serde"))]
use alloc::string::String;
use smallvec::SmallVec;

/// ASN.1 BOOLEAN value.
///
/// In DER and CER encoding `TRUE` must be encoded as `0xFF` and `FALSE` as
/// `0x00`.  In BER any non-zero byte represents `TRUE`.
///
/// The inner `bool` is accessible via the public tuple field `0` or through
/// the [`value`](Self::value) getter.
///
/// # Example
/// ```
/// use synta::Boolean;
///
/// let t = Boolean::new(true);
/// assert!(t.value());
///
/// let f: Boolean = false.into();
/// assert!(!f.value());
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Boolean(pub bool);

impl Boolean {
    /// Create a new Boolean
    pub const fn new(value: bool) -> Self {
        Self(value)
    }

    /// Get the boolean value
    pub const fn value(&self) -> bool {
        self.0
    }
}

impl From<bool> for Boolean {
    fn from(value: bool) -> Self {
        Self(value)
    }
}

impl From<Boolean> for bool {
    fn from(value: Boolean) -> Self {
        value.0
    }
}

/// ASN.1 INTEGER with arbitrary precision
///
/// Uses SmallVec to store up to 16 bytes inline (covers i128/u128),
/// spilling to heap only for truly large integers.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Integer {
    // Big-endian two's complement representation
    // Stores up to 16 bytes inline, avoiding allocation for common cases
    bytes: SmallVec<[u8; 16]>,
}

impl Integer {
    /// Create an integer from i64
    pub fn from_i64(value: i64) -> Self {
        let bytes = value.to_be_bytes();

        // Find the minimal representation by trimming leading 0x00 or 0xFF bytes
        // that don't affect the sign
        let mut start = 0;
        while start < bytes.len() - 1 {
            let current = bytes[start];
            let next = bytes[start + 1];

            // Can trim if:
            // - current is 0x00 and next has high bit 0 (positive)
            // - current is 0xFF and next has high bit 1 (negative)
            if (current == 0x00 && next & 0x80 == 0) || (current == 0xFF && next & 0x80 != 0) {
                start += 1;
            } else {
                break;
            }
        }

        Self {
            bytes: SmallVec::from_slice(&bytes[start..]),
        }
    }

    /// Create an integer from u64
    pub fn from_u64(value: u64) -> Self {
        let bytes = value.to_be_bytes();

        // Find first non-zero byte
        let mut start = 0;
        while start < bytes.len() - 1 && bytes[start] == 0 {
            start += 1;
        }

        // If the high bit is set, we need a leading 0x00 to keep it positive
        let mut result_bytes = SmallVec::new();
        if bytes[start] & 0x80 != 0 {
            result_bytes.push(0x00);
        }
        result_bytes.extend_from_slice(&bytes[start..]);

        Self {
            bytes: result_bytes,
        }
    }

    /// Create an integer from i128
    pub fn from_i128(value: i128) -> Self {
        let bytes = value.to_be_bytes();

        let mut start = 0;
        while start < bytes.len() - 1 {
            let current = bytes[start];
            let next = bytes[start + 1];

            if (current == 0x00 && next & 0x80 == 0) || (current == 0xFF && next & 0x80 != 0) {
                start += 1;
            } else {
                break;
            }
        }

        Self {
            bytes: SmallVec::from_slice(&bytes[start..]),
        }
    }

    /// Create an integer from raw big-endian two's complement bytes.
    ///
    /// The bytes are accepted as-is without validation.  In particular:
    ///
    /// - No minimal-encoding check is performed; a caller could pass a
    ///   non-minimal encoding (e.g. unnecessary leading `0x00` bytes) that
    ///   DER's decoder would normally reject.
    /// - An empty slice is interpreted as zero (`as_i64()` returns `Ok(0)`).
    ///
    /// Prefer the typed constructors (`from_i64`, `from_u64`, `from_i128`)
    /// unless you are re-wrapping bytes that have already been validated by
    /// the decoder.
    pub fn from_bytes(bytes: &[u8]) -> Self {
        Self {
            bytes: SmallVec::from_slice(bytes),
        }
    }

    /// Get the raw bytes (big-endian two's complement)
    pub fn as_bytes(&self) -> &[u8] {
        &self.bytes
    }

    /// Convert to i64 if possible
    pub fn as_i64(&self) -> crate::Result<i64> {
        if self.bytes.is_empty() {
            return Ok(0);
        }

        // Check if value fits in i64
        if self.bytes.len() > 8 {
            return Err(crate::Error::IntegerOverflow { position: 0 });
        }

        // Extend to 8 bytes with sign extension
        let mut bytes = [if self.bytes[0] & 0x80 != 0 {
            0xFF
        } else {
            0x00
        }; 8];
        let offset = 8 - self.bytes.len();
        bytes[offset..].copy_from_slice(&self.bytes);

        Ok(i64::from_be_bytes(bytes))
    }

    /// Convert to u64 if possible
    pub fn as_u64(&self) -> crate::Result<u64> {
        if self.bytes.is_empty() {
            return Ok(0);
        }

        // Check if value is negative
        if self.bytes[0] & 0x80 != 0 {
            return Err(crate::Error::IntegerOverflow { position: 0 });
        }

        // Check if value fits in u64 (at most 8 bytes; the sign check above
        // already ruled out negative values, so no leading-zero padding needed).
        if self.bytes.len() > 8 {
            return Err(crate::Error::IntegerOverflow { position: 0 });
        }

        let mut bytes = [0u8; 8];
        let offset = 8 - self.bytes.len();
        bytes[offset..].copy_from_slice(&self.bytes);

        Ok(u64::from_be_bytes(bytes))
    }

    /// Convert to i8 if possible
    pub fn as_i8(&self) -> crate::Result<i8> {
        let v = self.as_i64()?;
        i8::try_from(v).map_err(|_| crate::Error::IntegerOverflow { position: 0 })
    }

    /// Convert to i16 if possible
    pub fn as_i16(&self) -> crate::Result<i16> {
        let v = self.as_i64()?;
        i16::try_from(v).map_err(|_| crate::Error::IntegerOverflow { position: 0 })
    }

    /// Convert to i32 if possible
    pub fn as_i32(&self) -> crate::Result<i32> {
        let v = self.as_i64()?;
        i32::try_from(v).map_err(|_| crate::Error::IntegerOverflow { position: 0 })
    }

    /// Convert to u8 if possible
    pub fn as_u8(&self) -> crate::Result<u8> {
        let v = self.as_u64()?;
        u8::try_from(v).map_err(|_| crate::Error::IntegerOverflow { position: 0 })
    }

    /// Convert to u16 if possible
    pub fn as_u16(&self) -> crate::Result<u16> {
        let v = self.as_u64()?;
        u16::try_from(v).map_err(|_| crate::Error::IntegerOverflow { position: 0 })
    }

    /// Convert to u32 if possible
    pub fn as_u32(&self) -> crate::Result<u32> {
        let v = self.as_u64()?;
        u32::try_from(v).map_err(|_| crate::Error::IntegerOverflow { position: 0 })
    }

    /// Convert to i128 if possible
    pub fn as_i128(&self) -> crate::Result<i128> {
        if self.bytes.is_empty() {
            return Ok(0);
        }

        if self.bytes.len() > 16 {
            return Err(crate::Error::IntegerOverflow { position: 0 });
        }

        // Extend to 16 bytes with sign extension
        let mut bytes = [if self.bytes[0] & 0x80 != 0 {
            0xFF
        } else {
            0x00
        }; 16];
        let offset = 16 - self.bytes.len();
        bytes[offset..].copy_from_slice(&self.bytes);

        Ok(i128::from_be_bytes(bytes))
    }
}

impl From<i8> for Integer {
    fn from(value: i8) -> Self {
        Self::from_i64(value as i64)
    }
}

impl From<i16> for Integer {
    fn from(value: i16) -> Self {
        Self::from_i64(value as i64)
    }
}

impl From<i32> for Integer {
    fn from(value: i32) -> Self {
        Self::from_i64(value as i64)
    }
}

impl From<i64> for Integer {
    fn from(value: i64) -> Self {
        Self::from_i64(value)
    }
}

impl From<u8> for Integer {
    fn from(value: u8) -> Self {
        Self::from_u64(value as u64)
    }
}

impl From<u16> for Integer {
    fn from(value: u16) -> Self {
        Self::from_u64(value as u64)
    }
}

impl From<u32> for Integer {
    fn from(value: u32) -> Self {
        Self::from_u64(value as u64)
    }
}

impl From<u64> for Integer {
    fn from(value: u64) -> Self {
        Self::from_u64(value)
    }
}

impl From<i128> for Integer {
    fn from(value: i128) -> Self {
        Self::from_i128(value)
    }
}

/// ASN.1 ENUMERATED — an integer with named values (X.680 §19).
///
/// Encoded identically to [`Integer`] (big-endian two's complement, minimal
/// encoding) but carries the ENUMERATED tag (10) instead of the INTEGER tag (2).
/// Commonly used for status codes, e.g. the `responseStatus` field in an OCSP
/// `OCSPResponse`.
///
/// The raw bytes are accessible via [`as_bytes`](Self::as_bytes); the value is
/// most conveniently read as an `i64` or `i32` via [`as_i64`](Self::as_i64) /
/// [`as_i32`](Self::as_i32).
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Enumerated {
    /// Big-endian two's complement representation (minimal).
    bytes: SmallVec<[u8; 4]>,
}

impl Enumerated {
    /// Construct from a raw `i32` value.
    pub fn from_i32(value: i32) -> Self {
        let bytes = value.to_be_bytes();
        let mut start = 0;
        while start < bytes.len() - 1 {
            let current = bytes[start];
            let next = bytes[start + 1];
            if (current == 0x00 && next & 0x80 == 0) || (current == 0xFF && next & 0x80 != 0) {
                start += 1;
            } else {
                break;
            }
        }
        Self {
            bytes: SmallVec::from_slice(&bytes[start..]),
        }
    }

    /// Construct from a raw `i64` value.
    pub fn from_i64(value: i64) -> Self {
        let bytes = value.to_be_bytes();
        let mut start = 0;
        while start < bytes.len() - 1 {
            let current = bytes[start];
            let next = bytes[start + 1];
            if (current == 0x00 && next & 0x80 == 0) || (current == 0xFF && next & 0x80 != 0) {
                start += 1;
            } else {
                break;
            }
        }
        Self {
            bytes: SmallVec::from_slice(&bytes[start..]),
        }
    }

    /// Construct from raw big-endian two's complement bytes.
    pub fn from_bytes(bytes: &[u8]) -> Self {
        Self {
            bytes: SmallVec::from_slice(bytes),
        }
    }

    /// Return the raw bytes (big-endian two's complement).
    pub fn as_bytes(&self) -> &[u8] {
        &self.bytes
    }

    /// Convert to `i64` if the value fits.
    pub fn as_i64(&self) -> crate::Result<i64> {
        if self.bytes.is_empty() {
            return Ok(0);
        }
        if self.bytes.len() > 8 {
            return Err(crate::Error::IntegerOverflow { position: 0 });
        }
        let fill = if self.bytes[0] & 0x80 != 0 {
            0xFF
        } else {
            0x00
        };
        let mut buf = [fill; 8];
        buf[8 - self.bytes.len()..].copy_from_slice(&self.bytes);
        Ok(i64::from_be_bytes(buf))
    }

    /// Convert to `i32` if the value fits.
    pub fn as_i32(&self) -> crate::Result<i32> {
        let v = self.as_i64()?;
        i32::try_from(v).map_err(|_| crate::Error::IntegerOverflow { position: 0 })
    }

    /// Convert to `u8` if the value is non-negative and fits.
    pub fn as_u8(&self) -> crate::Result<u8> {
        let v = self.as_i64()?;
        if !(0..=255).contains(&v) {
            return Err(crate::Error::IntegerOverflow { position: 0 });
        }
        Ok(v as u8)
    }
}

impl From<i32> for Enumerated {
    fn from(v: i32) -> Self {
        Self::from_i32(v)
    }
}

impl From<i64> for Enumerated {
    fn from(v: i64) -> Self {
        Self::from_i64(v)
    }
}

// Decode trait for Enumerated
impl crate::traits::Decode<'_> for Enumerated {
    fn decode(decoder: &mut crate::der::decoder::Decoder) -> crate::Result<Self> {
        use crate::tag::TAG_ENUMERATED;

        let tag = decoder.read_tag()?;
        let expected_tag = crate::Tag::universal(TAG_ENUMERATED);

        if tag != expected_tag {
            return Err(crate::Error::UnexpectedTag {
                position: decoder.position(),
                expected: expected_tag,
                actual: tag,
            });
        }

        let length = decoder.read_length()?;
        let len = length.definite()?;

        if len == 0 {
            return Err(crate::Error::InvalidEncoding {
                position: decoder.position(),
                tag,
                #[cfg(feature = "std")]
                reason: "ENUMERATED length cannot be 0".to_string(),
                #[cfg(not(feature = "std"))]
                reason: "ENUMERATED length cannot be 0",
            });
        }

        let bytes = decoder.read_bytes(len)?;

        // DER/CER: minimal encoding (same rule as INTEGER)
        if (decoder.encoding() == crate::Encoding::Der
            || decoder.encoding() == crate::Encoding::Cer)
            && bytes.len() > 1
        {
            let first = bytes[0];
            let second = bytes[1];
            if (first == 0x00 && (second & 0x80) == 0) || (first == 0xFF && (second & 0x80) != 0) {
                #[cfg(feature = "std")]
                return Err(if decoder.encoding() == crate::Encoding::Der {
                    crate::Error::DerViolation {
                        position: decoder.position(),
                        reason: "DER requires minimal ENUMERATED encoding".to_string(),
                    }
                } else {
                    crate::Error::CerViolation {
                        position: decoder.position(),
                        reason: "CER requires minimal ENUMERATED encoding".to_string(),
                    }
                });

                #[cfg(not(feature = "std"))]
                return Err(if decoder.encoding() == crate::Encoding::Der {
                    crate::Error::DerViolation {
                        position: decoder.position(),
                        reason: "DER requires minimal ENUMERATED encoding",
                    }
                } else {
                    crate::Error::CerViolation {
                        position: decoder.position(),
                        reason: "CER requires minimal ENUMERATED encoding",
                    }
                });
            }
        }

        Ok(Enumerated::from_bytes(bytes))
    }
}

// Encode trait for Enumerated
impl crate::traits::Encode for Enumerated {
    fn encode(&self, encoder: &mut crate::der::encoder::Encoder) -> crate::Result<()> {
        use crate::tag::TAG_ENUMERATED;

        let tag = crate::Tag::universal(TAG_ENUMERATED);
        encoder.write_tag(tag)?;
        encoder.write_length(self.bytes.len())?;
        encoder.write_bytes(&self.bytes);
        Ok(())
    }

    fn encoded_len(&self) -> crate::Result<usize> {
        let tag_len = 1;
        let length = self.bytes.len();
        let length_len = crate::Length::Definite(length).encoded_len()?;
        Ok(tag_len + length_len + length)
    }
}

impl crate::traits::Tagged for Enumerated {
    fn tag() -> crate::Tag {
        crate::Tag::universal(crate::tag::TAG_ENUMERATED)
    }
}

#[cfg(feature = "serde")]
impl serde::Serialize for Enumerated {
    fn serialize<S: serde::Serializer>(&self, s: S) -> core::result::Result<S::Ok, S::Error> {
        match self.as_i64() {
            Ok(v) => s.serialize_i64(v),
            Err(_) => s.serialize_bytes(&self.bytes),
        }
    }
}

#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for Enumerated {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> core::result::Result<Self, D::Error> {
        let v = <i64 as serde::Deserialize<'de>>::deserialize(d)?;
        Ok(Enumerated::from_i64(v))
    }
}

/// ASN.1 NULL — the type with exactly one value and no content.
///
/// Encoded as the two-byte sequence `0x05 0x00` (tag 5, length 0).
/// Commonly used as the `parameters` field in `AlgorithmIdentifier` when the
/// algorithm takes no parameters (e.g. in RSA or many hash algorithm OIDs).
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Null;

// Implement Decode trait for Boolean
impl crate::traits::Decode<'_> for Boolean {
    fn decode(decoder: &mut crate::der::decoder::Decoder) -> crate::Result<Self> {
        use crate::tag::TAG_BOOLEAN;

        let tag = decoder.read_tag()?;
        let expected_tag = crate::Tag::universal(TAG_BOOLEAN);

        if tag != expected_tag {
            return Err(crate::Error::UnexpectedTag {
                position: decoder.position(),
                expected: expected_tag,
                actual: tag,
            });
        }

        let length = decoder.read_length()?;
        if length.definite()? != 1 {
            return Err(crate::Error::InvalidEncoding {
                position: decoder.position(),
                tag,
                #[cfg(feature = "std")]
                reason: "Boolean length must be 1".to_string(),
                #[cfg(not(feature = "std"))]
                reason: "Boolean length must be 1",
            });
        }

        let bytes = decoder.remaining();
        if bytes.is_empty() {
            return Err(crate::Error::UnexpectedEof {
                position: decoder.position(),
            });
        }

        // Read one byte
        let bytes = decoder.read_bytes(1)?;
        let value_byte = bytes[0];

        // DER and CER require TRUE = 0xFF, FALSE = 0x00
        // BER allows any non-zero value for TRUE
        if (decoder.encoding() == crate::Encoding::Der
            || decoder.encoding() == crate::Encoding::Cer)
            && value_byte != 0x00
            && value_byte != 0xFF
        {
            #[cfg(feature = "std")]
            return Err(if decoder.encoding() == crate::Encoding::Der {
                crate::Error::DerViolation {
                    position: decoder.position(),
                    reason: format!(
                        "DER requires BOOLEAN to be 0x00 or 0xFF, got 0x{:02X}",
                        value_byte
                    ),
                }
            } else {
                crate::Error::CerViolation {
                    position: decoder.position(),
                    reason: format!(
                        "CER requires BOOLEAN to be 0x00 or 0xFF, got 0x{:02X}",
                        value_byte
                    ),
                }
            });

            #[cfg(not(feature = "std"))]
            return Err(if decoder.encoding() == crate::Encoding::Der {
                crate::Error::DerViolation {
                    position: decoder.position(),
                    reason: "DER requires BOOLEAN to be 0x00 or 0xFF",
                }
            } else {
                crate::Error::CerViolation {
                    position: decoder.position(),
                    reason: "CER requires BOOLEAN to be 0x00 or 0xFF",
                }
            });
        }

        Ok(Boolean(value_byte != 0))
    }
}

// Implement Encode trait for Boolean
impl crate::traits::Encode for Boolean {
    fn encode(&self, encoder: &mut crate::der::encoder::Encoder) -> crate::Result<()> {
        use crate::tag::TAG_BOOLEAN;

        let tag = crate::Tag::universal(TAG_BOOLEAN);
        encoder.write_tag(tag)?;
        encoder.write_length(1)?;

        // DER requires 0xFF for true, 0x00 for false
        encoder.write_bytes(&[if self.0 { 0xFF } else { 0x00 }]);
        Ok(())
    }

    fn encoded_len(&self) -> crate::Result<usize> {
        // tag (1 byte) + length (1 byte) + value (1 byte)
        Ok(3)
    }
}

// Implement Decode trait for Integer
impl crate::traits::Decode<'_> for Integer {
    fn decode(decoder: &mut crate::der::decoder::Decoder) -> crate::Result<Self> {
        use crate::tag::TAG_INTEGER;

        let tag = decoder.read_tag()?;
        let expected_tag = crate::Tag::universal(TAG_INTEGER);

        if tag != expected_tag {
            return Err(crate::Error::UnexpectedTag {
                position: decoder.position(),
                expected: expected_tag,
                actual: tag,
            });
        }

        let length = decoder.read_length()?;
        let len = length.definite()?;

        if len == 0 {
            return Err(crate::Error::InvalidEncoding {
                position: decoder.position(),
                tag,
                #[cfg(feature = "std")]
                reason: "Integer length cannot be 0".to_string(),
                #[cfg(not(feature = "std"))]
                reason: "Integer length cannot be 0",
            });
        }

        let bytes = decoder.read_bytes(len)?;

        // DER and CER require minimal encoding (no unnecessary leading zeros or 0xFF bytes)
        if (decoder.encoding() == crate::Encoding::Der
            || decoder.encoding() == crate::Encoding::Cer)
            && bytes.len() > 1
        {
            let first = bytes[0];
            let second = bytes[1];

            // Check for unnecessary leading 0x00 (when next byte has high bit 0)
            if first == 0x00 && (second & 0x80) == 0 {
                #[cfg(feature = "std")]
                return Err(if decoder.encoding() == crate::Encoding::Der {
                    crate::Error::DerViolation {
                        position: decoder.position(),
                        reason: "DER requires minimal INTEGER encoding (unnecessary leading 0x00)"
                            .to_string(),
                    }
                } else {
                    crate::Error::CerViolation {
                        position: decoder.position(),
                        reason: "CER requires minimal INTEGER encoding (unnecessary leading 0x00)"
                            .to_string(),
                    }
                });

                #[cfg(not(feature = "std"))]
                return Err(if decoder.encoding() == crate::Encoding::Der {
                    crate::Error::DerViolation {
                        position: decoder.position(),
                        reason: "DER requires minimal INTEGER encoding",
                    }
                } else {
                    crate::Error::CerViolation {
                        position: decoder.position(),
                        reason: "CER requires minimal INTEGER encoding",
                    }
                });
            }

            // Check for unnecessary leading 0xFF (when next byte has high bit 1)
            if first == 0xFF && (second & 0x80) != 0 {
                #[cfg(feature = "std")]
                return Err(if decoder.encoding() == crate::Encoding::Der {
                    crate::Error::DerViolation {
                        position: decoder.position(),
                        reason: "DER requires minimal INTEGER encoding (unnecessary leading 0xFF)"
                            .to_string(),
                    }
                } else {
                    crate::Error::CerViolation {
                        position: decoder.position(),
                        reason: "CER requires minimal INTEGER encoding (unnecessary leading 0xFF)"
                            .to_string(),
                    }
                });

                #[cfg(not(feature = "std"))]
                return Err(if decoder.encoding() == crate::Encoding::Der {
                    crate::Error::DerViolation {
                        position: decoder.position(),
                        reason: "DER requires minimal INTEGER encoding",
                    }
                } else {
                    crate::Error::CerViolation {
                        position: decoder.position(),
                        reason: "CER requires minimal INTEGER encoding",
                    }
                });
            }
        }

        Ok(Integer::from_bytes(bytes))
    }
}

// Implement Encode trait for Integer
impl crate::traits::Encode for Integer {
    fn encode(&self, encoder: &mut crate::der::encoder::Encoder) -> crate::Result<()> {
        use crate::tag::TAG_INTEGER;

        let tag = crate::Tag::universal(TAG_INTEGER);
        encoder.write_tag(tag)?;
        encoder.write_length(self.bytes.len())?;
        encoder.write_bytes(&self.bytes);
        Ok(())
    }

    fn encoded_len(&self) -> crate::Result<usize> {
        let tag_len = 1; // Universal tags < 31 are 1 byte
        let length = self.bytes.len();
        let length_len = crate::Length::Definite(length).encoded_len()?;
        Ok(tag_len + length_len + length)
    }
}

// Implement Decode trait for Null
impl crate::traits::Decode<'_> for Null {
    fn decode(decoder: &mut crate::der::decoder::Decoder) -> crate::Result<Self> {
        use crate::tag::TAG_NULL;

        let tag = decoder.read_tag()?;
        let expected_tag = crate::Tag::universal(TAG_NULL);

        if tag != expected_tag {
            return Err(crate::Error::UnexpectedTag {
                position: decoder.position(),
                expected: expected_tag,
                actual: tag,
            });
        }

        let length = decoder.read_length()?;
        if length.definite()? != 0 {
            return Err(crate::Error::InvalidEncoding {
                position: decoder.position(),
                tag,
                #[cfg(feature = "std")]
                reason: "NULL length must be 0".to_string(),
                #[cfg(not(feature = "std"))]
                reason: "NULL length must be 0",
            });
        }

        Ok(Null)
    }
}

// Implement Encode trait for Null
impl crate::traits::Encode for Null {
    fn encode(&self, encoder: &mut crate::der::encoder::Encoder) -> crate::Result<()> {
        use crate::tag::TAG_NULL;

        let tag = crate::Tag::universal(TAG_NULL);
        encoder.write_tag(tag)?;
        encoder.write_length(0)?;
        Ok(())
    }

    fn encoded_len(&self) -> crate::Result<usize> {
        // tag (1 byte) + length (1 byte)
        Ok(2)
    }
}

// Implement Tagged trait
impl crate::traits::Tagged for Boolean {
    fn tag() -> crate::Tag {
        crate::Tag::universal(crate::tag::TAG_BOOLEAN)
    }
}

impl crate::traits::Tagged for Integer {
    fn tag() -> crate::Tag {
        crate::Tag::universal(crate::tag::TAG_INTEGER)
    }
}

impl crate::traits::Tagged for Null {
    fn tag() -> crate::Tag {
        crate::Tag::universal(crate::tag::TAG_NULL)
    }
}

// ── Private helpers for ASN.1 binary REAL (X.690 §8.5) ─────────────────────

/// Decompose a finite, non-zero `f64` into `(sign, mantissa, exponent)` such
/// that `value = (-1)^sign × mantissa × 2^exponent` and `mantissa` is odd
/// (canonical / shortest form).
fn f64_to_real_parts(bits: u64) -> (bool, u64, i64) {
    let sign = (bits >> 63) != 0;
    let biased_exp = ((bits >> 52) & 0x7FF) as i32;
    let frac_bits = bits & 0x000F_FFFF_FFFF_FFFF;

    let (mut mantissa, mut exponent): (u64, i64) = if biased_exp == 0 {
        // Denormal: no implicit leading 1.
        (frac_bits, -1074)
    } else {
        // Normal: restore implicit leading 1 at bit 52.
        (frac_bits | (1u64 << 52), i64::from(biased_exp) - 1023 - 52)
    };

    // Strip trailing zero bits so the mantissa is odd (canonical encoding).
    if mantissa != 0 {
        let trailing = mantissa.trailing_zeros();
        mantissa >>= trailing;
        exponent += i64::from(trailing);
    }
    (sign, mantissa, exponent)
}

/// Encode `v` as a signed big-endian two's complement integer using the minimum
/// number of bytes.  Returns `(length, buffer)`.
fn real_encode_exp(v: i64) -> (usize, [u8; 8]) {
    let buf = v.to_be_bytes();
    let mut start = 0usize;
    while start < 7 {
        let curr = buf[start];
        let next = buf[start + 1];
        // A leading byte is redundant when it is pure sign-extension of the next.
        if (curr == 0x00 && next & 0x80 == 0) || (curr == 0xFF && next & 0x80 != 0) {
            start += 1;
        } else {
            break;
        }
    }
    (8 - start, buf)
}

/// Encode `v` as an unsigned big-endian integer using the minimum number of
/// bytes (at least 1).  Returns `(length, buffer)`.
fn real_encode_mantissa(v: u64) -> (usize, [u8; 8]) {
    if v == 0 {
        return (1, [0u8; 8]);
    }
    let buf = v.to_be_bytes();
    let start = buf.iter().position(|&b| b != 0).unwrap_or(7);
    (8 - start, buf)
}

/// Decode a big-endian two's complement signed integer from `bytes`.
fn real_decode_exp(bytes: &[u8]) -> i64 {
    let fill = if !bytes.is_empty() && bytes[0] & 0x80 != 0 {
        0xFF
    } else {
        0x00
    };
    let mut buf = [fill; 8];
    let offset = 8 - bytes.len().min(8);
    buf[offset..].copy_from_slice(&bytes[..bytes.len().min(8)]);
    i64::from_be_bytes(buf)
}

/// Decode a big-endian unsigned integer from `bytes` into a `u64`.
fn real_decode_mantissa(bytes: &[u8]) -> crate::Result<u64> {
    if bytes.len() > 8 {
        return Err(crate::Error::IntegerOverflow { position: 0 });
    }
    let mut buf = [0u8; 8];
    buf[8 - bytes.len()..].copy_from_slice(bytes);
    Ok(u64::from_be_bytes(buf))
}

/// Reconstruct an `f64` from the ASN.1 binary REAL components
/// `(-1)^sign × mantissa × 2^exponent` (base-2, any `exponent`).
fn f64_from_binary_real(sign: bool, mantissa: u64, exponent: i64) -> f64 {
    if mantissa == 0 {
        return if sign { -0.0 } else { 0.0 };
    }

    // Position of the most significant set bit (0 = bit 0).
    let msb = 63u32 - mantissa.leading_zeros();
    // True unbiased IEEE 754 exponent.
    let true_exp = exponent + msb as i64;

    let sign_bit: u64 = if sign { 1 << 63 } else { 0 };

    let bits = if true_exp > 1023 {
        // Overflow → ±Infinity.
        sign_bit | 0x7FF0_0000_0000_0000
    } else if true_exp >= -1022 {
        // Normal: (1 + fraction) × 2^true_exp.
        let biased = (true_exp + 1023) as u64;
        // Extract the 52 explicit fraction bits (below the implicit leading 1).
        let frac = if msb <= 52 {
            (mantissa & ((1u64 << msb) - 1)) << (52 - msb)
        } else {
            // More than 53 significant bits: truncate toward zero.
            (mantissa >> (msb - 52)) & 0x000F_FFFF_FFFF_FFFF
        };
        sign_bit | (biased << 52) | frac
    } else if true_exp >= -1074 {
        // Denormal: implicit leading bit is 0.
        // We need: frac_bits × 2^(-1074) = mantissa × 2^exponent
        //   ⇒  frac_bits = mantissa × 2^(exponent + 1074)
        let shift = exponent + 1074;
        let frac = if shift >= 0 {
            let s = shift as u32;
            if s < 64 {
                mantissa.checked_shl(s).unwrap_or(u64::MAX)
            } else {
                0
            }
        } else {
            let s = (-shift) as u32;
            if s < 64 {
                mantissa >> s
            } else {
                0
            }
        };
        sign_bit | (frac & 0x000F_FFFF_FFFF_FFFF)
    } else {
        // Underflow → ±0.0.
        sign_bit
    };

    f64::from_bits(bits)
}

// ── Real type ────────────────────────────────────────────────────────────────

/// ASN.1 REAL type (IEEE 754 double-precision floating point).
///
/// Encoded and decoded using the standard ASN.1 binary REAL format defined
/// in X.690 §8.5.  The on-wire layout is:
///
/// - **Zero** (`0.0` / `-0.0`): zero-length content.
/// - **Special values** (`±∞`, `NaN`): one-byte content (`0x40`/`0x41`/`0x42`).
/// - **Finite non-zero values**: binary encoding with a variable-length info
///   byte, a signed base-2 exponent in the minimum number of bytes, and the
///   odd-normalised mantissa in the minimum number of bytes.
///
/// Values encoded by this crate are interoperable with other standard-compliant
/// ASN.1 implementations.  During decoding the full X.690 §8.5 repertoire is
/// accepted:
///
/// - Binary (base-2, base-8, base-16) per §8.5.6
/// - Decimal (ISO 6093 NR1, NR2, NR3) per §8.5.7
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Real(pub f64);

impl Real {
    /// Create a new Real from f64
    pub fn new(value: f64) -> Self {
        Real(value)
    }

    /// Get the f64 value
    pub fn value(&self) -> f64 {
        self.0
    }
}

impl From<f64> for Real {
    fn from(value: f64) -> Self {
        Real(value)
    }
}

impl From<Real> for f64 {
    fn from(real: Real) -> Self {
        real.0
    }
}

impl crate::traits::Encode for Real {
    fn encode(&self, encoder: &mut crate::der::encoder::Encoder) -> crate::Result<()> {
        use crate::tag::TAG_REAL;

        let tag = crate::Tag::universal(TAG_REAL);
        encoder.write_tag(tag)?;

        // Zero: zero-length content (X.690 §8.5.2).
        if self.0 == 0.0 {
            encoder.write_length(0)?;
            return Ok(());
        }

        // Special values: one-byte content (X.690 §8.5.9).
        if self.0.is_infinite() {
            encoder.write_length(1)?;
            encoder.write_bytes(&[if self.0.is_sign_positive() {
                0x40
            } else {
                0x41
            }]);
            return Ok(());
        }
        if self.0.is_nan() {
            encoder.write_length(1)?;
            encoder.write_bytes(&[0x42]);
            return Ok(());
        }

        // Binary REAL encoding per X.690 §8.5.6.
        let (sign, mantissa, exponent) = f64_to_real_parts(self.0.to_bits());

        let (exp_len, exp_buf) = real_encode_exp(exponent);
        let (mant_len, mant_buf) = real_encode_mantissa(mantissa);

        // For f64 the exponent fits in at most 2 bytes (range ≈ [-1074, 1023]),
        // so exp_len is always 1 or 2 and bits 1–0 of the info byte suffice.
        debug_assert!(exp_len <= 3);

        // Info byte: bit7=1 (binary), bit6=sign, bits5–4=00 (base 2),
        //            bits3–2=00 (scaling factor 0), bits1–0=exp_len−1.
        let info = 0x80u8 | (u8::from(sign) << 6) | (exp_len as u8 - 1);

        encoder.write_length(1 + exp_len + mant_len)?;
        encoder.write_bytes(&[info]);
        encoder.write_bytes(&exp_buf[8 - exp_len..]);
        encoder.write_bytes(&mant_buf[8 - mant_len..]);
        Ok(())
    }

    fn encoded_len(&self) -> crate::Result<usize> {
        let tag_len = 1;
        let content_len = if self.0 == 0.0 {
            0
        } else if self.0.is_infinite() || self.0.is_nan() {
            1
        } else {
            let (_, mantissa, exponent) = f64_to_real_parts(self.0.to_bits());
            let (exp_len, _) = real_encode_exp(exponent);
            let (mant_len, _) = real_encode_mantissa(mantissa);
            1 + exp_len + mant_len // info byte + exponent + mantissa
        };
        let length_len = crate::Length::Definite(content_len).encoded_len()?;
        Ok(tag_len + length_len + content_len)
    }
}

impl crate::traits::Decode<'_> for Real {
    fn decode(decoder: &mut crate::der::decoder::Decoder) -> crate::Result<Self> {
        use crate::tag::TAG_REAL;

        let tag = decoder.read_tag()?;
        let expected_tag = crate::Tag::universal(TAG_REAL);

        if tag != expected_tag {
            return Err(crate::Error::UnexpectedTag {
                position: decoder.position(),
                expected: expected_tag,
                actual: tag,
            });
        }

        let length = decoder.read_length()?;
        let n = length.definite()?;

        if n == 0 {
            // Zero (X.690 §8.5.2).
            return Ok(Real(0.0));
        }

        let bytes = decoder.read_bytes(n)?;
        let info = bytes[0];

        if n == 1 {
            // Special value (X.690 §8.5.9).
            return match info {
                0x40 => Ok(Real(f64::INFINITY)),
                0x41 => Ok(Real(f64::NEG_INFINITY)),
                0x42 => Ok(Real(f64::NAN)),
                _ => Err(crate::Error::InvalidEncoding {
                    position: decoder.position(),
                    tag: expected_tag,
                    reason: "Invalid REAL special value".into(),
                }),
            };
        }

        if info & 0x80 != 0 {
            // Binary encoding (X.690 §8.5.6).
            let sign = (info >> 6) & 1 != 0;
            let base: u8 = match (info >> 4) & 0x03 {
                0 => 2,
                1 => 8,
                2 => 16,
                _ => {
                    return Err(crate::Error::InvalidEncoding {
                        position: decoder.position(),
                        tag: expected_tag,
                        reason: "Reserved base value in binary REAL".into(),
                    })
                }
            };
            let scaling = (info >> 2) & 0x03; // pre-shift: mantissa × 2^scaling

            // Exponent length field (bits 1–0 of info byte).
            let (exp_len, rest) = match info & 0x03 {
                0 => (1usize, &bytes[1..]),
                1 => (2, &bytes[1..]),
                2 => (3, &bytes[1..]),
                _ => {
                    // Long form: next byte holds the exponent byte count.
                    if bytes.len() < 2 {
                        return Err(crate::Error::UnexpectedEof {
                            position: decoder.position(),
                        });
                    }
                    (bytes[1] as usize, &bytes[2..])
                }
            };

            if rest.len() < exp_len || exp_len == 0 {
                return Err(crate::Error::UnexpectedEof {
                    position: decoder.position(),
                });
            }
            let (exp_bytes, mant_bytes) = rest.split_at(exp_len);

            let exponent = real_decode_exp(exp_bytes);
            let mantissa =
                real_decode_mantissa(mant_bytes).map_err(|_| crate::Error::InvalidEncoding {
                    position: decoder.position(),
                    tag: expected_tag,
                    reason: "REAL mantissa too large for u64".into(),
                })?;

            // Apply the scaling factor (mantissa is treated as mantissa × 2^scaling).
            let mantissa = mantissa << u32::from(scaling);

            // Convert base-8 / base-16 exponents to base-2.
            let base2_exp = match base {
                2 => exponent,
                8 => exponent.saturating_mul(3),
                16 => exponent.saturating_mul(4),
                _ => unreachable!(),
            };

            Ok(Real(f64_from_binary_real(sign, mantissa, base2_exp)))
        } else if info & 0xC0 == 0 {
            // Decimal encoding per X.690 §8.5.7 (ISO 6093 NR1/NR2/NR3).
            //
            // The info byte lower 6 bits select the NR form:
            //   0x01 = NR1 (integer, e.g. "12")
            //   0x02 = NR2 (decimal, e.g. "1.5")
            //   0x03 = NR3 (scientific, e.g. "1.5E1")
            //
            // The remaining bytes are the ASCII decimal representation.
            let nr_form = info & 0x3F;
            if nr_form == 0 || nr_form > 3 {
                return Err(crate::Error::InvalidEncoding {
                    position: decoder.position(),
                    tag: expected_tag,
                    reason: "Unknown decimal REAL NR form".into(),
                });
            }

            let ascii = &bytes[1..];
            let s = core::str::from_utf8(ascii).map_err(|_| crate::Error::InvalidEncoding {
                position: decoder.position(),
                tag: expected_tag,
                reason: "Non-ASCII bytes in decimal REAL".into(),
            })?;

            // ISO 6093 permits leading spaces; trim before parsing.
            let s = s.trim();
            if s.is_empty() {
                return Err(crate::Error::InvalidEncoding {
                    position: decoder.position(),
                    tag: expected_tag,
                    reason: "Empty decimal REAL string".into(),
                });
            }

            // Rust's float parser handles NR1 (integer), NR2 (decimal point),
            // and NR3 (exponent with E/e and optional sign).
            s.parse::<f64>()
                .map(Real)
                .map_err(|_| crate::Error::InvalidEncoding {
                    position: decoder.position(),
                    tag: expected_tag,
                    reason: "Malformed decimal REAL string".into(),
                })
        } else {
            Err(crate::Error::InvalidEncoding {
                position: decoder.position(),
                tag: expected_tag,
                reason: "Invalid REAL encoding".into(),
            })
        }
    }
}

impl crate::traits::Tagged for Real {
    fn tag() -> crate::Tag {
        crate::Tag::universal(crate::tag::TAG_REAL)
    }
}

// ---- serde support ----

#[cfg(feature = "serde")]
impl serde::Serialize for Boolean {
    fn serialize<S: serde::Serializer>(&self, s: S) -> core::result::Result<S::Ok, S::Error> {
        s.serialize_bool(self.0)
    }
}

#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for Boolean {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> core::result::Result<Self, D::Error> {
        let v = <bool as serde::Deserialize<'de>>::deserialize(d)?;
        Ok(Boolean(v))
    }
}

/// `Integer` serializes as a lowercase hexadecimal string (big-endian two's complement).
#[cfg(feature = "serde")]
impl serde::Serialize for Integer {
    fn serialize<S: serde::Serializer>(&self, s: S) -> core::result::Result<S::Ok, S::Error> {
        let hex = crate::serde_impl::bytes_to_hex(self.as_bytes());
        s.serialize_str(&hex)
    }
}

#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for Integer {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> core::result::Result<Self, D::Error> {
        let s = <String as serde::Deserialize<'de>>::deserialize(d)?;
        let bytes = crate::serde_impl::hex_to_bytes::<D::Error>(&s)?;
        Ok(Integer::from_bytes(&bytes))
    }
}

#[cfg(feature = "serde")]
impl serde::Serialize for Null {
    fn serialize<S: serde::Serializer>(&self, s: S) -> core::result::Result<S::Ok, S::Error> {
        s.serialize_unit()
    }
}

#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for Null {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> core::result::Result<Self, D::Error> {
        struct NullVisitor;
        impl<'de> serde::de::Visitor<'de> for NullVisitor {
            type Value = Null;
            fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
                write!(f, "null")
            }
            fn visit_unit<E: serde::de::Error>(self) -> core::result::Result<Null, E> {
                Ok(Null)
            }
            fn visit_none<E: serde::de::Error>(self) -> core::result::Result<Null, E> {
                Ok(Null)
            }
        }
        d.deserialize_unit(NullVisitor)
    }
}

#[cfg(feature = "serde")]
impl serde::Serialize for Real {
    fn serialize<S: serde::Serializer>(&self, s: S) -> core::result::Result<S::Ok, S::Error> {
        s.serialize_f64(self.0)
    }
}

#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for Real {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> core::result::Result<Self, D::Error> {
        let v = <f64 as serde::Deserialize<'de>>::deserialize(d)?;
        Ok(Real(v))
    }
}