internet 0.0.5

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

/// A IPv6 header.
///
/// Defined in [IETF RFC 8200]
///
/// [IETF RFC 8200]: https://datatracker.ietf.org/doc/html/rfc8200
///
/// # Examples
/// ```
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Ipv6 {
    /// Traffic Class field.
    pub traffic_class: TrafficClass,
    /// Flow Label field.
    pub flow_label: FlowLabel,
    /// Payload Length field.
    pub payload_length: PayloadLength,
    /// Next Header field.
    pub next_header: Protocol,
    /// Hop Limit field.
    pub hop_limit: HopLimit,
    /// Source Address field.
    pub source_address: Address,
    /// Destination Address field.
    pub destination_address: Address,
}

impl Ipv6 {
    /// Version field.
    pub const VERSION: Version = Version::Ipv6;
}

impl Codec for Ipv6 {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        // Упаковываем: Version (4 бита, всегда 6) | Traffic Class (8 бит) | Flow Label (20 бит)
        // let v_tc_fl: u32 =
        // (6u32 << 28) | ((self.traffic_class as u32) << 20) | (self.flow_label & 0x000F_FFFF);

        // writer.write_u32_be(v_tc_fl)?;
        self.payload_length.encode(writer, ())?;
        self.next_header.encode(writer, ())?;
        self.hop_limit.encode(writer, ())?;
        self.source_address.encode(writer, ())?;
        self.destination_address.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        let v_tc_fl = u32::decode(reader, ())?;

        let version = v_tc_fl >> 28;
        if version != 6 {
            return Err(BufError::UnexpectedValue);
        }

        let traffic_class = TrafficClass::decode(reader, ())?;
        let flow_label = FlowLabel(v_tc_fl & 0x000F_FFFF);
        let payload_length = PayloadLength::decode(reader, ())?;
        let next_header = Protocol::decode(reader, ())?;
        let hop_limit = HopLimit::decode(reader, ())?;
        let source_address = Address::decode(reader, ())?;
        let destination_address = Address::decode(reader, ())?;

        Ok(Self {
            traffic_class,
            flow_label,
            payload_length,
            next_header,
            hop_limit,
            source_address,
            destination_address,
        })
    }
}

/// `Traffic Class` IPv6 header field.
///
/// Defined in [IETF RFC 8200, Section 3].
///
/// [IETF RFC 8200, Section 3]: https://datatracker.ietf.org/doc/html/rfc8200#section-3
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(transparent)]
pub struct TrafficClass(pub u8);

impl TrafficClass {}

impl From<u8> for TrafficClass {
    fn from(value: u8) -> Self {
        Self(value)
    }
}

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

impl std::fmt::Display for TrafficClass {
    fn fmt(&self, _f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        todo!()
    }
}

impl Codec for TrafficClass {
    fn encode<W: BufMut>(&self, _writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        // the same as decode but reversed
        todo!()
    }

    // ((v_tc_fl >> 20) & 0xFF) as u8;
    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        let _version_traffic_class = reader.read_u8()?;
        let _traffic_class_flow_label = reader.peek_u8()?;
        // we're need to combine this two variables of first ipv6 header 16 bits to extract only `Traffic Class`
        let traffic_class = 0;

        Ok(Self(traffic_class))
    }
}

/// `Flow Label` IPv6 header field.
///
/// Defined in [IETF RFC 8200, Section 3].
///
/// [IETF RFC 8200, Section 3]: https://datatracker.ietf.org/doc/html/rfc8200#section-3
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(transparent)]
pub struct FlowLabel(pub u32);

impl FlowLabel {}

impl From<u32> for FlowLabel {
    fn from(value: u32) -> Self {
        Self(value)
    }
}

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

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

    fn decode<R: Buf>(_reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        todo!()
        // Ok(Self())
    }
}

impl std::fmt::Display for FlowLabel {
    fn fmt(&self, _f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        todo!()
    }
}

