internet 0.1.0

//! ICMPv4 message types and codecs.
//!
//! As defined in [RFC 792].
//! See the [IANA ICMP Parameters] registry for the complete list.
//!
//! ## Messages
//!
//! * [Echo] / [EchoReply]
//! * [DestinationUnreachable]
//! * [SourceQuench]
//! * [Redirect]
//! * [TimeExceeded]
//! * [ParameterProblem]
//! * [Timestamp] / [TimestampReply]
//! * [InformationRequest] / [InformationReply]
//!
//! ## Supporting types
//!
//! * [Type] — the message type.
//! * [Checksum] — the Internet Checksum.
//!
//! [RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
//! [IANA ICMP Parameters]: https://www.iana.org/assignments/icmp-parameters

use crate::{
    Buf, BufError, BufMut, BufResult, Codec, Cursor,
    ietf::ipv4::{Address, Header},
};

/// An ICMPv4 message.
///
/// Currently covers only the messages defined in [RFC 792].
/// See the [IANA ICMP Parameters] registry for the complete list.
///
/// [RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
/// [IANA ICMP Parameters]: https://www.iana.org/assignments/icmp-parameters
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Message {
    /// Echo Reply.
    EchoReply(EchoReply),
    /// Destination Unreachable.
    DestinationUnreachable(DestinationUnreachable),
    /// Source Quench.
    SourceQuench(SourceQuench),
    /// Redirect.
    Redirect(Redirect),
    /// Echo.
    Echo(Echo),
    /// Time Exceeded.
    TimeExceeded(TimeExceeded),
    /// Parameter Problem.
    ParameterProblem(ParameterProblem),
    /// Timestamp.
    Timestamp(Timestamp),
    /// Timestamp Reply.
    TimestampReply(TimestampReply),
    /// Information Request.
    InformationRequest(InformationRequest),
    /// Information Reply.
    InformationReply(InformationReply),
}

impl Codec for Message {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        match self {
            Message::EchoReply(message) => message.encode(writer, ()),
            Message::DestinationUnreachable(message) => message.encode(writer, ()),
            Message::SourceQuench(message) => message.encode(writer, ()),
            Message::Redirect(message) => message.encode(writer, ()),
            Message::Echo(message) => message.encode(writer, ()),
            Message::TimeExceeded(message) => message.encode(writer, ()),
            Message::ParameterProblem(message) => message.encode(writer, ()),
            Message::Timestamp(message) => message.encode(writer, ()),
            Message::TimestampReply(message) => message.encode(writer, ()),
            Message::InformationRequest(message) => message.encode(writer, ()),
            Message::InformationReply(message) => message.encode(writer, ()),
        }
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        let type_byte = reader.peek_u8()?;
        let r#type = Type::decode(&mut Cursor::new(&[type_byte]), ())?;
        Ok(match r#type {
            Type::EchoReply => Self::EchoReply(EchoReply::decode(reader, ())?),
            Type::DestinationUnreachable => {
                Self::DestinationUnreachable(DestinationUnreachable::decode(reader, ())?)
            }
            Type::SourceQuench => Self::SourceQuench(SourceQuench::decode(reader, ())?),
            Type::Redirect => Self::Redirect(Redirect::decode(reader, ())?),
            Type::Echo => Self::Echo(Echo::decode(reader, ())?),
            Type::TimeExceeded => Self::TimeExceeded(TimeExceeded::decode(reader, ())?),
            Type::ParameterProblem => Self::ParameterProblem(ParameterProblem::decode(reader, ())?),
            Type::Timestamp => Self::Timestamp(Timestamp::decode(reader, ())?),
            Type::TimestampReply => Self::TimestampReply(TimestampReply::decode(reader, ())?),
            Type::InformationRequest => {
                Self::InformationRequest(InformationRequest::decode(reader, ())?)
            }
            Type::InformationReply => Self::InformationReply(InformationReply::decode(reader, ())?),
        })
    }
}

/// An ICMPv4 message type.
///
/// Determines the format of the remaining data, as defined in [RFC 792].
/// See the [IANA ICMP Parameters] registry for the complete list.
///
/// [RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
/// [IANA ICMP Parameters]: https://www.iana.org/assignments/icmp-parameters
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum Type {
    /// Echo Reply.
    EchoReply = 0,
    /// Destination Unreachable.
    DestinationUnreachable = 3,
    /// Source Quench.
    SourceQuench = 4,
    /// Redirect.
    Redirect = 5,
    /// Echo.
    Echo = 8,
    /// Time Exceeded.
    TimeExceeded = 11,
    /// Parameter Problem.
    ParameterProblem = 12,
    /// Timestamp.
    Timestamp = 13,
    /// Timestamp Reply.
    TimestampReply = 14,
    /// Information Request.
    InformationRequest = 15,
    /// Information Reply.
    InformationReply = 16,
}

