synta-python 0.3.1

//! Python wrappers for primitive ASN.1 types: INTEGER, OCTET STRING, BIT STRING,
//! BOOLEAN, UTCTime, GeneralizedTime, REAL, NULL.

use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};

use pyo3::exceptions::{PyOverflowError, PyValueError};
use pyo3::prelude::*;
use pyo3::types::PyBytes;

use synta::{
    BitString, Boolean, FromDer, GeneralizedTime, Integer, Null, OctetString, Real, ToDer, UtcTime,
};

use crate::error::SyntaErr;

/// Python wrapper for ASN.1 INTEGER
#[pyclass(name = "Integer")]
#[derive(Debug, Clone)]
pub struct PyInteger {
    pub(crate) inner: Integer,
}

#[pymethods]
impl PyInteger {
    /// Create a new Integer from a Python int
    #[new]
    fn new(value: i64) -> Self {
        Self {
            inner: Integer::from_i64(value),
        }
    }

    /// Convert to Python int (i64)
    fn to_int(&self) -> PyResult<i64> {
        self.inner
            .as_i64()
            .map_err(|_| PyOverflowError::new_err("Integer too large for i64"))
    }

    /// Get the raw bytes (big-endian two's complement)
    fn to_bytes<'py>(&self, py: Python<'py>) -> Bound<'py, PyBytes> {
        PyBytes::new(py, self.inner.as_bytes())
    }

    /// Create Integer from raw bytes
    #[staticmethod]
    fn from_bytes(bytes: &[u8]) -> Self {
        Self {
            inner: Integer::from_bytes(bytes),
        }
    }

    /// Create Integer from an unsigned 64-bit value
    #[staticmethod]
    fn from_u64(value: u64) -> Self {
        Self {
            inner: Integer::from_u64(value),
        }
    }

    /// Return the DER encoding of this ``Integer``.
    fn to_der<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyBytes>> {
        Ok(PyBytes::new(py, &self.inner.to_der().map_err(SyntaErr)?))
    }

    /// Parse a DER-encoded ``Integer``.
    ///
    /// :raises ValueError: if the bytes cannot be decoded.
    #[staticmethod]
    fn from_der(data: &[u8]) -> PyResult<Self> {
        let inner = Integer::from_der(data).map_err(SyntaErr)?;
        Ok(Self { inner })
    }

    /// Convert to Python int (i128) for larger integers
    fn to_i128(&self) -> PyResult<i128> {
        self.inner
            .as_i128()
            .map_err(|_| PyOverflowError::new_err("Integer too large for i128"))
    }

    fn __eq__(&self, other: &Self) -> bool {
        // DER encodes integers with minimal bytes (no redundant leading zeros),
        // so comparing the raw bytes is equivalent to comparing by value.
        self.inner.as_bytes() == other.inner.as_bytes()
    }

    fn __hash__(&self) -> u64 {
        let mut h = DefaultHasher::new();
        self.inner.as_bytes().hash(&mut h);
        h.finish()
    }

    fn __repr__(&self) -> PyResult<String> {
        match self.inner.as_i64() {
            Ok(val) => Ok(format!("Integer({})", val)),
            Err(_) => Ok(format!("Integer(<{} bytes>)", self.inner.as_bytes().len())),
        }
    }

    fn __str__(&self) -> PyResult<String> {
        match self.inner.as_i64() {
            Ok(val) => Ok(val.to_string()),
            Err(_) => Ok(format!("<integer {} bytes>", self.inner.as_bytes().len())),
        }
    }
}

/// Python wrapper for ASN.1 OCTET STRING
#[pyclass(name = "OctetString")]
#[derive(Debug, Clone)]
pub struct PyOctetString {
    pub(crate) inner: OctetString,
}

#[pymethods]
impl PyOctetString {
    /// Create a new OctetString from bytes
    #[new]
    fn new(data: Vec<u8>) -> Self {
        Self {
            inner: OctetString::new(data),
        }
    }