/// `Payload Length` field of IPv6 header.
///
/// Defined in [IETF RFC 8200, Section 3].
///
/// [IETF RFC 8200, Section 3]: https://datatracker.ietf.org/doc/html/rfc8200#section-3
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(transparent)]
pub struct PayloadLength(pub u16);

impl PayloadLength {}

impl From<u16> for PayloadLength {
    fn from(value: u16) -> Self {
        Self(value)
    }
}

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

impl Codec for PayloadLength {
    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, ())?))
    }
}

impl std::fmt::Display for PayloadLength {
    fn fmt(&self, _f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        todo!()
    }
}

/// Hop Limit IPv6 header field.
///
/// Defined in [IETF RFC 8200, Section 3].
///
/// [IETF RFC 8200, Section 3]: https://datatracker.ietf.org/doc/html/rfc8200#section-3
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(transparent)]
pub struct HopLimit(pub u8);

impl HopLimit {}

impl From<u8> for HopLimit {
    fn from(value: u8) -> Self {
        Self(value)
    }
}

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

impl Codec for HopLimit {
    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, ())?))
    }
}

impl std::fmt::Display for HopLimit {
    fn fmt(&self, _f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        todo!()
    }
}

/// An IPv6 address.
///
/// Defined in [IETF RFC 8200, Section 3].
///
/// [IETF RFC 8200, Section 3]: https://datatracker.ietf.org/doc/html/rfc8200#section-3
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(transparent)]
pub struct Address(pub [u8; 16]);

impl Address {
    ///
    pub const UNSPECIFIED: Self = Self([0; 16]);
    ///
    pub const LOOPBACK: Self = Self([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]);

    ///
    pub const fn from_octets(octets: [u8; 16]) -> Self {
        Self(octets)
    }

    ///
    pub const fn octets(self) -> [u8; 16] {
        self.0
    }

    ///
    pub const fn is_multicast(self) -> bool {
        self.0[0] == 0xFF
    }

    ///
    pub const fn is_link_local(self) -> bool {
        self.0[0] == 0xFE && (self.0[1] & 0xC0) == 0x80
    }

    ///
    pub const fn is_unique_local(self) -> bool {
        // fc00::/7
        (self.0[0] & 0xFE) == 0xFC
    }

    ///
    pub const fn is_global_unicast(self) -> bool {
        /*!self.is_unspecified()
        && !self.is_loopback()
        &&*/
        !self.is_multicast() && !self.is_link_local() && !self.is_unique_local()
    }
}

impl From<[u8; 16]> for Address {
    fn from(octets: [u8; 16]) -> Self {
        Self(octets)
    }
}

impl From<Address> for [u8; 16] {
    fn from(addr: Address) -> Self {
        addr.0
    }
}

impl Codec for Address {
    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(reader.read_array::<16>()?))
    }
}

impl std::fmt::Display for Address {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        for (i, &byte) in self.0.iter().enumerate() {
            if i % 2 == 0 && i != 0 {
                write!(f, ":")?;
            }
            write!(f, "{:02x}", byte)?;
        }
        Ok(())
    }
}

/// A Hop By Hop Options IPv6 extension header.
///
/// Defined in [IETF RFC 8200, Section 4.3]
///
/// [IETF RFC 8200, Section 4.3]: https://datatracker.ietf.org/doc/html/rfc8200#section-4.3
///
/// # Examples
/// ```
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct HopByHopOptionsHeader {
    ///
    pub next_header: Protocol,
    ///
    pub hdr_ext_len: u8,
}

impl Codec for HopByHopOptionsHeader {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        self.next_header.encode(writer, ())?;
        self.hdr_ext_len.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        let next_header = Protocol::decode(reader, ())?;
        let hdr_ext_len = u8::decode(reader, ())?;

        Ok(Self {
            next_header,
            hdr_ext_len,
        })
    }
}