impl Codec for Type {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        (*self as u8).encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        match u8::decode(reader, ())? {
            x if x == (Self::EchoReply as u8) => Ok(Self::EchoReply),
            x if x == (Self::DestinationUnreachable as u8) => Ok(Self::DestinationUnreachable),
            x if x == (Self::SourceQuench as u8) => Ok(Self::SourceQuench),
            x if x == (Self::Redirect as u8) => Ok(Self::Redirect),
            x if x == (Self::Echo as u8) => Ok(Self::Echo),
            x if x == (Self::TimeExceeded as u8) => Ok(Self::TimeExceeded),
            x if x == (Self::ParameterProblem as u8) => Ok(Self::ParameterProblem),
            x if x == (Self::Timestamp as u8) => Ok(Self::Timestamp),
            x if x == (Self::TimestampReply as u8) => Ok(Self::TimestampReply),
            x if x == (Self::InformationRequest as u8) => Ok(Self::InformationRequest),
            x if x == (Self::InformationReply as u8) => Ok(Self::InformationReply),
            _ => Err(BufError::UnexpectedValue),
        }
    }
}

/// A zero code value.
///
/// Used when the code field is unused.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum NoCode {
    /// Zero.
    Zero = 0,
}

impl Codec for NoCode {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        (*self as u8).encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        match u8::decode(reader, ())? {
            x if x == Self::Zero as u8 => Ok(Self::Zero),
            _ => Err(BufError::UnexpectedValue),
        }
    }
}

/// An ICMPv4 checksum.
///
/// Used to detect data corruption, as defined in [RFC 792].
///
/// [RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Checksum(pub u16);

impl Checksum {
    /// Calculates the Internet Checksum.
    ///
    /// As defined in [RFC 1071].
    ///
    /// # Examples
    ///
    /// ```
    /// use internet::ietf::icmpv4::Checksum;
    ///
    /// // The checksum field must be zeroed before calculation.
    /// let mut packet = vec![0x08, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01];
    ///
    /// let checksum = Checksum::calculate(&packet);
    /// packet[2..4].copy_from_slice(&checksum.0.to_be_bytes());
    /// ```
    ///
    /// [RFC 1071]: https://datatracker.ietf.org/doc/html/rfc1071
    pub fn calculate(data: &[u8]) -> Self {
        let mut sum: u32 = 0;
        let mut i = 0;

        while i + 1 < data.len() {
            sum += u16::from_be_bytes([data[i], data[i + 1]]) as u32;
            i += 2;
        }

        if i < data.len() {
            sum += (data[i] as u32) << 8;
        }

        while sum >> 16 != 0 {
            sum = (sum & 0xFFFF) + (sum >> 16);
        }

        Checksum(!(sum as u16))
    }
}

impl Codec for Checksum {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        self.0.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        Ok(Self(u16::decode(reader, ())?))
    }
}

/// A Destination Unreachable message.
///
/// Sent when the destination cannot be reached, as defined in [RFC 792].
///
/// [RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DestinationUnreachable {
    /// The code.
    pub code: DestinationUnreachableCode,
    /// The checksum.
    pub checksum: Checksum,
    /// The IPv4 header.
    pub header: Header,
    /// The first 64 bits of the original datagram.
    pub bytes: [u8; 8],
}

impl DestinationUnreachable {
    /// The type.
    pub const TYPE: Type = Type::DestinationUnreachable;
    /// Reserved. Must be zero.
    pub const UNUSED: [u8; 4] = [0u8; 4];
}

impl Codec for DestinationUnreachable {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        Self::TYPE.encode(writer, ())?;
        self.code.encode(writer, ())?;
        self.checksum.encode(writer, ())?;
        Self::UNUSED.encode(writer, ())?;
        self.header.encode(writer, ())?;
        self.bytes.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        match Type::decode(reader, ())? {
            Type::DestinationUnreachable => (),
            _ => return Err(BufError::UnexpectedValue),
        }
        let code = DestinationUnreachableCode::decode(reader, ())?;
        let checksum = Checksum::decode(reader, ())?;
        match reader.read_array::<4>()? {
            Self::UNUSED => (),
            _ => return Err(BufError::UnexpectedValue),
        }
        let header = Header::decode(reader, ())?;
        let bytes = reader.read_array::<8>()?;
        Ok(Self {
            code,
            checksum,
            header,
            bytes,
        })
    }
}

/// A code for [`DestinationUnreachable`].
///
/// The reason the destination is unreachable.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum DestinationUnreachableCode {
    /// Net unreachable.
    NetUnreachable = 0,
    /// Host unreachable.
    HostUnreachable = 1,
    /// Protocol unreachable.
    ProtocolUnreachable = 2,
    /// Port unreachable.
    PortUnreachable = 3,
    /// Fragmentation needed and DF set.
    FragmentationNeededAndDfSet = 4,
    /// Source route failed.
    SourceRouteFailed = 5,
}

impl Codec for DestinationUnreachableCode {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        (*self as u8).encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        match u8::decode(reader, ())? {
            0 => Ok(Self::NetUnreachable),
            1 => Ok(Self::HostUnreachable),
            2 => Ok(Self::ProtocolUnreachable),
            3 => Ok(Self::PortUnreachable),
            4 => Ok(Self::FragmentationNeededAndDfSet),
            5 => Ok(Self::SourceRouteFailed),
            _ => Err(BufError::UnexpectedValue),
        }
    }
}
/// A Time Exceeded message.
///
/// Sent when the time to live or fragment reassembly time has been exceeded,
/// as defined in [RFC 792].
///
/// [RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TimeExceeded {
    /// The code.
    pub code: TimeExceededCode,
    /// The checksum.
    pub checksum: Checksum,
    /// The original header.
    pub header: Header,
    /// The first 64 bits of the original datagram.
    pub bytes: [u8; 8],
}

