internet 0.0.5

//! Encoding for ICMPv4 by [RFC 792].
//!
//! Module provides encoding for following [Message]s:
//! - [EchoReply]
//! - [DestinationUnreachable]
//! - [SourceQuench]
//! - [Redirect]
//! - [Echo]
//! - [TimeExceeded]
//! - [ParameterProblem]
//! - [Timestamp]
//! - [TimestampReply]
//! - [InformationRequest]
//! - [InformationReply]
//!
//! And following types:
//!  - [Type]
//!  - [Code]
//!  - [Checksum]
//!
//! [RFC 792]: https://datatracker.ietf.org/doc/html/rfc792

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

/// A messages of the ICMPv4.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Message<'a> {
    /// The Echo Reply message.
    EchoReply(EchoReply<'a>),
    /// The Destination Unreachable message.
    DestinationUnreachable(DestinationUnreachable),
    /// The Source Quench message.
    SourceQuench(SourceQuench),
    /// The Redirect message.
    Redirect(Redirect),
    /// The Echo message.
    Echo(Echo<'a>),
    /// The Time Exceed message.
    TimeExceeded(TimeExceeded),
    /// The Parameter Problem message.
    ParameterProblem(ParameterProblem),
    /// The Timestamp message.
    Timestamp(Timestamp),
    /// The Timestamp Reply message.
    TimestampReply(TimestampReply),
    /// The Information Request messge.
    InformationRequest(InformationRequest),
    /// The Information Reply message.
    InformationReply(InformationReply),
}

impl<'a> Codec for Message<'a> {
    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 typ = Type::decode(&mut Cursor::new(&[(reader.peek_u8()?)]), ())?;
        Ok(match typ {
            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, ())?),
        })
    }
}

/// A `Type` field values.
///
/// [RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum Type {
    ///
    EchoReply = 0,
    ///
    DestinationUnreachable = 3,
    ///
    SourceQuench = 4,
    ///
    Redirect = 5,
    ///
    Echo = 8,
    ///
    TimeExceeded = 11,
    ///
    ParameterProblem = 12,
    ///
    Timestamp = 13,
    ///
    TimestampReply = 14,
    ///
    InformationRequest = 15,
    ///
    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 `Code` fields of the ICMPv4 messages.
///
/// [RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Code {
    /// The Echo Reply message code.
    EchoReply(EchoReplyCode),
    /// The Destination Unreachable message code.
    DestinationUnreachable(DestinationUnreachableCode),
    /// The Source Quench message code.
    SourceQuench(SourceQuenchCode),
    /// The Redirect message code.
    Redirect(RedirectCode),
    /// The Echo message code.
    Echo(EchoCode),
    /// The Time Exceed message code.
    TimeExceeded(TimeExceededCode),
    /// The Parameter Problem message code.
    ParameterProblem(ParameterProblemCode),
    /// The Timestamp message code.
    Timestamp(TimestampCode),
    /// The Timestamp Reply message code.
    TimestampReply(TimestampReplyCode),
    /// The Information Request message code.
    InformationRequest(InformationRequestCode),
    /// The Information Reply message Code.
    InformationReply(InformationReplyCode),
}

/// The [`DestinationUnreachable`] message code.
///
/// Destination Unreachable Message's constants defined in [IETF RFC 792]
///
/// [IETF RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
///
/// # Examples
/// ```
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum ZeroCode {
    /// Zero
    Zero = 0,
}

impl Codec for ZeroCode {
    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),
        }
    }
}

/// A `Checksum` field of the each [Message] by [RFC 792].
///
/// [RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
///
/// # Examples
/// ```
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Checksum(pub u16);

impl Checksum {
    ///
    pub fn calculate() -> Self {
        todo!()
    }
}

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 by [RFC 792].
///
/// [RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
///
/// # Examples
/// ```
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct DestinationUnreachable {
    /// The ICMPv4 message `Code`.
    pub code: DestinationUnreachableCode,
    /// The ICMPv4 message `Checksum`.
    pub checksum: Checksum,
    /// The Internet Header.
    pub header: Header,
    /// The 64 bits of Data Datagram.
    pub bytes: [u8; 8],
}

impl DestinationUnreachable {
    /// Type field = 3.
    pub const TYPE: Type = Type::DestinationUnreachable;
    /// unused field, reserved for future and filled with zeros.
    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, ())?;
        Ok(())
    }

    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 Destination Unreachable Message's code.