/// A Routing IPv6 extension header.
///
/// Defined in [IETF RFC 8200, Section 4.4]
///
/// [IETF RFC 8200, Section 4.4]: https://datatracker.ietf.org/doc/html/rfc8200#section-4.4
///
/// # Examples
/// ```
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct RoutingHeader {
    ///
    pub next_header: u8,
    ///
    pub reserved: u8,
    ///
    pub fragment_offset: u16,
    ///
    pub res: u8,
    ///
    pub m: bool,
    ///
    pub identification: u32,
}

impl Codec for RoutingHeader {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        self.next_header.encode(writer, ())?;
        self.reserved.encode(writer, ())?;

        let frag_off_res_m: u16 = ((self.fragment_offset & 0x1FFF) << 3)
            | ((self.res as u16 & 0x03) << 1)
            | (self.m as u16);

        frag_off_res_m.encode(writer, ())?;
        self.identification.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        let next_header = u8::decode(reader, ())?;
        let reserved = u8::decode(reader, ())?;

        let frag_off_res_m = u16::decode(reader, ())?;
        let fragment_offset = frag_off_res_m >> 3;
        let res = ((frag_off_res_m >> 1) & 0x03) as u8;
        let m = (frag_off_res_m & 0x01) != 0;

        let identification = u32::decode(reader, ())?;

        Ok(Self {
            next_header,
            reserved,
            fragment_offset,
            res,
            m,
            identification,
        })
    }
}

/// A Fragment IPv6 extension header.
///
/// Defined in [IETF RFC 8200, Section 4.5]
///
/// [IETF RFC 8200, Section 4.5]: https://datatracker.ietf.org/doc/html/rfc8200#section-4.5
///
/// # Examples
/// ```
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct FragmentHeader {
    ///
    pub next_header: Protocol,
    ///
    pub reserved: u8,
    ///
    pub fragment_offset: u16,
    ///
    pub res: u8,
    ///
    pub m: bool,
    ///
    pub identification: u32,
}

impl Codec for FragmentHeader {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        self.next_header.encode(writer, ())?;
        self.reserved.encode(writer, ())?;

        let frag_off_res_m: u16 = ((self.fragment_offset & 0x1FFF) << 3)
            | ((self.res as u16 & 0x03) << 1)
            | (self.m as u16);

        frag_off_res_m.encode(writer, ())?;
        self.identification.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        let next_header = Protocol::decode(reader, ())?;
        let reserved = u8::decode(reader, ())?;

        let frag_off_res_m = u16::decode(reader, ())?;
        let fragment_offset = frag_off_res_m >> 3;
        let res = ((frag_off_res_m >> 1) & 0x03) as u8;
        let m = (frag_off_res_m & 0x01) != 0;

        let identification = u32::decode(reader, ())?;

        Ok(Self {
            next_header,
            reserved,
            fragment_offset,
            res,
            m,
            identification,
        })
    }
}

/// A Destination Options IPv6 extension header.
///
/// Defined in [IETF RFC 8200, Section 4.6]
///
/// [IETF RFC 8200, Section 4.6]: https://datatracker.ietf.org/doc/html/rfc8200#section-4.6
///
/// # Examples
/// ```
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct DestinationOptionsHeader {
    ///
    pub next_header: u8,
    ///
    pub reserved: u8,
    ///
    pub fragment_offset: u16,
    ///
    pub res: u8,
    ///
    pub m: bool,
    ///
    pub identification: u32,
}

impl Codec for DestinationOptionsHeader {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        self.next_header.encode(writer, ())?;
        self.reserved.encode(writer, ())?;

        let frag_off_res_m: u16 = ((self.fragment_offset & 0x1FFF) << 3)
            | ((self.res as u16 & 0x03) << 1)
            | (self.m as u16);

        frag_off_res_m.encode(writer, ())?;
        self.identification.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        let next_header = u8::decode(reader, ())?;
        let reserved = u8::decode(reader, ())?;