impl TimeExceeded {
    /// The type.
    pub const TYPE: Type = Type::TimeExceeded;
    /// Reserved. Must be zero.
    pub const UNUSED: [u8; 4] = [0u8; 4];
}

impl Codec for TimeExceeded {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        Self::TYPE.encode(writer, ())?;
        self.code.encode(writer, ())?;
        self.checksum.encode(writer, ())?;
        Self::UNUSED.encode(writer, ())?;
        self.header.encode(writer, ())?;
        self.bytes.encode(writer, ())?;
        Ok(())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        match Type::decode(reader, ())? {
            Type::TimeExceeded => (),
            _ => return Err(BufError::UnexpectedValue),
        }
        let code = TimeExceededCode::decode(reader, ())?;
        let checksum = Checksum::decode(reader, ())?;
        match reader.read_array::<4>()? {
            Self::UNUSED => (),
            _ => return Err(BufError::UnexpectedValue),
        }
        let header = Header::decode(reader, ())?;
        let bytes = reader.read_array::<8>()?;
        Ok(Self {
            code,
            checksum,
            header,
            bytes,
        })
    }
}

/// A code for [`TimeExceeded`].
///
/// The reason the time was exceeded.
///
/// [RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum TimeExceededCode {
    /// Time to live exceeded in transit.
    TimeToLiveExceededInTransit = 0,
    /// Fragment reassembly time exceeded.
    FragmentReassemblyTimeExceeded = 1,
}

impl Codec for TimeExceededCode {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        (*self as u8).encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        match u8::decode(reader, ())? {
            0 => Ok(Self::TimeToLiveExceededInTransit),
            1 => Ok(Self::FragmentReassemblyTimeExceeded),
            _ => Err(BufError::UnexpectedValue),
        }
    }
}

/// A Parameter Problem message.
///
/// Sent when a parameter in the IP header is invalid, as defined in [RFC 792].
///
/// [RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ParameterProblem {
    /// The code.
    pub code: ParameterProblemCode,
    /// The checksum.
    pub checksum: Checksum,
    /// The byte offset of the error.
    pub pointer: u8,
    /// Reserved. Must be zero.
    pub unused: [u8; 3],
    /// The original header.
    pub header: Header,
    /// The first 64 bits of the original datagram.
    pub bytes: [u8; 8],
}

impl ParameterProblem {
    /// The type.
    pub const TYPE: Type = Type::ParameterProblem;
    /// Reserved. Must be zero.
    pub const UNUSED: [u8; 3] = [0u8; 3];
}

impl Codec for ParameterProblem {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        Self::TYPE.encode(writer, ())?;
        self.code.encode(writer, ())?;
        self.checksum.encode(writer, ())?;
        self.pointer.encode(writer, ())?;
        Self::UNUSED.encode(writer, ())?;
        self.header.encode(writer, ())?;
        self.bytes.encode(writer, ())?;
        Ok(())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        match Type::decode(reader, ())? {
            Type::ParameterProblem => (),
            _ => return Err(BufError::UnexpectedValue),
        }
        let code = ParameterProblemCode::decode(reader, ())?;
        let checksum = Checksum::decode(reader, ())?;
        let pointer = u8::decode(reader, ())?;
        match reader.read_array::<3>()? {
            Self::UNUSED => (),
            _ => return Err(BufError::UnexpectedValue),
        }
        let header = Header::decode(reader, ())?;
        let bytes = reader.read_array::<8>()?;
        Ok(Self {
            code,
            checksum,
            pointer,
            unused: Self::UNUSED,
            header,
            bytes,
        })
    }
}

/// A code for [`ParameterProblem`].
///
/// [RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
pub type ParameterProblemCode = NoCode;

/// A Source Quench message.
///
/// Requests that the sender reduce the rate of transmission, as defined in [RFC 792].
///
/// [RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SourceQuench {
    /// The code.
    pub code: SourceQuenchCode,
    /// The checksum.
    pub checksum: Checksum,
    /// The original header.
    pub header: Header,
    /// The first 64 bits of the original datagram.
    pub bytes: [u8; 8],
}

impl SourceQuench {
    /// The type.
    pub const TYPE: Type = Type::SourceQuench;
    /// Reserved. Must be zero.
    pub const UNUSED: [u8; 4] = [0u8; 4];
}

impl Codec for SourceQuench {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        Self::TYPE.encode(writer, ())?;
        self.code.encode(writer, ())?;
        self.checksum.encode(writer, ())?;
        Self::UNUSED.encode(writer, ())?;
        self.header.encode(writer, ())?;
        self.bytes.encode(writer, ())?;
        Ok(())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        match Type::decode(reader, ())? {
            Type::SourceQuench => (),
            _ => return Err(BufError::UnexpectedValue),
        }
        let code = SourceQuenchCode::decode(reader, ())?;
        let checksum = Checksum::decode(reader, ())?;
        match reader.read_array::<4>()? {
            Self::UNUSED => (),
            _ => return Err(BufError::UnexpectedValue),
        }
        let header = Header::decode(reader, ())?;
        let bytes = reader.read_array::<8>()?;
        Ok(Self {
            code,
            checksum,
            header,
            bytes,
        })
    }
}