    /// Get the bytes as a Python bytes object
    fn to_bytes<'py>(&self, py: Python<'py>) -> Bound<'py, PyBytes> {
        PyBytes::new(py, self.inner.as_bytes())
    }

    /// Get the length
    fn __len__(&self) -> usize {
        self.inner.as_bytes().len()
    }

    fn __eq__(&self, other: &Self) -> bool {
        self.inner == other.inner
    }

    fn __repr__(&self) -> String {
        format!("OctetString(<{} bytes>)", self.inner.as_bytes().len())
    }

    /// Return the DER encoding of this ``OctetString``.
    fn to_der<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyBytes>> {
        Ok(PyBytes::new(py, &self.inner.to_der().map_err(SyntaErr)?))
    }

    /// Parse a DER-encoded ``OctetString``.
    ///
    /// :raises ValueError: if the bytes cannot be decoded.
    #[staticmethod]
    fn from_der(data: &[u8]) -> PyResult<Self> {
        let inner = OctetString::from_der(data).map_err(SyntaErr)?;
        Ok(Self { inner })
    }
}

/// Python wrapper for ASN.1 BIT STRING
#[pyclass(name = "BitString")]
#[derive(Debug, Clone)]
pub struct PyBitString {
    pub(crate) inner: BitString,
}

#[pymethods]
impl PyBitString {
    /// Create a new BitString from bytes and unused bits count
    #[new]
    fn new(data: Vec<u8>, unused_bits: u8) -> PyResult<Self> {
        if unused_bits > 7 {
            return Err(PyValueError::new_err("unused_bits must be 0-7"));
        }
        let inner = BitString::new(data, unused_bits)
            .map_err(|e| PyValueError::new_err(format!("Invalid BitString: {:?}", e)))?;
        Ok(Self { inner })
    }

    /// Get the bytes
    fn to_bytes<'py>(&self, py: Python<'py>) -> Bound<'py, PyBytes> {
        PyBytes::new(py, self.inner.as_bytes())
    }

    /// Get the number of unused bits in the last byte
    fn unused_bits(&self) -> u8 {
        self.inner.unused_bits()
    }

    /// Get the number of bits
    fn bit_len(&self) -> usize {
        self.inner.bit_len()
    }

    fn __len__(&self) -> usize {
        self.inner.bit_len()
    }

    fn __eq__(&self, other: &Self) -> bool {
        self.inner == other.inner
    }

    fn __repr__(&self) -> String {
        format!(
            "BitString(<{} bits, {} unused>)",
            self.inner.bit_len(),
            self.inner.unused_bits()
        )
    }

    /// Return the DER encoding of this ``BitString``.
    fn to_der<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyBytes>> {
        Ok(PyBytes::new(py, &self.inner.to_der().map_err(SyntaErr)?))
    }

    /// Parse a DER-encoded ``BitString``.
    ///
    /// :raises ValueError: if the bytes cannot be decoded.
    #[staticmethod]
    fn from_der(data: &[u8]) -> PyResult<Self> {
        let inner = BitString::from_der(data).map_err(SyntaErr)?;
        Ok(Self { inner })
    }
}

/// Python wrapper for ASN.1 BOOLEAN
#[pyclass(name = "Boolean")]
#[derive(Debug, Clone, Copy)]
pub struct PyBoolean {
    pub(crate) inner: Boolean,
}

#[pymethods]
impl PyBoolean {
    /// Create a new Boolean
    #[new]
    fn new(value: bool) -> Self {
        Self {
            inner: Boolean::new(value),
        }
    }

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

    fn __bool__(&self) -> bool {
        self.inner.value()
    }

    fn __eq__(&self, other: &Self) -> bool {
        self.inner.value() == other.inner.value()
    }

    fn __hash__(&self) -> isize {
        // Matches Python's hash(True) == 1, hash(False) == 0.
        self.inner.value() as isize
    }

    fn __repr__(&self) -> String {
        format!("Boolean({})", self.inner.value())
    }

    /// Return the DER encoding of this ``Boolean``.
    #[allow(clippy::wrong_self_convention)]
    fn to_der<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyBytes>> {
        Ok(PyBytes::new(py, &self.inner.to_der().map_err(SyntaErr)?))
    }