        let frag_off_res_m = u16::decode(reader, ())?;
        let fragment_offset = frag_off_res_m >> 3;
        let res = ((frag_off_res_m >> 1) & 0x03) as u8;
        let m = (frag_off_res_m & 0x01) != 0;

        let identification = u32::decode(reader, ())?;

        Ok(Self {
            next_header,
            reserved,
            fragment_offset,
            res,
            m,
            identification,
        })
    }
}

/// An Encapsulation Security Payload IPv6 extension header.
///
/// Defined in [IETF RFC 8200, Section 4.5]
///
/// [IETF RFC 8200, Section 4.5]: https://datatracker.ietf.org/doc/html/rfc8200#section-4.5
///
/// # Examples
/// ```
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct EncapsulatingSecurityPayloadHeader {
    ///
    pub next_header: u8,
    ///
    pub reserved: u8,
    ///
    pub fragment_offset: u16,
    ///
    pub res: u8,
    ///
    pub m: bool,
    ///
    pub identification: u32,
}

impl Codec for EncapsulatingSecurityPayloadHeader {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        self.next_header.encode(writer, ())?;
        self.reserved.encode(writer, ())?;

        let frag_off_res_m: u16 = ((self.fragment_offset & 0x1FFF) << 3)
            | ((self.res as u16 & 0x03) << 1)
            | (self.m as u16);

        frag_off_res_m.encode(writer, ())?;
        self.identification.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        let next_header = u8::decode(reader, ())?;
        let reserved = u8::decode(reader, ())?;

        let frag_off_res_m = u16::decode(reader, ())?;
        let fragment_offset = frag_off_res_m >> 3;
        let res = ((frag_off_res_m >> 1) & 0x03) as u8;
        let m = (frag_off_res_m & 0x01) != 0;

        let identification = u32::decode(reader, ())?;

        Ok(Self {
            next_header,
            reserved,
            fragment_offset,
            res,
            m,
            identification,
        })
    }
}

/// An Authentication IPv6 extension header.
///
/// Defined in [IETF RFC 8200, Section 4.5]
///
/// [IETF RFC 8200, Section 4.5]: https://datatracker.ietf.org/doc/html/rfc8200#section-4.5
///
/// # Examples
/// ```
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct AuthenticationHeader {
    ///
    pub next_header: u8,
    ///
    pub reserved: u8,
    ///
    pub fragment_offset: u16,
    ///
    pub res: u8,
    ///
    pub m: bool,
    ///
    pub identification: u32,
}

impl Codec for AuthenticationHeader {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        self.next_header.encode(writer, ())?;
        self.reserved.encode(writer, ())?;

        let frag_off_res_m: u16 = ((self.fragment_offset & 0x1FFF) << 3)
            | ((self.res as u16 & 0x03) << 1)
            | (self.m as u16);

        frag_off_res_m.encode(writer, ())?;
        self.identification.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        let next_header = u8::decode(reader, ())?;
        let reserved = u8::decode(reader, ())?;

        let frag_off_res_m = u16::decode(reader, ())?;
        let fragment_offset = frag_off_res_m >> 3;
        let res = ((frag_off_res_m >> 1) & 0x03) as u8;
        let m = (frag_off_res_m & 0x01) != 0;

        let identification = u32::decode(reader, ())?;

        Ok(Self {
            next_header,
            reserved,
            fragment_offset,
            res,
            m,
            identification,
        })
    }
}

/// A Mobility IPv6 extension header.
///
/// Defined in [IETF RFC 8200, Section 4.5]
///
/// [IETF RFC 8200, Section 4.5]: https://datatracker.ietf.org/doc/html/rfc8200#section-4.5
///
/// # Examples
/// ```
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct MobilityHeader {
    ///
    pub next_header: u8,
    ///
    pub reserved: u8,
    ///
    pub fragment_offset: u16,
    ///
    pub res: u8,
    ///
    pub m: bool,
    ///
    pub identification: u32,
}

impl Codec for MobilityHeader {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        self.next_header.encode(writer, ())?;
        self.reserved.encode(writer, ())?;