/// A code for [`SourceQuench`].
///
/// [RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
pub type SourceQuenchCode = NoCode;

/// A Redirect message.
///
/// Directs the host to send traffic to a different gateway, as defined in [RFC 792].
///
/// [RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Redirect {
    /// The code.
    pub code: RedirectCode,
    /// The checksum.
    pub checksum: Checksum,
    /// The gateway address.
    pub gateway_internet_address: Address,
    /// The original header.
    pub header: Header,
    /// The first 64 bits of the original datagram.
    pub bytes: [u8; 8],
}

impl Redirect {
    /// The type.
    pub const TYPE: Type = Type::Redirect;
}

impl Codec for Redirect {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        Self::TYPE.encode(writer, ())?;
        self.code.encode(writer, ())?;
        self.checksum.encode(writer, ())?;
        self.gateway_internet_address.encode(writer, ())?;
        self.header.encode(writer, ())?;
        self.bytes.encode(writer, ())?;
        Ok(())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        match Type::decode(reader, ())? {
            Type::Redirect => (),
            _ => return Err(BufError::UnexpectedValue),
        }
        let code = RedirectCode::decode(reader, ())?;
        let checksum = Checksum::decode(reader, ())?;
        let gateway_internet_address = Address::decode(reader, ())?;
        let header = Header::decode(reader, ())?;
        let bytes = reader.read_array::<8>()?;
        Ok(Self {
            code,
            checksum,
            gateway_internet_address,
            header,
            bytes,
        })
    }
}

/// A code for [`Redirect`].
///
/// The redirection target.
///
/// [RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum RedirectCode {
    /// Redirect datagrams for the network.
    Network = 0,
    /// Redirect datagrams for the host.
    Host = 1,
    /// Redirect datagrams for the type of service and network.
    TypeOfServiceAndNetwork = 2,
    /// Redirect datagrams for the type of service and host.
    TypeOfServiceAndHost = 3,
}

impl Codec for RedirectCode {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        (*self as u8).encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        match u8::decode(reader, ())? {
            0 => Ok(Self::Network),
            1 => Ok(Self::Host),
            2 => Ok(Self::TypeOfServiceAndNetwork),
            3 => Ok(Self::TypeOfServiceAndHost),
            _ => Err(BufError::UnexpectedValue),
        }
    }
}

/// An Echo message.
///
/// Used to test reachability (commonly known as "ping"), as defined in [RFC 792].
///
/// [RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Echo {
    /// The code.
    pub code: EchoCode,
    /// The checksum.
    pub checksum: Checksum,
    /// The identifier.
    pub identifier: u16,
    /// The sequence number.
    pub sequence_number: u16,
    /// The data.
    pub data: Vec<u8>,
}

impl Echo {
    /// The type.
    pub const TYPE: Type = Type::Echo;
}

impl Codec for Echo {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        Self::TYPE.encode(writer, ())?;
        self.code.encode(writer, ())?;
        self.checksum.encode(writer, ())?;
        self.identifier.encode(writer, ())?;
        self.sequence_number.encode(writer, ())?;
        self.data.encode(writer, ())?;
        Ok(())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        match Type::decode(reader, ())? {
            Type::Echo => (),
            _ => return Err(BufError::UnexpectedValue),
        }
        let code = EchoCode::decode(reader, ())?;
        let checksum = Checksum::decode(reader, ())?;
        let identifier = u16::decode(reader, ())?;
        let sequence_number = u16::decode(reader, ())?;
        let data = Vec::decode(reader, ())?;
        Ok(Self {
            code,
            checksum,
            identifier,
            sequence_number,
            data,
        })
    }
}

/// A code for [`Echo`].
///
/// [RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
pub type EchoCode = NoCode;

/// An Echo Reply message.
///
/// Sent in response to an [`Echo`], as defined in [RFC 792].
///
/// [RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct EchoReply {
    /// The code.
    pub code: EchoReplyCode,
    /// The checksum.
    pub checksum: Checksum,
    /// The identifier.
    pub identifier: u16,
    /// The sequence number.
    pub sequence_number: u16,
    /// The data.
    pub data: Vec<u8>,
}

impl EchoReply {
    /// The type.
    pub const TYPE: Type = Type::EchoReply;
}

impl Codec for EchoReply {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        Self::TYPE.encode(writer, ())?;
        self.code.encode(writer, ())?;
        self.checksum.encode(writer, ())?;
        self.identifier.encode(writer, ())?;
        self.sequence_number.encode(writer, ())?;
        self.data.encode(writer, ())?;
        Ok(())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        match Type::decode(reader, ())? {
            Type::EchoReply => (),
            _ => return Err(BufError::UnexpectedValue),
        }
        let code = EchoReplyCode::decode(reader, ())?;
        let checksum = Checksum::decode(reader, ())?;
        let identifier = u16::decode(reader, ())?;
        let sequence_number = u16::decode(reader, ())?;
        let data = Vec::decode(reader, ())?;
        Ok(Self {
            code,
            checksum,
            identifier,
            sequence_number,
            data,
        })
    }
}