    /// Parse a DER-encoded ``Boolean``.
    ///
    /// :raises ValueError: if the bytes cannot be decoded.
    #[staticmethod]
    fn from_der(data: &[u8]) -> PyResult<Self> {
        let inner = Boolean::from_der(data).map_err(SyntaErr)?;
        Ok(Self { inner })
    }
}

/// Python wrapper for ASN.1 UTCTime
#[pyclass(name = "UtcTime")]
#[derive(Debug, Clone)]
pub struct PyUtcTime {
    pub(crate) inner: UtcTime,
}

#[pymethods]
impl PyUtcTime {
    /// Create a new UTCTime (year must be in 1950-2049 range)
    #[new]
    fn new(year: u16, month: u8, day: u8, hour: u8, minute: u8, second: u8) -> PyResult<Self> {
        let inner = UtcTime::new(year, month, day, hour, minute, second)
            .map_err(|e| PyValueError::new_err(format!("Invalid UTCTime: {:?}", e)))?;
        Ok(Self { inner })
    }

    /// Four-digit year (1950–2049).
    #[getter]
    fn year(&self) -> u16 {
        self.inner.year
    }

    /// Month (1–12).
    #[getter]
    fn month(&self) -> u8 {
        self.inner.month
    }

    /// Day of month (1–31).
    #[getter]
    fn day(&self) -> u8 {
        self.inner.day
    }

    /// Hour (0–23).
    #[getter]
    fn hour(&self) -> u8 {
        self.inner.hour
    }

    /// Minute (0–59).
    #[getter]
    fn minute(&self) -> u8 {
        self.inner.minute
    }

    /// Second (0–59).
    #[getter]
    fn second(&self) -> u8 {
        self.inner.second
    }

    fn __str__(&self) -> String {
        self.inner.to_string()
    }

    fn __repr__(&self) -> String {
        format!("UtcTime('{}')", self.inner)
    }

    /// Return the DER encoding of this ``UtcTime``.
    fn to_der<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyBytes>> {
        Ok(PyBytes::new(py, &self.inner.to_der().map_err(SyntaErr)?))
    }

    /// Parse a DER-encoded ``UtcTime``.
    ///
    /// :raises ValueError: if the bytes cannot be decoded.
    #[staticmethod]
    fn from_der(data: &[u8]) -> PyResult<Self> {
        let inner = UtcTime::from_der(data).map_err(SyntaErr)?;
        Ok(Self { inner })
    }
}

impl std::fmt::Display for PyUtcTime {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.inner)
    }
}

/// Python wrapper for ASN.1 GeneralizedTime
#[pyclass(name = "GeneralizedTime")]
#[derive(Debug, Clone)]
pub struct PyGeneralizedTime {
    pub(crate) inner: GeneralizedTime,
}

#[pymethods]
impl PyGeneralizedTime {
    /// Create a new GeneralizedTime
    ///
    /// Args:
    ///     milliseconds: Optional fractional seconds in milliseconds (0-999)
    #[new]
    fn new(
        year: u16,
        month: u8,
        day: u8,
        hour: u8,
        minute: u8,
        second: u8,
        milliseconds: Option<u16>,
    ) -> PyResult<Self> {
        let inner = GeneralizedTime::new(year, month, day, hour, minute, second, milliseconds)
            .map_err(|e| PyValueError::new_err(format!("Invalid GeneralizedTime: {:?}", e)))?;
        Ok(Self { inner })
    }

    /// Four-digit year.
    #[getter]
    fn year(&self) -> u16 {
        self.inner.year
    }

    /// Month (1–12).
    #[getter]
    fn month(&self) -> u8 {
        self.inner.month
    }

    /// Day of month (1–31).
    #[getter]
    fn day(&self) -> u8 {
        self.inner.day
    }

    /// Hour (0–23).
    #[getter]
    fn hour(&self) -> u8 {
        self.inner.hour
    }

    /// Minute (0–59).
    #[getter]
    fn minute(&self) -> u8 {
        self.inner.minute
    }

    /// Second (0–59).
    #[getter]
    fn second(&self) -> u8 {
        self.inner.second
    }

    /// Fractional seconds expressed as whole milliseconds (0–999), or ``None``.
    #[getter]
    fn milliseconds(&self) -> Option<u16> {
        self.inner.milliseconds
    }