///
/// Destination Unreachable Message's constants defined in [IETF RFC 792]
///
/// [IETF RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
///
/// # Examples
/// ```
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum DestinationUnreachableCode {
    /// 0 = net unreachable.
    NetUreachable = 0,
    /// 1 = host unreachable.
    HostUnreachable = 1,
    /// 2 = protocol unreachable.
    ProtocolUnreachable = 2,
    /// 3 = port unreachable.
    PortUnreachable = 3,
    /// 4 = fragmentation needed and DF set.
    FragmentationNeededAndDfSet = 4,
    /// 5 = 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, ())? {
            x if x == (Self::NetUreachable as u8) => Ok(Self::NetUreachable),
            x if x == (Self::HostUnreachable as u8) => Ok(Self::HostUnreachable),
            x if x == (Self::ProtocolUnreachable as u8) => Ok(Self::ProtocolUnreachable),
            x if x == (Self::PortUnreachable as u8) => Ok(Self::PortUnreachable),
            x if x == (Self::FragmentationNeededAndDfSet as u8) => {
                Ok(Self::FragmentationNeededAndDfSet)
            }
            x if x == (Self::SourceRouteFailed as u8) => Ok(Self::SourceRouteFailed),
            _ => Err(BufError::UnexpectedValue),
        }
    }
}

/// A Time Exceeded message.
///
/// Defined in [IETF RFC 792]
///
/// [IETF RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
///
/// # Examples
/// ```
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct TimeExceeded {
    /// Code field.
    pub code: TimeExceededCode,
    /// Checksum field.
    pub checksum: Checksum,
    /// Internet Header
    pub header: Header,
    /// 64 bits of Data Datagram
    pub bytes: [u8; 8],
}

impl TimeExceeded {
    /// Type field = 11.
    pub const TYPE: Type = Type::TimeExceeded;
    /// unused field, reserved for future and filled with zeros.
    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 Time Exceeded message code.
///
/// Defined in [IETF RFC 792]
///
/// [IETF RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
///
/// # Examples
/// ```
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum TimeExceededCode {
    /// 0 = time to live exceed in transit;
    TimeToLiveExceedInTransit = 0,
    /// 1 = 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, ())? {
            x if x == (Self::TimeToLiveExceedInTransit as u8) => {
                Ok(Self::TimeToLiveExceedInTransit)
            }
            x if x == (Self::FragmentReassemblyTimeExceeded as u8) => {
                Ok(Self::FragmentReassemblyTimeExceeded)
            }
            _ => Err(BufError::UnexpectedValue),
        }
    }
}

/// A Parameter Problem message.
///
/// Defined in [IETF RFC 792].
///
/// [IETF RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
///
/// # Examples
/// ```
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct ParameterProblem {
    /// Code field.
    pub code: ParameterProblemCode,
    /// Checksum field.
    pub checksum: Checksum,
    /// Internet Header
    pub header: Header,
    /// 64 bits of Data Datagram
    pub bytes: [u8; 8],
}

impl ParameterProblem {
    /// Type field = 11.
    pub const TYPE: Type = Type::ParameterProblem;
    /// unused field, reserved for future and filled with zeros.
    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::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, ())?;
        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,
            header,
            bytes,
        })
    }
}

///
pub type ParameterProblemCode = ZeroCode;

/// A Source Quench message.
///
/// Defined in [IETF RFC 792]
///
/// [IETF RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
///
/// # Examples
/// ```
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct SourceQuench {
    /// Code field.
    pub code: SourceQuenchCode,
    /// Checksum field.
    pub checksum: Checksum,
    /// Internet Header
    pub header: Header,
    /// 64 bits of Data Datagram
    pub bytes: [u8; 8],
}

impl SourceQuench {
    /// Type field = 11.
    pub const TYPE: Type = Type::SourceQuench;
    /// unused field, reserved for future and filled with zeros.
    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,
        })
    }
}

///
pub type SourceQuenchCode = ZeroCode;

/// A Redirect message.
///
/// Defined in [IETF RFC 792]
///
/// [IETF RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
///
/// # Examples
/// ```
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Redirect {
    /// Code field.
    pub code: RedirectCode,
    /// Checksum field.
    pub checksum: Checksum,
    /// Gateway Internet Address.
    pub gateway_internet_address: Address,
    /// Internet Header
    pub header: Header,
    /// 64 bits of Data Datagram
    pub bytes: [u8; 8],
}

impl Redirect {
    /// Type field = 5.
    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 Redirect message code.
///
/// Defined in [IETF RFC 792].
///
/// [IETF RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
///
/// # Examples
/// ```
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum RedirectCode {
    /// 0 = Redirect datagrams for the Network.
    Network = 0,
    /// 1 = Redirect datagrams for the Host.
    Host = 1,
    /// 2 = Redirect datagrams for the Type of Service and Network.
    TypeOfServiceAndNetwork = 2,
    /// 3 = 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, ())? {
            x if x == (Self::Network as u8) => Ok(Self::Network),
            x if x == (Self::Host as u8) => Ok(Self::Host),
            x if x == (Self::TypeOfServiceAndNetwork as u8) => Ok(Self::TypeOfServiceAndNetwork),
            x if x == (Self::TypeOfServiceAndHost as u8) => Ok(Self::TypeOfServiceAndHost),
            _ => Err(BufError::UnexpectedValue),
        }
    }
}