/// A code for [`EchoReply`].
///
/// [RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
pub type EchoReplyCode = NoCode;

/// A Timestamp message.
///
/// Used for time synchronization, as defined in [RFC 792].
///
/// [RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Timestamp {
    /// The code.
    pub code: TimestampCode,
    /// The checksum.
    pub checksum: Checksum,
    /// The identifier.
    pub identifier: u16,
    /// The sequence number.
    pub sequence_number: u16,
    /// The originate timestamp.
    pub originate_timestamp: u32,
    /// The receive timestamp.
    pub receive_timestamp: u32,
    /// The transmit timestamp.
    pub transmit_timestamp: u32,
}

impl Timestamp {
    /// The type.
    pub const TYPE: Type = Type::Timestamp;
}

impl Codec for Timestamp {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        Self::TYPE.encode(writer, ())?;
        self.code.encode(writer, ())?;
        self.checksum.encode(writer, ())?;
        self.identifier.encode(writer, ())?;
        self.sequence_number.encode(writer, ())?;
        self.originate_timestamp.encode(writer, ())?;
        self.receive_timestamp.encode(writer, ())?;
        self.transmit_timestamp.encode(writer, ())?;
        Ok(())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        match Type::decode(reader, ())? {
            Type::Timestamp => (),
            _ => return Err(BufError::UnexpectedValue),
        }
        let code = TimestampCode::decode(reader, ())?;
        let checksum = Checksum::decode(reader, ())?;
        let identifier = u16::decode(reader, ())?;
        let sequence_number = u16::decode(reader, ())?;
        let originate_timestamp = u32::decode(reader, ())?;
        let receive_timestamp = u32::decode(reader, ())?;
        let transmit_timestamp = u32::decode(reader, ())?;
        Ok(Self {
            code,
            checksum,
            identifier,
            sequence_number,
            originate_timestamp,
            receive_timestamp,
            transmit_timestamp,
        })
    }
}

/// A code for [`Timestamp`].
///
/// [RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
pub type TimestampCode = NoCode;

/// A Timestamp Reply message.
///
/// Sent in response to a [`Timestamp`], as defined in [RFC 792].
///
/// [RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct TimestampReply {
    /// The code.
    pub code: TimestampReplyCode,
    /// The checksum.
    pub checksum: Checksum,
    /// The identifier.
    pub identifier: u16,
    /// The sequence number.
    pub sequence_number: u16,
    /// The originate timestamp.
    pub originate_timestamp: u32,
    /// The receive timestamp.
    pub receive_timestamp: u32,
    /// The transmit timestamp.
    pub transmit_timestamp: u32,
}

impl TimestampReply {
    /// The type.
    pub const TYPE: Type = Type::TimestampReply;
}

impl Codec for TimestampReply {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        Self::TYPE.encode(writer, ())?;
        self.code.encode(writer, ())?;
        self.checksum.encode(writer, ())?;
        self.identifier.encode(writer, ())?;
        self.sequence_number.encode(writer, ())?;
        self.originate_timestamp.encode(writer, ())?;
        self.receive_timestamp.encode(writer, ())?;
        self.transmit_timestamp.encode(writer, ())?;
        Ok(())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        match Type::decode(reader, ())? {
            Type::TimestampReply => (),
            _ => return Err(BufError::UnexpectedValue),
        }
        let code = TimestampReplyCode::decode(reader, ())?;
        let checksum = Checksum::decode(reader, ())?;
        let identifier = u16::decode(reader, ())?;
        let sequence_number = u16::decode(reader, ())?;
        let originate_timestamp = u32::decode(reader, ())?;
        let receive_timestamp = u32::decode(reader, ())?;
        let transmit_timestamp = u32::decode(reader, ())?;
        Ok(Self {
            code,
            checksum,
            identifier,
            sequence_number,
            originate_timestamp,
            receive_timestamp,
            transmit_timestamp,
        })
    }
}

/// A code for [`TimestampReply`].
///
/// [RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
pub type TimestampReplyCode = NoCode;

/// An Information Request message.
///
/// Used to discover the network configuration, as defined in [RFC 792].
///
/// [RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct InformationRequest {
    /// The code.
    pub code: InformationRequestCode,
    /// The checksum.
    pub checksum: Checksum,
    /// The identifier.
    pub identifier: u16,
    /// The sequence number.
    pub sequence_number: u16,
}

impl InformationRequest {
    /// The type.
    pub const TYPE: Type = Type::InformationRequest;
}

impl Codec for InformationRequest {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        Self::TYPE.encode(writer, ())?;
        self.code.encode(writer, ())?;
        self.checksum.encode(writer, ())?;
        self.identifier.encode(writer, ())?;
        self.sequence_number.encode(writer, ())?;
        Ok(())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        match Type::decode(reader, ())? {
            Type::InformationRequest => (),
            _ => return Err(BufError::UnexpectedValue),
        }
        let code = InformationRequestCode::decode(reader, ())?;
        let checksum = Checksum::decode(reader, ())?;
        let identifier = u16::decode(reader, ())?;
        let sequence_number = u16::decode(reader, ())?;
        Ok(Self {
            code,
            checksum,
            identifier,
            sequence_number,
        })
    }
}