    fn __str__(&self) -> String {
        self.inner.to_string()
    }

    fn __repr__(&self) -> String {
        format!("GeneralizedTime('{}')", self.inner)
    }

    /// Return the DER encoding of this ``GeneralizedTime``.
    fn to_der<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyBytes>> {
        Ok(PyBytes::new(py, &self.inner.to_der().map_err(SyntaErr)?))
    }

    /// Parse a DER-encoded ``GeneralizedTime``.
    ///
    /// :raises ValueError: if the bytes cannot be decoded.
    #[staticmethod]
    fn from_der(data: &[u8]) -> PyResult<Self> {
        let inner = GeneralizedTime::from_der(data).map_err(SyntaErr)?;
        Ok(Self { inner })
    }
}

impl std::fmt::Display for PyGeneralizedTime {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.inner)
    }
}

/// Python wrapper for ASN.1 REAL
#[pyclass(name = "Real")]
#[derive(Debug, Clone, Copy)]
pub struct PyReal {
    pub(crate) inner: Real,
}

#[pymethods]
impl PyReal {
    /// Create a new Real from a Python float
    #[new]
    fn new(value: f64) -> Self {
        Self {
            inner: Real::new(value),
        }
    }

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

    /// Return True if this is positive infinity
    fn is_infinite(&self) -> bool {
        self.inner.value().is_infinite()
    }

    /// Return True if this is NaN (not-a-number)
    fn is_nan(&self) -> bool {
        self.inner.value().is_nan()
    }

    /// Return True if the value is finite
    fn is_finite(&self) -> bool {
        self.inner.value().is_finite()
    }

    fn __float__(&self) -> f64 {
        self.inner.value()
    }

    fn __repr__(&self) -> String {
        format!("Real({})", self.inner.value())
    }

    fn __str__(&self) -> String {
        self.inner.value().to_string()
    }

    fn __eq__(&self, other: &Self) -> bool {
        // NaN != NaN by IEEE 754 — mirror Python float behaviour
        self.inner.value() == other.inner.value()
    }

    fn __hash__(&self, py: Python<'_>) -> PyResult<isize> {
        // Delegate to Python's float.__hash__ so that hash(Real(1.0)) == hash(1.0) == hash(1),
        // matching the Python data model guarantee for numeric types.
        self.inner.value().into_pyobject(py)?.hash()
    }

    /// Return the DER encoding of this ``Real``.
    #[allow(clippy::wrong_self_convention)]
    fn to_der<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyBytes>> {
        Ok(PyBytes::new(py, &self.inner.to_der().map_err(SyntaErr)?))
    }

    /// Parse a DER-encoded ``Real``.
    ///
    /// :raises ValueError: if the bytes cannot be decoded.
    #[staticmethod]
    fn from_der(data: &[u8]) -> PyResult<Self> {
        let inner = Real::from_der(data).map_err(SyntaErr)?;
        Ok(Self { inner })
    }
}

/// Python wrapper for ASN.1 NULL
#[pyclass(name = "Null")]
#[derive(Debug, Clone, Copy)]
pub struct PyNull;

#[pymethods]
impl PyNull {
    /// Create a ``Null`` value.
    #[new]
    fn new() -> Self {
        Self
    }

    fn __repr__(&self) -> String {
        "Null()".to_string()
    }

    fn __eq__(&self, _other: &Self) -> bool {
        true
    }

    fn __hash__(&self) -> isize {
        // All Null values are equal; use a fixed hash consistent with __eq__.
        0
    }

    /// Return the DER encoding of this ``Null``.
    #[allow(clippy::wrong_self_convention)]
    fn to_der<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyBytes>> {
        Ok(PyBytes::new(py, &Null.to_der().map_err(SyntaErr)?))
    }

    /// Parse a DER-encoded ``Null``.
    ///
    /// :raises ValueError: if the bytes cannot be decoded.
    #[staticmethod]
    fn from_der(data: &[u8]) -> PyResult<Self> {
        Null::from_der(data).map_err(SyntaErr)?;
        Ok(Self)
    }
}