internet 0.1.0

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

/// An ICMPv6 message representation.
///
/// Encapsulates all supported ICMPv6 messages as defined in [IETF RFC 4443].
///
/// [IETF RFC 4443]: https://datatracker.ietf.org/doc/html/rfc4443
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Message<'a> {
  /// Destination Unreachable message.
  DestinationUnreachable(DestinationUnreachable<'a>),
  /// Packet Too Big message.
  PacketTooBig(PacketTooBig<'a>),
  /// Time Exceed message.
  TimeExceeded(TimeExceeded<'a>),
  /// Parameter Problem message.
  ParameterProblem(ParameterProblem<'a>),
  /// Echo message.
  EchoRequest(EchoRequest<'a>),
  /// Echo Reply message.
  EchoReply(EchoReply<'a>),
}

impl<'a> Codec for Message<'a> {
  fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
    match self {
      Message::DestinationUnreachable(message) => message.encode(writer, ()),
      Message::PacketTooBig(message) => message.encode(writer, ()),
      Message::TimeExceeded(message) => message.encode(writer, ()),
      Message::ParameterProblem(message) => message.encode(writer, ()),
      Message::EchoRequest(message) => message.encode(writer, ()),
      Message::EchoReply(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::DestinationUnreachable => {
        Self::DestinationUnreachable(DestinationUnreachable::decode(reader, ())?)
      }
      Type::PacketTooBig => Self::PacketTooBig(PacketTooBig::decode(reader, ())?),
      Type::TimeExceeded => Self::TimeExceeded(TimeExceeded::decode(reader, ())?),
      Type::ParameterProblem => Self::ParameterProblem(ParameterProblem::decode(reader, ())?),
      Type::EchoRequest => Self::EchoRequest(EchoRequest::decode(reader, ())?),
      Type::EchoReply => Self::EchoReply(EchoReply::decode(reader, ())?),
    })
  }
}

/// A type of the ICMPv6 header following [RFC 4443, Section 2.1].
///
/// [RFC 4443, Section 2.1]: https://datatracker.ietf.org/doc/html/rfc4443#section-2.1
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum Type {
  /// Destination Unreachable.
  DestinationUnreachable = 1,
  /// Packet Too Big.
  PacketTooBig = 2,
  /// Time Exceeded.
  TimeExceeded = 3,
  /// Parameter Problem.
  ParameterProblem = 4,
  /// Echo Request.
  EchoRequest = 128,
  /// Echo Reply.
  EchoReply = 129,
}

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::DestinationUnreachable as u8) => Ok(Self::DestinationUnreachable),
      x if x == (Self::PacketTooBig as u8) => Ok(Self::PacketTooBig),
      x if x == (Self::TimeExceeded as u8) => Ok(Self::TimeExceeded),
      x if x == (Self::ParameterProblem as u8) => Ok(Self::ParameterProblem),
      x if x == (Self::EchoRequest as u8) => Ok(Self::EchoRequest),
      x if x == (Self::EchoReply as u8) => Ok(Self::EchoReply),
      _ => Err(BufError::UnexpectedValue),
    }
  }
}

/// A code of the ICMPv6 header following [RFC 4443, Section 2.3].
///
/// [RFC 4443, Section 2.3]: https://datatracker.ietf.org/doc/html/rfc4443#section-2.3
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Code(pub u8);

impl Codec for Code {
  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(u8::decode(reader, ())?))
  }
}

/// `Checksum` of ICMPv6 message.
///
/// 16-bit mandatory field used by all ICMPv6 messages for data validation.
///
/// Calculation defined in [IETF RFC 4443, Section 2.3].
///
/// [IETF RFC 4443, Section 2.3]: https://datatracker.ietf.org/doc/html/rfc4443#section-2.3
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Checksum(pub u16);