/// A code for [`InformationRequest`].
///
/// [RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
pub type InformationRequestCode = NoCode;

/// An Information Reply message.
///
/// Sent in response to an [`InformationRequest`], as defined in [RFC 792].
///
/// [RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct InformationReply {
    /// The code.
    pub code: InformationReplyCode,
    /// The checksum.
    pub checksum: Checksum,
    /// The identifier.
    pub identifier: u16,
    /// The sequence number.
    pub sequence_number: u16,
}

impl InformationReply {
    /// The type.
    pub const TYPE: Type = Type::InformationReply;
}

impl Codec for InformationReply {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        Self::TYPE.encode(writer, ())?;
        self.code.encode(writer, ())?;
        self.checksum.encode(writer, ())?;
        self.identifier.encode(writer, ())?;
        self.sequence_number.encode(writer, ())?;
        Ok(())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        match Type::decode(reader, ())? {
            Type::InformationReply => (),
            _ => return Err(BufError::UnexpectedValue),
        }
        let code = InformationReplyCode::decode(reader, ())?;
        let checksum = Checksum::decode(reader, ())?;
        let identifier = u16::decode(reader, ())?;
        let sequence_number = u16::decode(reader, ())?;
        Ok(Self {
            code,
            checksum,
            identifier,
            sequence_number,
        })
    }
}

/// A code for [`InformationReply`].
///
/// [RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
pub type InformationReplyCode = NoCode;

#[cfg(test)]
mod tests {
    use core::fmt::Debug;

    use crate::ietf::ip::Protocol;
    use crate::ietf::ipv4::{self, Address, Dscp, Ecn, Header, Ihl, Options};
    use crate::{
        Codec, Cursor,
        ietf::icmpv4::{
            Checksum, DestinationUnreachable, DestinationUnreachableCode, Echo, EchoCode,
            EchoReply, EchoReplyCode, InformationReply, InformationReplyCode, InformationRequest,
            InformationRequestCode, NoCode, ParameterProblem, ParameterProblemCode, Redirect,
            RedirectCode, SourceQuench, SourceQuenchCode, TimeExceeded, TimeExceededCode,
            Timestamp, TimestampCode, TimestampReply, TimestampReplyCode, Type,
        },
    };

    fn codec_roundtrip<T: Codec<C> + Debug + Eq, C: Copy>(
        etalon_struct: T,
        etalon_bytes: &[u8],
        context: C,
    ) {
        let mut encoded_bytes = vec![];
        {
            let writer = &mut Cursor::new(&mut encoded_bytes);
            etalon_struct.encode(writer, context).unwrap();
        }
        assert_eq!(etalon_bytes, &encoded_bytes);

        let decoded_struct = {
            let reader = &mut Cursor::new(&mut encoded_bytes);
            T::decode(reader, context).unwrap()
        };
        assert_eq!(etalon_struct, decoded_struct);

        encoded_bytes.fill(0x00);
        {
            let writer = &mut Cursor::new(&mut encoded_bytes);
            decoded_struct.encode(writer, context).unwrap();
        }
        assert_eq!(etalon_bytes, &encoded_bytes);
    }

    #[test]
    fn checksum() {
        let packet = &[0x08, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02];
        let checksum = Checksum::calculate(packet);

        let mut with_checksum = vec![0x08, 0x00];
        with_checksum.extend_from_slice(&checksum.0.to_be_bytes());
        with_checksum.extend_from_slice(&[0x00, 0x01, 0x00, 0x02]);

        let verify = Checksum::calculate(&with_checksum);
        assert!(verify.0 == 0x0000 || verify.0 == 0xFFFF);
    }

    #[test]
    fn type_roundtrip() {
        let cases = [
            (Type::EchoReply, &[0x00][..]),
            (Type::DestinationUnreachable, &[0x03][..]),
            (Type::SourceQuench, &[0x04][..]),
            (Type::Redirect, &[0x05][..]),
            (Type::Echo, &[0x08][..]),
            (Type::TimeExceeded, &[0x0b][..]),
            (Type::ParameterProblem, &[0x0c][..]),
            (Type::Timestamp, &[0x0d][..]),
            (Type::TimestampReply, &[0x0e][..]),
            (Type::InformationRequest, &[0x0f][..]),
            (Type::InformationReply, &[0x10][..]),
        ];
        for (t, bytes) in &cases {
            codec_roundtrip(*t, bytes, ());
        }
    }

    #[test]
    fn no_code() {
        codec_roundtrip(NoCode::Zero, &[0x00], ());
    }