/// An Echo message.
///
/// Defined in [IETF RFC 792]
///
/// [IETF RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
///
/// # Examples
/// ```
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Echo<'a> {
    /// Code field.
    pub code: EchoCode,
    /// Checksum field.
    pub checksum: Checksum,
    /// Identifier field.
    pub identifier: u16,
    /// Sequence Number field.
    pub sequence_number: u16,
    /// Data field.
    pub data: &'a [u8],
}

impl<'a> Echo<'a> {
    /// Type field = 15.
    pub const TYPE: Type = Type::Echo;
}

impl<'a> Codec for Echo<'a> {
    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::Redirect => (),
            _ => 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 = &[0u8];
        Ok(Self {
            code,
            checksum,
            identifier,
            sequence_number,
            data,
        })
    }
}

///
pub type EchoCode = ZeroCode;

/// An Echo Reply message.
///
/// Defined in [IETF RFC 792]
///
/// [IETF RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
///
/// # Examples
/// ```
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct EchoReply<'a> {
    /// Code field.
    pub code: EchoCode,
    /// Checksum field.
    pub checksum: Checksum,
    /// Identifier field.
    pub identifier: u16,
    /// Sequence Number field.
    pub sequence_number: u16,
    /// Data field.
    pub data: &'a [u8],
}

impl<'a> EchoReply<'a> {
    /// Type field = 15.
    pub const TYPE: Type = Type::EchoReply;
}

impl<'a> Codec for EchoReply<'a> {
    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::Redirect => (),
            _ => 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 = &[0u8];
        Ok(Self {
            code,
            checksum,
            identifier,
            sequence_number,
            data,
        })
    }
}

///
pub type EchoReplyCode = ZeroCode;

/// A Timestamp message.
///
/// Defined in [IETF RFC 792].
///
/// [IETF RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
///
/// # Examples
/// ```
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Timestamp {
    /// Code field.
    pub code: TimestampCode,
    /// Checksum field.
    pub checksum: Checksum,
    /// Identifier field.
    pub identifier: u16,
    /// Sequence Number field.
    pub sequence_number: u16,
    /// Originate Timestamp.
    pub originate_timestamp: u32,
    /// Receive Timestamp.
    pub receive_timestamp: u32,
    /// Transmit Timestamp.
    pub transmit_timestamp: u32,
}

impl Timestamp {
    /// Type field = 15.
    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, ())? {
            Self::TYPE => (),
            _ => 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 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,
        })
    }
}

///
pub type TimestampCode = ZeroCode;

/// A Timestamp Reply message.
///
/// Defined in [IETF RFC 792]
///
/// [IETF RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
///
/// # Examples
/// ```
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct TimestampReply {
    /// Code field.
    pub code: TimestampCode,
    /// Checksum field.
    pub checksum: Checksum,
    /// Identifier field.
    pub identifier: u16,
    /// Sequence Number field.
    pub sequence_number: u16,
    /// Originate Timestamp.
    pub originate_timestamp: u32,
    /// Receive Timestamp.
    pub receive_timestamp: u32,
    /// Transmit Timestamp.
    pub transmit_timestamp: u32,
}

impl TimestampReply {
    /// Type field = 15.
    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, ())? {
            Self::TYPE => (),
            _ => 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 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,
        })
    }
}

///
pub type TimestampReplyCode = ZeroCode;

/// A Information Request message.
///
/// Defined in [IETF RFC 792].
///
/// [IETF RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
///
/// # Examples
/// ```
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct InformationRequest {
    /// Code field.
    pub code: InformationRequestCode,
    /// Checksum field.
    pub checksum: Checksum,
    /// Identifier field.
    pub identifier: u16,
    /// Sequence Number field.
    pub sequence_number: u16,
}

impl InformationRequest {
    /// Type field = 15.
    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, ())? {
            Self::TYPE => (),
            _ => 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, ())?;
        Ok(Self {
            code,
            checksum,
            identifier,
            sequence_number,
        })
    }
}

///
pub type InformationRequestCode = ZeroCode;

/// An Information Reply message.
///
/// Defined in [IETF RFC 792].
///
/// [IETF RFC 792]: https://datatracker.ietf.org/doc/html/rfc792
///
/// # Examples
/// ```
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct InformationReply {
    /// Code field.
    pub code: InformationRequestCode,
    /// Checksum field.
    pub checksum: Checksum,
    /// Identifier field.
    pub identifier: u16,
    /// Sequence Number field.
    pub sequence_number: u16,
}

impl InformationReply {
    /// Type field = 16.
    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, ())? {
            Self::TYPE => (),
            _ => 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, ())?;
        Ok(Self {
            code,
            checksum,
            identifier,
            sequence_number,
        })
    }
}

///
pub type InformationReplyCode = ZeroCode;

#[cfg(test)]
mod tests {}