impl Checksum {
  /// Вычисляет и возвращает заголовок с актуальной контрольной суммой.
  ///
  /// Входной пакет `input` содержит полный IPv6/ICMPv6 контекст.
  pub fn calculate() -> Self {
    // let mut checksum_acc: u32 = 0;

    // // -------------------------------------------------------------
    // // 1. Учитываем IPv6 Pseudo-Header (RFC 2460 / RFC 4443)
    // // -------------------------------------------------------------

    // let ipv6_header = Ipv6 {
    //     traffic_class: todo!(),
    //     flow_label: todo!(),
    //     payload_length: todo!(),
    //     next_header: todo!(),
    //     hop_limit: todo!(),
    //     source_address: todo!(),
    //     destination_address: todo!(),
    // };

    // let icmpv6_header = {};

    // // Source IPv6 Address (16 байт = 8 слов по 16 бит)
    // for chunk in ipv6_header.source_address.octets().chunks_exact(2) {
    //     checksum_acc += u16::from_be_bytes([chunk[0], chunk[1]]) as u32;
    // }

    // // Destination IPv6 Address (16 байт = 8 слов по 16 бит)
    // for chunk in input.dst_ip().octets().chunks_exact(2) {
    //     checksum_acc += u16::from_be_bytes([chunk[0], chunk[1]]) as u32;
    // }

    // // Upper-Layer Packet Length (ICMPv6 header + payload length)
    // let icmp_len = input.icmp_payload_len() + Icmpv6Header::BYTES_LEN;
    // checksum_acc += (icmp_len >> 16) as u32;
    // checksum_acc += (icmp_len & 0xFFFF) as u32;

    // // Next Header Protocol ID for ICMPv6 (58)
    // checksum_acc += Protocol::IPV6_ICMP.0 as u32;

    // // -------------------------------------------------------------
    // // 2. Учитываем сам ICMPv6 Заголовок (с обнуленным полем checksum)
    // // -------------------------------------------------------------

    // let header_bytes = input.header_bytes_with_zero_checksum();
    // for chunk in header_bytes.chunks_exact(2) {
    //     checksum_acc += u16::from_be_bytes([chunk[0], chunk[1]]) as u32;
    // }

    // // -------------------------------------------------------------
    // // 3. Учитываем ICMPv6 Payload (данные пакета)
    // // -------------------------------------------------------------

    // let payload = input.payload_bytes();
    // let mut chunks = payload.chunks_exact(2);

    // for chunk in &mut chunks {
    //     checksum_acc += u16::from_be_bytes([chunk[0], chunk[1]]) as u32;
    // }

    // // Если длина payload нечетная — дописываем последний байт как старший (big-endian)
    // let remainder = chunks.remainder();
    // if !remainder.is_empty() {
    //     checksum_acc += ((remainder[0] as u32) << 8);
    // }

    // // -------------------------------------------------------------
    // // 4. Сворачиваем 32-битный аккумулированный результат в 16 бит
    // // -------------------------------------------------------------

    // while (checksum_acc >> 16) > 0 {
    //     checksum_acc = (checksum_acc & 0xFFFF) + (checksum_acc >> 16);
    // }

    // // Побитовое инвертирование (Ones' complement)
    // let final_checksum = !(checksum_acc as u16);

    // // Возвращаем копию заголовка с проставленной контрольной суммой
    // let mut header = input.header().clone();
    // header.set_checksum(final_checksum);
    // header
    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 Zero Code.
///
/// [IETF RFC 4443]
///
/// [IETF RFC 4443]: https://datatracker.ietf.org/doc/html/rfc4443
#[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 Destination Unreachable message following [RFC 4443, Section 3.1].
///
/// [RFC 4443, Section 3.1]: https://datatracker.ietf.org/doc/html/rfc4443#section-3.1
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct DestinationUnreachable<'a> {
  /// Code field.
  pub code: DestinationUnreachableCode,
  /// Checksum field.
  pub checksum: Checksum,
  /// As much of invoking packet as possible without the ICMPv6 packet exceeding the minimum IPv6 MTU [IPv6]
  pub data: &'a [u8],
}

impl<'a> DestinationUnreachable<'a> {
  /// Type field = 1.
  pub const TYPE: Type = Type::DestinationUnreachable;
  /// unused field, reserved for future and filled with zeros.
  pub const UNUSED: [u8; 4] = [0u8; 4];
}

impl<'a> Codec for DestinationUnreachable<'a> {
  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.data.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, ())?;
    let data = &[0u8];
    Ok(Self {
      code,
      checksum,
      data,
    })
  }
}