    #[test]
    fn destination_unreachable() {
        let etalon_bytes = &[
            0x03, // Type
            0x01, // Code: HostUnreachable
            0x00, 0x00, // Checksum
            0x00, 0x00, 0x00, 0x00, // UNUSED
            0x45, 0x00, 0x00, 0x08, 0x00, 0x00, 0x40, 0x00, 0x40, 0x11, 0x00, 0x00, 0x7F, 0x00,
            0x00, 0x01, 0x7F, 0x00, 0x00, 0x01, // First 64 bits of original data
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        ];
        let etalon_struct = DestinationUnreachable {
            code: DestinationUnreachableCode::HostUnreachable,
            checksum: Checksum(0x0000),
            header: Header {
                ihl: Ihl(5),
                dscp: Dscp::new(0).unwrap(),
                ecn: Ecn::NonEct,
                total_length: 8,
                identification: 0,
                df: true,
                mf: false,
                fragment_offset: 0,
                ttl: 64,
                protocol: Protocol::UDP,
                checksum: ipv4::Checksum(0),
                source_address: Address::LOOPBACK,
                destination_address: Address::LOOPBACK,
                options: Options::default(),
            },
            bytes: [0x00; 8],
        };
        codec_roundtrip(etalon_struct, etalon_bytes, ());
    }

    #[test]
    fn source_quench() {
        let etalon_bytes = &[
            0x04, // Type
            0x00, // Code
            0x00, 0x00, // Checksum
            0x00, 0x00, 0x00, 0x00, // UNUSED
            0x45, 0x00, 0x00, 0x08, 0x00, 0x00, 0x40, 0x00, 0x40, 0x11, 0x00, 0x00, 0x7F, 0x00,
            0x00, 0x01, 0x7F, 0x00, 0x00, 0x01, // First 64 bits of original data
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        ];
        let etalon_struct = SourceQuench {
            code: SourceQuenchCode::Zero,
            checksum: Checksum(0x0000),
            header: Header {
                ihl: Ihl(5),
                dscp: Dscp::new(0).unwrap(),
                ecn: Ecn::NonEct,
                total_length: 8,
                identification: 0,
                df: true,
                mf: false,
                fragment_offset: 0,
                ttl: 64,
                protocol: Protocol::UDP,
                checksum: ipv4::Checksum(0),
                source_address: Address::LOOPBACK,
                destination_address: Address::LOOPBACK,
                options: Options::default(),
            },
            bytes: [0x00; 8],
        };
        codec_roundtrip(etalon_struct, etalon_bytes, ());
    }

    #[test]
    fn redirect() {
        let etalon_bytes = &[
            0x05, // Type
            0x00, // Code: Network
            0x00, 0x00, // Checksum
            0x0a, 0x00, 0x00, 0x01, // Gateway: 10.0.0.1
            0x45, 0x00, 0x00, 0x08, 0x00, 0x00, 0x40, 0x00, 0x40, 0x11, 0x00, 0x00, 0x7F, 0x00,
            0x00, 0x01, 0x7F, 0x00, 0x00, 0x01, // First 64 bits of original data
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        ];
        let etalon_struct = Redirect {
            code: RedirectCode::Network,
            checksum: Checksum(0x0000),
            gateway_internet_address: Address::from([10, 0, 0, 1]),
            header: Header {
                ihl: Ihl(5),
                dscp: Dscp::new(0).unwrap(),
                ecn: Ecn::NonEct,
                total_length: 8,
                identification: 0,
                df: true,
                mf: false,
                fragment_offset: 0,
                ttl: 64,
                protocol: Protocol::UDP,
                checksum: ipv4::Checksum(0),
                source_address: Address::LOOPBACK,
                destination_address: Address::LOOPBACK,
                options: Options::default(),
            },
            bytes: [0x00; 8],
        };
        codec_roundtrip(etalon_struct, etalon_bytes, ());
    }

    #[test]
    fn time_exceeded() {
        let etalon_bytes = &[
            0x0b, // Type
            0x00, // Code: TimeToLiveExceededInTransit
            0x00, 0x00, // Checksum
            0x00, 0x00, 0x00, 0x00, // UNUSED
            0x45, 0x00, 0x00, 0x08, 0x00, 0x00, 0x40, 0x00, 0x40, 0x11, 0x00, 0x00, 0x7F, 0x00,
            0x00, 0x01, 0x7F, 0x00, 0x00, 0x01, // First 64 bits of original data
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        ];
        let etalon_struct = TimeExceeded {
            code: TimeExceededCode::TimeToLiveExceededInTransit,
            checksum: Checksum(0x0000),
            header: Header {
                ihl: Ihl(5),
                dscp: Dscp::new(0).unwrap(),
                ecn: Ecn::NonEct,
                total_length: 8,
                identification: 0,
                df: true,
                mf: false,
                fragment_offset: 0,
                ttl: 64,
                protocol: Protocol::UDP,
                checksum: ipv4::Checksum(0),
                source_address: Address::LOOPBACK,
                destination_address: Address::LOOPBACK,
                options: Options::default(),
            },
            bytes: [0x00; 8],
        };
        codec_roundtrip(etalon_struct, etalon_bytes, ());
    }