        let frag_off_res_m: u16 = ((self.fragment_offset & 0x1FFF) << 3)
            | ((self.res as u16 & 0x03) << 1)
            | (self.m as u16);

        frag_off_res_m.encode(writer, ())?;
        self.identification.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        let next_header = u8::decode(reader, ())?;
        let reserved = u8::decode(reader, ())?;

        let frag_off_res_m = u16::decode(reader, ())?;
        let fragment_offset = frag_off_res_m >> 3;
        let res = ((frag_off_res_m >> 1) & 0x03) as u8;
        let m = (frag_off_res_m & 0x01) != 0;

        let identification = u32::decode(reader, ())?;

        Ok(Self {
            next_header,
            reserved,
            fragment_offset,
            res,
            m,
            identification,
        })
    }
}

/// A Host Identity Protocol IPv6 extension header.
///
/// Defined in [IETF RFC 8200, Section 4.5]
///
/// [IETF RFC 8200, Section 4.5]: https://datatracker.ietf.org/doc/html/rfc8200#section-4.5
///
/// # Examples
/// ```
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct HostIdentityProtocolHeader {
    ///
    pub next_header: u8,
    ///
    pub reserved: u8,
    ///
    pub fragment_offset: u16,
    ///
    pub res: u8,
    ///
    pub m: bool,
    ///
    pub identification: u32,
}

impl Codec for HostIdentityProtocolHeader {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        self.next_header.encode(writer, ())?;
        self.reserved.encode(writer, ())?;

        let frag_off_res_m: u16 = ((self.fragment_offset & 0x1FFF) << 3)
            | ((self.res as u16 & 0x03) << 1)
            | (self.m as u16);

        frag_off_res_m.encode(writer, ())?;
        self.identification.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        let next_header = u8::decode(reader, ())?;
        let reserved = u8::decode(reader, ())?;

        let frag_off_res_m = u16::decode(reader, ())?;
        let fragment_offset = frag_off_res_m >> 3;
        let res = ((frag_off_res_m >> 1) & 0x03) as u8;
        let m = (frag_off_res_m & 0x01) != 0;

        let identification = u32::decode(reader, ())?;

        Ok(Self {
            next_header,
            reserved,
            fragment_offset,
            res,
            m,
            identification,
        })
    }
}

/// A Shim6 IPv6 extension header.
///
/// Defined in [IETF RFC 8200, Section 4.5]
///
/// [IETF RFC 8200, Section 4.5]: https://datatracker.ietf.org/doc/html/rfc8200#section-4.5
///
/// # Examples
/// ```
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Shim6Header {
    ///
    pub next_header: u8,
    ///
    pub reserved: u8,
    ///
    pub fragment_offset: u16,
    ///
    pub res: u8,
    ///
    pub m: bool,
    ///
    pub identification: u32,
}

impl Codec for Shim6Header {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        self.next_header.encode(writer, ())?;
        self.reserved.encode(writer, ())?;

        let frag_off_res_m: u16 = ((self.fragment_offset & 0x1FFF) << 3)
            | ((self.res as u16 & 0x03) << 1)
            | (self.m as u16);

        frag_off_res_m.encode(writer, ())?;
        self.identification.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        let next_header = u8::decode(reader, ())?;
        let reserved = u8::decode(reader, ())?;

        let frag_off_res_m = u16::decode(reader, ())?;
        let fragment_offset = frag_off_res_m >> 3;
        let res = ((frag_off_res_m >> 1) & 0x03) as u8;
        let m = (frag_off_res_m & 0x01) != 0;

        let identification = u32::decode(reader, ())?;

        Ok(Self {
            next_header,
            reserved,
            fragment_offset,
            res,
            m,
            identification,
        })
    }
}

// #[cfg(test)]
// mod tests {
//     use super::*;