/// A Destination Unreachable message code.
///
/// Defined in [IETF RFC 4443, Section 3.1].
///
/// [IETF RFC 4443, Section 3.1]: https://datatracker.ietf.org/doc/html/rfc4443#section-3.1
///
/// # Examples
/// ```
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum DestinationUnreachableCode {
  /// 0 - No route to destination
  NoRouteToDestination = 0,
  /// 1 - Communication with destination administratively prohibited.
  CommunicationWithDestinationAdministrativelyProhibited = 1,
  /// 2 - Beyond scope of source address.
  BeyondScopeOfSourceAddress = 2,
  /// 3 - address unreachable.
  AddressUnreachable = 3,
  /// 4 - Port unreachable.
  PortUnreachable = 4,
  /// 5 - Source address failed ingress/egress policy.
  SourceAddressFailedIngressEgressPolicy = 5,
  /// 6 - Reject route to destination.
  RejectRouteToDestination = 6,
}

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::NoRouteToDestination as u8) => Ok(Self::NoRouteToDestination),
      x if x == (Self::CommunicationWithDestinationAdministrativelyProhibited as u8) => {
        Ok(Self::CommunicationWithDestinationAdministrativelyProhibited)
      }
      x if x == (Self::BeyondScopeOfSourceAddress as u8) => Ok(Self::BeyondScopeOfSourceAddress),
      x if x == (Self::AddressUnreachable as u8) => Ok(Self::AddressUnreachable),
      x if x == (Self::PortUnreachable as u8) => Ok(Self::PortUnreachable),
      x if x == (Self::SourceAddressFailedIngressEgressPolicy as u8) => {
        Ok(Self::SourceAddressFailedIngressEgressPolicy)
      }
      x if x == (Self::RejectRouteToDestination as u8) => Ok(Self::RejectRouteToDestination),
      _ => Err(BufError::UnexpectedValue),
    }
  }
}

/// A Packet Too Big message.
///
/// Defined in [IETF RFC 4443, Section 3.2].
///
/// [IETF RFC 4443, Section 3.2]: https://datatracker.ietf.org/doc/html/rfc4443#section-3.2
///
/// # Examples
/// ```
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct PacketTooBig<'a> {
  /// Code field.
  pub code: PacketTooBigCode,
  /// Checksum field.
  pub checksum: Checksum,
  /// MTU field.
  pub mtu: u32,
  /// As much of invoking packet as possible without the ICMPv6 packet exceeding the minimum IPv6 MTU [IPv6]
  pub data: &'a [u8],
}

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

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

  fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
    if Type::decode(reader, ())? != Self::TYPE {
      return Err(BufError::UnexpectedValue);
    }
    let code = PacketTooBigCode::decode(reader, ())?;
    let checksum = Checksum::decode(reader, ())?;
    let mtu = u32::decode(reader, ())?;
    let data = &[0u8];
    Ok(Self {
      code,
      checksum,
      mtu,
      data,
    })
  }
}

/// A Packet Too Big message code.
///
/// Defined in [IETF RFC 4443, Section 3.2].
///
/// [IETF RFC 4443, Section 3.2]: https://datatracker.ietf.org/doc/html/rfc4443#section-3.2
pub type PacketTooBigCode = ZeroCode;

/// A Time Exceeded message.
///
/// Defined in [IETF RFC 4443].
///
/// [IETF RFC 4443]: https://datatracker.ietf.org/doc/html/rfc4443
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct TimeExceeded<'a> {
  /// Code field.
  pub code: TimeExceededCode,
  /// Checksum field.
  pub checksum: Checksum,
  /// As much of invoking packet as possible without the ICMPv6 packet exceeding the minimum IPv6 MTU [IPv6]
  pub data: &'a [u8],
}

impl<'a> TimeExceeded<'a> {
  /// Type field = 3.
  pub const TYPE: Type = Type::TimeExceeded;
  /// unused field, reserved for future and filled with zeros.
  pub const UNUSED: [u8; 4] = [0u8; 4];
}

impl<'a> Codec for TimeExceeded<'a> {
  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.data.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, ())?;
    let data = &[0u8];
    Ok(Self {
      code,
      checksum,
      data,
    })
  }
}