    #[test]
    fn parameter_problem() {
        let etalon_bytes = &[
            0x0c, // Type
            0x00, // Code
            0x00, 0x00, // Checksum
            0x05, // Pointer
            0x00, 0x00, 0x00, // UNUSED
            // Header (20 bytes)
            0x45, 0x00, 0x00, 0x08, 0x00, 0x00, 0x40, 0x00, 0x40, 0x11, 0x00, 0x00, 0x7F, 0x00,
            0x00, 0x01, 0x7F, 0x00, 0x00, 0x01, // First 64 bits of original data
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        ];
        let etalon_struct = ParameterProblem {
            code: ParameterProblemCode::Zero,
            checksum: Checksum(0x0000),
            pointer: 5,
            unused: ParameterProblem::UNUSED,
            header: Header {
                ihl: Ihl(5),
                dscp: Dscp::new(0).unwrap(),
                ecn: Ecn::NonEct,
                total_length: 8,
                identification: 0,
                df: true,
                mf: false,
                fragment_offset: 0,
                ttl: 64,
                protocol: Protocol::UDP,
                checksum: ipv4::Checksum(0),
                source_address: Address::LOOPBACK,
                destination_address: Address::LOOPBACK,
                options: Options::default(),
            },
            bytes: [0x00; 8],
        };
        codec_roundtrip(etalon_struct, etalon_bytes, ());
    }

    #[test]
    fn echo() {
        let etalon_bytes = &[
            0x08, // Type: Echo
            0x00, // Code: 0
            0x00, 0x00, // Checksum: 0 (for testing)
            0x00, 0x01, // Identifier: 1
            0x00, 0x02, // Sequence Number: 2
            0x41, 0x42, 0x43, // Data: "ABC"
        ];
        let etalon_struct = Echo {
            code: EchoCode::Zero,
            checksum: Checksum(0x0000),
            identifier: 1,
            sequence_number: 2,
            data: vec![0x41, 0x42, 0x43],
        };
        codec_roundtrip(etalon_struct, etalon_bytes, ());
    }

    #[test]
    fn echo_reply() {
        let etalon_bytes = &[
            0x00, // Type: Echo Reply
            0x00, // Code: 0
            0x00, 0x00, // Checksum: 0 (for testing)
            0x00, 0x01, // Identifier: 1
            0x00, 0x02, // Sequence Number: 2
            0x41, 0x42, 0x43, // Data: "ABC"
        ];
        let etalon_struct = EchoReply {
            code: EchoReplyCode::Zero,
            checksum: Checksum(0x0000),
            identifier: 1,
            sequence_number: 2,
            data: vec![0x41, 0x42, 0x43],
        };
        codec_roundtrip(etalon_struct, etalon_bytes, ());
    }

    #[test]
    fn timestamp() {
        let etalon_bytes = &[
            0x0d, // Type: Timestamp
            0x00, // Code: 0
            0x00, 0x00, // Checksum: 0 (for testing)
            0x00, 0x01, // Identifier: 1
            0x00, 0x02, // Sequence Number: 2
            0x00, 0x00, 0x00, 0x03, // Originate Timestamp: 3
            0x00, 0x00, 0x00, 0x04, // Receive Timestamp: 4
            0x00, 0x00, 0x00, 0x05, // Transmit Timestamp: 5
        ];
        let etalon_struct = Timestamp {
            code: TimestampCode::Zero,
            checksum: Checksum(0x0000),
            identifier: 1,
            sequence_number: 2,
            originate_timestamp: 3,
            receive_timestamp: 4,
            transmit_timestamp: 5,
        };
        codec_roundtrip(etalon_struct, etalon_bytes, ());
    }

    #[test]
    fn timestamp_reply() {
        let etalon_bytes = &[
            0x0e, // Type: Timestamp Reply
            0x00, // Code: 0
            0x00, 0x00, // Checksum: 0 (for testing)
            0x00, 0x01, // Identifier: 1
            0x00, 0x02, // Sequence Number: 2
            0x00, 0x00, 0x00, 0x03, // Originate Timestamp: 3
            0x00, 0x00, 0x00, 0x04, // Receive Timestamp: 4
            0x00, 0x00, 0x00, 0x05, // Transmit Timestamp: 5
        ];
        let etalon_struct = TimestampReply {
            code: TimestampReplyCode::Zero,
            checksum: Checksum(0x0000),
            identifier: 1,
            sequence_number: 2,
            originate_timestamp: 3,
            receive_timestamp: 4,
            transmit_timestamp: 5,
        };
        codec_roundtrip(etalon_struct, etalon_bytes, ());
    }

    #[test]
    fn information_request() {
        let etalon_bytes = &[
            0x0f, // Type: Information Request
            0x00, // Code: 0
            0x00, 0x00, // Checksum: 0 (for testing)
            0x00, 0x01, // Identifier: 1
            0x00, 0x02, // Sequence Number: 2
        ];
        let etalon_struct = InformationRequest {
            code: InformationRequestCode::Zero,
            checksum: Checksum(0x0000),
            identifier: 1,
            sequence_number: 2,
        };
        codec_roundtrip(etalon_struct, etalon_bytes, ());
    }

    #[test]
    fn information_reply() {
        let etalon_bytes = &[
            0x10, // Type: Information Reply
            0x00, // Code: 0
            0x00, 0x00, // Checksum: 0 (for testing)
            0x00, 0x01, // Identifier: 1
            0x00, 0x02, // Sequence Number: 2
        ];
        let etalon_struct = InformationReply {
            code: InformationReplyCode::Zero,
            checksum: Checksum(0x0000),
            identifier: 1,
            sequence_number: 2,
        };
        codec_roundtrip(etalon_struct, etalon_bytes, ());
    }
}