//     use crate::BufError;
//     use crate::Codec;
//     use crate::Cursor;
//     use crate::ipv6::mapping::FragmentHeaderMapping;
//     use crate::ipv6::{FragmentHeader, Ipv6};

//     #[test]
//     fn test_ipv6_fragmentation() -> Result<(), BufError> {
//         let src_ip =
//             Address::from_octets([0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x01]);
//         let dst_ip =
//             Address::from_octets([0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x02]);
//         let packet_id = 0x12345678;

//         // Имитируем TCP заголовок (20 байт) + HTTP GET (37 байт) = 57 байт
//         let mut original_payload = Vec::new();
//         // В реальном коде здесь было бы: tcp_header.encode(&mut Cursor::new(&mut original_payload))?;
//         original_payload.extend_from_slice(&[0u8; 20]); // Заглушка для TCP заголовка
//         original_payload.extend_from_slice(b"GET / HTTP/1.1\r\nHost: example.com\r\n\r\n");

//         // Разбиваем на части: 32 байта и 25 байт
//         let (payload_part1, payload_part2) = original_payload.split_at(32);

//         // ====================================================================
//         // ГЕНЕРАЦИЯ ФРАГМЕНТА 1 (Смещение 0, Флаг M = 1)
//         // ====================================================================
//         let mut frag1_buffer = vec![0u8; 100];
//         let mut cursor1 = Cursor::new(&mut frag1_buffer[..]);

//         let ipv6_frag1 = Ipv6 {
//             traffic_class: 0,
//             flow_label: 0,
//             payload_length: (8 + payload_part1.len()) as u16,
//             next_header: 44,
//             hop_limit: 64,
//             source_address: src_ip,
//             destination_address: dst_ip,
//         };
//         ipv6_frag1.encode(&mut cursor1)?;

//         let frag_header1 = FragmentHeader {
//             next_header: Protocol::TCP,
//             reserved: 0,
//             fragment_offset: 0,
//             res: 0,
//             m: true,
//             identification: packet_id,
//         };
//         frag_header1.encode(&mut cursor1)?;

//         for &byte in payload_part1 {
//             cursor1.write_u8(byte)?;
//         }

//         let mut frag2_buffer = vec![0u8; 100];
//         let mut cursor2 = Cursor::new(&mut frag2_buffer[..]);

//         let ipv6_frag2 = Ipv6 {
//             traffic_class: Tr0,
//             flow_label: 0,
//             payload_length: (8 + payload_part2.len()) as u16,
//             next_header: 44,
//             hop_limit: 64,
//             source_address: src_ip,
//             destination_address: dst_ip,
//         };
//         ipv6_frag2.encode(&mut cursor2)?;

//         let frag_header2 = FragmentHeader {
//             next_header: Protocol::TCP,
//             reserved: 0,
//             fragment_offset: 4,
//             res: 0,
//             m: false,
//             identification: packet_id,
//         };
//         frag_header2.encode(&mut cursor2)?;

//         for &byte in payload_part2 {
//             cursor2.write_u8(byte)?;
//         }

//         // ====================================================================
//         // ВАЛИДАЦИЯ И ПРОВЕРКА ЧЕРЕЗ VIEWS (ZERO-COPY)
//         // ====================================================================

//         let frag1_view = FragmentHeaderMapping::new(&frag1_buffer[40..48]);
//         assert_eq!(frag1_view.read_next_header()?, 6);
//         assert_eq!(frag1_view.read_fragment_offset()?, 0);
//         assert_eq!(frag1_view.read_m()?, true);
//         assert_eq!(frag1_view.read_identification()?, packet_id);

//         let frag2_view = FragmentHeaderMapping::new(&frag2_buffer[40..48]);
//         assert_eq!(frag2_view.read_next_header()?, 6);
//         assert_eq!(frag2_view.read_fragment_offset()?, 4);
//         assert_eq!(frag2_view.read_m()?, false);
//         assert_eq!(frag2_view.read_identification()?, packet_id);

//         Ok(())
//     }
// }