/// A Time Exceeded message code.
///
/// Defined in [IETF RFC 4443]
///
/// [IETF RFC 4443]: https://datatracker.ietf.org/doc/html/rfc4443
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum TimeExceededCode {
  /// 0 = hop limit exceeded in transit.
  HopLimitExceededInTransit = 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::HopLimitExceededInTransit as u8) => Ok(Self::HopLimitExceededInTransit),
      x if x == (Self::FragmentReassemblyTimeExceeded as u8) => {
        Ok(Self::FragmentReassemblyTimeExceeded)
      }
      _ => Err(BufError::UnexpectedValue),
    }
  }
}

/// A Parameter Problem message.
///
/// Defined in [IETF RFC 4443].
///
/// [IETF RFC 4443]: https://datatracker.ietf.org/doc/html/rfc4443
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct ParameterProblem<'a> {
  /// Code field.
  pub code: ParameterProblemCode,
  /// Checksum field.
  pub checksum: Checksum,
  /// Pointer field.
  pub pointer: u32,
  /// As much of invoking packet as possible without the ICMPv6 packet exceeding the minimum IPv6 MTU [IPv6]
  pub data: &'a [u8],
}

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

impl<'a> Codec for ParameterProblem<'a> {
  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.data.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 = u32::decode(reader, ())?;
    let data = &[0u8];
    Ok(Self {
      code,
      checksum,
      pointer,
      data,
    })
  }
}

/// A Parameter Problem message code.
///
/// Defined in [IETF RFC 4443, Section 3.4].
///
/// [IETF RFC 4443, Section 3.4]: https://datatracker.ietf.org/doc/html/rfc4443#section-3.4
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum ParameterProblemCode {
  /// 0 - Erroneous header field encountered
  ErroneousHeaderFieldEncountered = 0,
  /// 1 - Unrecognized Next Header type encountered
  UnrecognizedNextHeaderTypeEncountered = 1,
  /// 2 - Unrecognized IPv6 option encountered
  UnrecognizedIpv6OptionEncountered = 2,
}

impl Codec for ParameterProblemCode {
  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::ErroneousHeaderFieldEncountered as u8) => {
        Ok(Self::ErroneousHeaderFieldEncountered)
      }
      x if x == (Self::UnrecognizedNextHeaderTypeEncountered as u8) => {
        Ok(Self::UnrecognizedNextHeaderTypeEncountered)
      }
      x if x == (Self::UnrecognizedIpv6OptionEncountered as u8) => {
        Ok(Self::UnrecognizedIpv6OptionEncountered)
      }
      _ => Err(BufError::UnexpectedValue),
    }
  }
}

/// An Echo Request message.
///
/// Defined in [IETF RFC 4443, Section 4.1].
///
/// [IETF RFC 4443, Section 4.1]: https://datatracker.ietf.org/doc/html/rfc4443#section-4.1
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct EchoRequest<'a> {
  /// Code field.
  pub code: EchoRequestCode,
  /// 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> EchoRequest<'a> {
  /// Type field = 128.
  pub const TYPE: Type = Type::EchoRequest;
}

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

/// A Echo Request message code.
///
/// Defined in [IETF RFC 4443, Section 4.1].
///
/// [IETF RFC 4443, Section 4.1]: https://datatracker.ietf.org/doc/html/rfc4443#section-4.1
pub type EchoRequestCode = ZeroCode;

/// An Echo Reply message.
///
/// Defined in [IETF RFC 4443, Section 4.2].
///
/// [IETF RFC 4443, Section 4.2]: https://datatracker.ietf.org/doc/html/rfc4443#section-4.2
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct EchoReply<'a> {
  /// Code field.
  pub code: EchoRequestCode,
  /// 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 = 129.
  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, ())? {
      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 data = &[0u8];
    Ok(Self {
      code,
      checksum,
      identifier,
      sequence_number,
      data,
    })
  }
}

/// A Echo Reply message code.
///
/// Defined in [IETF RFC 4443, Section 4.2].
///
/// [IETF RFC 4443, Section 4.2]: https://datatracker.ietf.org/doc/html/rfc4443#section-4.2
pub type EchoReplyCode = ZeroCode;