use crate::{err::ValueTooBigError, *};

/// IPv6 header according to rfc8200.
#[derive(Clone, Debug, Eq, PartialEq, Default)]
pub struct Ipv6Header {
    pub traffic_class: u8,
    /// If non 0 serves as a hint to router and switches with multiple outbound paths that these packets should stay on the same path, so that they will not be reordered.
    pub flow_label: Ipv6FlowLabel,
    ///The length of the payload and extension headers in bytes (0 in case of jumbo payloads).
    pub payload_length: u16,
    /// IP protocol number specifying the next header or transport layer protocol.
    ///
    /// See [IpNumber] or [ip_number] for a definitions of ids.
    pub next_header: IpNumber,
    /// The number of hops the packet can take before it is discarded.
    pub hop_limit: u8,
    /// IPv6 source address
    pub source: [u8; 16],
    /// IPv6 destination address
    pub destination: [u8; 16],
}

impl Ipv6Header {
    /// Serialized size of an IPv6 header in bytes/octets.
    pub const LEN: usize = 40;

    #[deprecated(since = "0.14.0", note = "Use `Ipv6Header::LEN` instead")]
    pub const SERIALIZED_SIZE: usize = Ipv6Header::LEN;

    /// Renamed to `Ipv6Header::from_slice`
    #[deprecated(since = "0.10.1", note = "Renamed to `Ipv6Header::from_slice`")]
    #[inline]
    pub fn read_from_slice(
        slice: &[u8],
    ) -> Result<(Ipv6Header, &[u8]), err::ipv6::HeaderSliceError> {
        Ipv6Header::from_slice(slice)
    }

    /// Read an Ipv6Header from a slice and return the header & unused parts of the slice.
    ///
    /// Note that this function DOES NOT seperate the payload based on the length
    /// payload_length present in the IPv6 header. It just returns the left over slice
    /// after the header.
    ///
    /// If you want to have correctly seperated payload including the IP extension
    /// headers use
    ///
    /// * [`crate::IpHeaders::from_ipv6_slice`] (decodes all the fields of the IP headers)
    /// * [`crate::Ipv6Slice::from_slice`] (just identifies the ranges in the slice where
    ///   the headers and payload are present)
    ///
    /// or
    ///
    /// * [`crate::IpHeaders::from_ipv6_slice_lax`]
    /// * [`crate::Ipv6Slice::from_slice_lax`]
    ///
    /// for a laxer version which falls back to slice length when the `payload_length`
    /// contains an inconsistent value.
    #[inline]
    pub fn from_slice(slice: &[u8]) -> Result<(Ipv6Header, &[u8]), err::ipv6::HeaderSliceError> {
        Ok((
            Ipv6HeaderSlice::from_slice(slice)?.to_header(),
            &slice[Ipv6Header::LEN..],
        ))
    }

    ///Reads an IPv6 header from the current position.
    #[cfg(feature = "std")]
    #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
    pub fn read<T: std::io::Read + std::io::Seek + Sized>(
        reader: &mut T,
    ) -> Result<Ipv6Header, err::ipv6::HeaderReadError> {
        use err::ipv6::{HeaderError::*, HeaderReadError::*};

        let mut value: [u8; 1] = [0; 1];
        reader.read_exact(&mut value).map_err(Io)?;
        let version_number = value[0] >> 4;
        if 6 != version_number {
            return Err(Content(UnexpectedVersion { version_number }));
        }
        Ipv6Header::read_without_version(reader, value[0] & 0xf).map_err(Io)
    }

    ///Reads an IPv6 header assuming the version & flow_label field have already been read.
    #[cfg(feature = "std")]
    #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
    pub fn read_without_version<T: std::io::Read + std::io::Seek + Sized>(
        reader: &mut T,
        version_rest: u8,
    ) -> Result<Ipv6Header, std::io::Error> {
        let mut buffer: [u8; 8 + 32 - 1] = [0; 8 + 32 - 1];
        reader.read_exact(&mut buffer[..])?;

        Ok(Ipv6Header {
            traffic_class: (version_rest << 4) | (buffer[0] >> 4),
            flow_label: unsafe {
                // SAFETY: Safe as the bitmask & 0 contant guarantee that the value
                // does not exceed 20 bytes.
                Ipv6FlowLabel::new_unchecked(u32::from_be_bytes([
                    0,
                    buffer[0] & 0b0000_1111,
                    buffer[1],
                    buffer[2],
                ]))
            },
            payload_length: u16::from_be_bytes([buffer[3], buffer[4]]),
            next_header: IpNumber(buffer[5]),
            hop_limit: buffer[6],
            #[rustfmt::skip]
            source: [
                buffer[7],   buffer[8],  buffer[9], buffer[10],
                buffer[11], buffer[12], buffer[13], buffer[14],
                buffer[15], buffer[16], buffer[17], buffer[18],
                buffer[19], buffer[20], buffer[21], buffer[22],
            ],
            #[rustfmt::skip]
            destination: [
                buffer[23], buffer[24], buffer[25], buffer[26],
                buffer[27], buffer[28], buffer[29], buffer[30],
                buffer[31], buffer[32], buffer[33], buffer[34],
                buffer[35], buffer[36], buffer[37], buffer[38],
            ],
        })
    }

    ///Takes a slice and skips an ipv6 header extensions and returns the next_header ip number & the slice past the header.
    pub fn skip_header_extension_in_slice(
        slice: &[u8],
        next_header: IpNumber,
    ) -> Result<(IpNumber, &[u8]), err::LenError> {
        use crate::ip_number::*;

        // verify that a ipv6 extension is present (before
        // validating the slice length)
        match next_header {
            IPV6_FRAG | AUTH | IPV6_HOP_BY_HOP | IPV6_ROUTE | IPV6_DEST_OPTIONS | MOBILITY
            | HIP | SHIM6 => {}
            _ => {
                return Ok((next_header, slice));
            }
        }

        if slice.len() >= 2 {
            //determine the length
            let len = match next_header {
                IPV6_FRAG => 8,
                AUTH => (usize::from(slice[1]) + 2) * 4,
                IPV6_HOP_BY_HOP | IPV6_ROUTE | IPV6_DEST_OPTIONS | MOBILITY | HIP | SHIM6 => {
                    (usize::from(slice[1]) + 1) * 8
                }
                // not a ipv6 header extension that can be skipped
                _ => unreachable!(),
            };

            if slice.len() < len {
                Err(err::LenError {
                    required_len: len,
                    len: slice.len(),
                    len_source: LenSource::Slice,
                    layer: err::Layer::Ipv6ExtHeader,
                    layer_start_offset: 0,
                })
            } else {
                Ok((IpNumber(slice[0]), &slice[len..]))
            }
        } else {
            Err(err::LenError {
                required_len: 2,
                len: slice.len(),
                len_source: LenSource::Slice,
                layer: err::Layer::Ipv6ExtHeader,
                layer_start_offset: 0,
            })
        }
    }

    /// Returns true if the given ip protocol number is a skippable header extension.
    ///
    /// A skippable header extension is an extension header for which it is known how
    /// to determine the protocol number of the following header as well as how many
    /// octets have to be skipped to reach the start of the following header.
    pub fn is_skippable_header_extension(ip_protocol_number: IpNumber) -> bool {
        use crate::ip_number::*;
        //Note: EncapsulatingSecurityPayload & ExperimentalAndTesting0 can not be skipped
        matches!(
            ip_protocol_number,
            IPV6_HOP_BY_HOP
                | IPV6_ROUTE
                | IPV6_FRAG
                | AUTH
                | IPV6_DEST_OPTIONS
                | MOBILITY
                | HIP
                | SHIM6
        )
    }

    ///Takes a slice & ip protocol number (identifying the first header type) and returns next_header id & the slice past after all ipv6 header extensions.
    pub fn skip_all_header_extensions_in_slice(
        slice: &[u8],
        next_header: IpNumber,
    ) -> Result<(IpNumber, &[u8]), err::LenError> {
        let mut next_header = next_header;
        let mut rest = slice;
        let mut offset = 0;

        loop {
            let (n_id, n_rest) = Ipv6Header::skip_header_extension_in_slice(rest, next_header)
                .map_err(|err| err.add_offset(offset))?;
            offset = slice.len() - n_rest.len();

            if n_rest.len() == rest.len() {
                return Ok((next_header, rest));
            } else {
                next_header = n_id;
                rest = n_rest;
            }
        }
    }

    ///Skips the ipv6 header extension and returns the next ip protocol number
    #[cfg(feature = "std")]
    #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
    pub fn skip_header_extension<T: std::io::Read + std::io::Seek + Sized>(
        reader: &mut T,
        next_header: IpNumber,
    ) -> Result<IpNumber, std::io::Error> {
        use crate::ip_number::*;

        let (next_header, rest_length) = match next_header {
            IPV6_FRAG => {
                let mut buf = [0; 1];
                reader.read_exact(&mut buf)?;
                (IpNumber(buf[0]), 7)
            }
            AUTH => {
                let mut buf = [0; 2];
                reader.read_exact(&mut buf)?;
                (IpNumber(buf[0]), i64::from(buf[1]) * 4 + 6)
            }
            IPV6_HOP_BY_HOP | IPV6_ROUTE | IPV6_DEST_OPTIONS | MOBILITY | HIP | SHIM6 => {
                let mut buf = [0; 2];
                reader.read_exact(&mut buf)?;
                (IpNumber(buf[0]), i64::from(buf[1]) * 8 + 6)
            }
            // not a ipv6 header extension that can be skipped
            _ => return Ok(next_header),
        };

        //Sadly seek does not return an error if the seek could not be fulfilled.
        //Some implementations do not even truncate the returned position to the
        //last valid one. std::io::Cursor for example just moves the position
        //over the border of the given slice (e.g. returns position 15 even when
        //the given slice contains only 1 element).
        //The only option, to detect that we are in an invalid state, is to move the
        //seek offset to one byte before the end and then execute a normal read to
        //trigger an error.
        reader.seek(std::io::SeekFrom::Current(rest_length - 1))?;
        {
            let mut buf = [0; 1];
            reader.read_exact(&mut buf)?;
        }
        Ok(next_header)
    }

    ///Skips all ipv6 header extensions and returns the next ip protocol number
    #[cfg(feature = "std")]
    #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
    pub fn skip_all_header_extensions<T: std::io::Read + std::io::Seek + Sized>(
        reader: &mut T,
        next_header: IpNumber,
    ) -> Result<IpNumber, std::io::Error> {
        let mut next_header = next_header;

        loop {
            if Ipv6Header::is_skippable_header_extension(next_header) {
                next_header = Ipv6Header::skip_header_extension(reader, next_header)?;
            } else {
                return Ok(next_header);
            }
        }
    }

    ///Writes a given IPv6 header to the current position.
    #[cfg(feature = "std")]
    #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
    pub fn write<T: std::io::Write + Sized>(&self, writer: &mut T) -> Result<(), std::io::Error> {
        writer.write_all(&self.to_bytes())
    }

    /// Return the ipv6 source address as an std::net::Ipv6Addr
    #[cfg(feature = "std")]
    #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
    #[inline]
    pub fn source_addr(&self) -> std::net::Ipv6Addr {
        std::net::Ipv6Addr::from(self.source)
    }

    /// Return the ipv6 destination address as an std::net::Ipv6Addr
    #[cfg(feature = "std")]
    #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
    #[inline]
    pub fn destination_addr(&self) -> std::net::Ipv6Addr {
        std::net::Ipv6Addr::from(self.destination)
    }

    /// Length of the serialized header in bytes.
    ///
    /// The function always returns the constant Ipv6Header::LEN
    /// and exists to keep the methods consistent with other headers.
    #[inline]
    pub fn header_len(&self) -> usize {
        Ipv6Header::LEN
    }

    /// Sets the field total_length based on the size of the payload and the options. Returns an error if the payload is too big to fit.
    pub fn set_payload_length(&mut self, size: usize) -> Result<(), ValueTooBigError<usize>> {
        use crate::err::ValueType;
        // check that the total length fits into the field
        const MAX_PAYLOAD_LENGTH: usize = core::u16::MAX as usize;
        if MAX_PAYLOAD_LENGTH < size {
            return Err(ValueTooBigError {
                actual: size,
                max_allowed: MAX_PAYLOAD_LENGTH,
                value_type: ValueType::Ipv6PayloadLength,
            });
        }

        self.payload_length = size as u16;
        Ok(())
    }

    /// Returns the serialized form of the header as a statically
    /// sized byte array.
    #[rustfmt::skip]
    pub fn to_bytes(&self) -> [u8;Ipv6Header::LEN] {
        // serialize header
        let flow_label_be = self.flow_label.value().to_be_bytes();
        let payload_len_be = self.payload_length.to_be_bytes();

        [
            (6 << 4) | (self.traffic_class >> 4),
            (self.traffic_class << 4) | flow_label_be[1],
            flow_label_be[2],
            flow_label_be[3],
            payload_len_be[0],
            payload_len_be[1],
            self.next_header.0,
            self.hop_limit,
            self.source[0], self.source[1], self.source[2], self.source[3],
            self.source[4], self.source[5], self.source[6], self.source[7],
            self.source[8], self.source[9], self.source[10], self.source[11],
            self.source[12], self.source[13], self.source[14], self.source[15],
            self.destination[0], self.destination[1], self.destination[2], self.destination[3],
            self.destination[4], self.destination[5], self.destination[6], self.destination[7],
            self.destination[8], self.destination[9], self.destination[10], self.destination[11],
            self.destination[12], self.destination[13], self.destination[14], self.destination[15],
        ]
    }
}

#[cfg(test)]
mod test {
    use crate::{
        err::ipv6::HeaderError::*, err::ipv6::HeaderSliceError::*, ip_number::*, test_gens::*, *,
    };
    use alloc::format;
    use arrayvec::ArrayVec;
    use proptest::*;
    use std::io::Cursor;

    #[test]
    fn default() {
        let header: Ipv6Header = Default::default();
        assert_eq!(0, header.traffic_class);
        assert_eq!(0, header.flow_label.value());
        assert_eq!(0, header.payload_length);
        assert_eq!(255, header.next_header.0);
        assert_eq!(0, header.hop_limit);
        assert_eq!([0u8; 16], header.source);
        assert_eq!([0u8; 16], header.destination);
    }

    #[test]
    fn debug() {
        let header: Ipv6Header = Default::default();
        assert_eq!(
            format!("{:?}", header),
            format!(
                "Ipv6Header {{ traffic_class: {}, flow_label: {:?}, payload_length: {}, next_header: {:?}, hop_limit: {}, source: {:?}, destination: {:?} }}",
                header.traffic_class,
                header.flow_label,
                header.payload_length,
                header.next_header,
                header.hop_limit,
                header.source,
                header.destination
            )
        );
    }

    proptest! {
        #[test]
        fn clone_eq(header in ipv6_any()) {
            assert_eq!(header.clone(), header);
        }
    }

    proptest! {
        #[test]
        #[allow(deprecated)]
        fn read_from_slice(
            header in ipv6_any(),
            bad_version in 0..=0b1111u8
        ) {
            // ok read
            {
                let bytes = header.to_bytes();
                let (actual, rest) = Ipv6Header::read_from_slice(&bytes).unwrap();
                assert_eq!(header, actual);
                assert_eq!(rest, &[]);
            }

            // version error
            if bad_version != 6 {
                let mut bytes = header.to_bytes();
                // inject a bad version number
                bytes[0] = (0b1111 & bytes[0]) | (bad_version << 4);

                assert_eq!(
                    Ipv6Header::read_from_slice(&bytes).unwrap_err(),
                    Content(UnexpectedVersion{ version_number: bad_version })
                );
            }

            // length error
            {
                let bytes = header.to_bytes();
                for len in 0..bytes.len() {
                    assert_eq!(
                        Ipv6Header::read_from_slice(&bytes[..len])
                            .unwrap_err(),
                        Len(err::LenError{
                            required_len: Ipv6Header::LEN,
                            len: len,
                            len_source: LenSource::Slice,
                            layer: err::Layer::Ipv6Header,
                            layer_start_offset: 0,
                        })
                    );
                }
            }
        }
    }

    proptest! {
        #[test]
        fn from_slice(
            header in ipv6_any(),
            bad_version in 0..=0b1111u8
        ) {
            // ok read
            {
                let bytes = header.to_bytes();
                let (actual, rest) = Ipv6Header::from_slice(&bytes).unwrap();
                assert_eq!(header, actual);
                assert_eq!(rest, &[]);
            }

            // version error
            if bad_version != 6 {
                let mut bytes = header.to_bytes();
                // inject a bad version number
                bytes[0] = (0b1111 & bytes[0]) | (bad_version << 4);

                assert_eq!(
                    Ipv6Header::from_slice(&bytes).unwrap_err(),
                    Content(UnexpectedVersion{ version_number: bad_version })
                );
            }

            // length error
            {
                let bytes = header.to_bytes();
                for len in 0..bytes.len() {
                    assert_eq!(
                        Ipv6Header::from_slice(&bytes[..len])
                            .unwrap_err(),
                        Len(err::LenError{
                            required_len: Ipv6Header::LEN,
                            len: len,
                            len_source: LenSource::Slice,
                            layer: err::Layer::Ipv6Header,
                            layer_start_offset: 0,
                        })
                    );
                }
            }
        }
    }

    proptest! {
        #[test]
        fn read(
            header in ipv6_any(),
            bad_version in 0..=0b1111u8
        ) {
            use err::ipv6::HeaderError::*;

            // ok read
            {
                let bytes = header.to_bytes();
                let mut cursor = Cursor::new(&bytes[..]);
                let actual = Ipv6Header::read(&mut cursor).unwrap();
                assert_eq!(header, actual);
                assert_eq!(cursor.position(), bytes.len() as u64);
            }

            // version error
            if bad_version != 6 {
                let mut bytes = header.to_bytes();
                // inject a bad version number
                bytes[0] = (0b1111 & bytes[0]) | (bad_version << 4);

                let mut cursor = Cursor::new(&bytes[..]);
                assert_eq!(
                    Ipv6Header::read(&mut cursor)
                        .unwrap_err()
                        .content_error()
                        .unwrap(),
                    UnexpectedVersion {
                        version_number: bad_version,
                    }
                );
            }

            // io error
            {
                let bytes = header.to_bytes();
                for len in 0..bytes.len() {
                    let mut cursor = Cursor::new(&bytes[..len]);
                    assert!(Ipv6Header::read(&mut cursor).is_err());
                }
            }
        }
    }

    proptest! {
        #[test]
        fn read_without_version(header in ipv6_any()) {
            // ok read
            {
                let bytes = header.to_bytes();
                let mut cursor = Cursor::new(&bytes[1..]);
                let actual = Ipv6Header::read_without_version(&mut cursor, bytes[0] & 0xf).unwrap();
                assert_eq!(header, actual);
                assert_eq!(cursor.position(), bytes.len() as u64 - 1);
            }

            // io error
            {
                let bytes = header.to_bytes();
                for len in 1..bytes.len() {
                    let mut cursor = Cursor::new(&bytes[1..len]);
                    assert!(Ipv6Header::read_without_version(&mut cursor, bytes[0] & 0xf).is_err());
                }
            }
        }
    }

    proptest! {
        #[test]
        fn skip_header_extension_in_slice(
            generic in ipv6_raw_ext_any(),
            frag in ipv6_fragment_any(),
            auth in ip_auth_any()
        ) {
            const GENERICS: [IpNumber;7] = [
                IPV6_HOP_BY_HOP,
                IPV6_DEST_OPTIONS,
                IPV6_ROUTE,
                IPV6_DEST_OPTIONS,
                MOBILITY,
                HIP,
                SHIM6,
            ];

            // generic headers
            for g in GENERICS {
                let bytes = generic.to_bytes();
                // ok case
                {
                    let (next, rest) = Ipv6Header::skip_header_extension_in_slice(&bytes, g).unwrap();
                    assert_eq!(next, generic.next_header);
                    assert_eq!(rest, &[]);
                }
                // length error
                for len in 0..bytes.len() {
                    assert_eq!(
                        Ipv6Header::skip_header_extension_in_slice(&bytes[..len], g).unwrap_err(),
                        err::LenError {
                            required_len: if len < 2 {
                                2
                            } else {
                                bytes.len()
                            },
                            len: len,
                            len_source: LenSource::Slice,
                            layer: err::Layer::Ipv6ExtHeader,
                            layer_start_offset: 0,
                        }
                    );
                }
            }
            // frag header
            {
                let bytes = frag.to_bytes();
                // ok case
                {
                    let (next, rest) = Ipv6Header::skip_header_extension_in_slice(&bytes, IPV6_FRAG).unwrap();
                    assert_eq!(next, frag.next_header);
                    assert_eq!(rest, &[]);
                }
                // length error
                for len in 0..bytes.len() {
                    assert_eq!(
                        Ipv6Header::skip_header_extension_in_slice(&bytes[..len], IPV6_FRAG).unwrap_err(),
                        err::LenError {
                            required_len: if len < 2 {
                                2
                            } else {
                                bytes.len()
                            },
                            len: len,
                            len_source: LenSource::Slice,
                            layer: err::Layer::Ipv6ExtHeader,
                            layer_start_offset: 0,
                        }
                    );
                }
            }

            // auth header
            {
                let bytes = auth.to_bytes();
                // ok case
                {
                    let (next, rest) = Ipv6Header::skip_header_extension_in_slice(&bytes, AUTH).unwrap();
                    assert_eq!(next, auth.next_header);
                    assert_eq!(rest, &[]);
                }
                // length error
                for len in 0..bytes.len() {
                    assert_eq!(
                        Ipv6Header::skip_header_extension_in_slice(&bytes[..len], AUTH).unwrap_err(),
                        err::LenError {
                            required_len: if len < 2 {
                                2
                            } else {
                                bytes.len()
                            },
                            len: len,
                            len_source: LenSource::Slice,
                            layer: err::Layer::Ipv6ExtHeader,
                            layer_start_offset: 0,
                        }
                    );
                }
            }
        }
    }

    #[test]
    fn is_skippable_header_extension() {
        for i in 0..0xffu8 {
            let expected = match IpNumber(i) {
                IPV6_HOP_BY_HOP | IPV6_ROUTE | IPV6_FRAG | AUTH | IPV6_DEST_OPTIONS | MOBILITY
                | HIP | SHIM6 => true,
                _ => false,
            };
            assert_eq!(
                expected,
                Ipv6Header::is_skippable_header_extension(IpNumber(i))
            );
        }
    }

    proptest! {
        #[test]
        fn skip_all_header_extensions_in_slice(
            hop_by_hop in ipv6_raw_ext_any(),
            dst_opt1 in ipv6_raw_ext_any(),
            route in ipv6_raw_ext_any(),
            frag in ipv6_fragment_any(),
            auth in ip_auth_any(),
            dst_opt2 in ipv6_raw_ext_any(),
            mobility in ipv6_raw_ext_any(),
            hip in ipv6_raw_ext_any(),
            shim6 in ipv6_raw_ext_any()
        ) {
            // no extension header
            {
                let (next, rest) = Ipv6Header::skip_all_header_extensions_in_slice(&[], UDP).unwrap();
                assert_eq!(UDP, next);
                assert_eq!(rest, &[]);
            }

            // setup a buffer with all extension headers present
            let buffer = {
                let mut buffer = ArrayVec::<u8, {
                    Ipv6RawExtHeader::MAX_LEN * 8 + IpAuthHeader::MAX_LEN
                }>::new();

                // based on RFC 8200 4.1. Extension Header Order
                // & IANA https://www.iana.org/assignments/ipv6-parameters/ipv6-parameters.xhtml
                //
                // IPV6_HOP_BY_HOP,
                // IPV6_DEST_OPTIONS,
                // IPV6_ROUTE,
                // IPV6_FRAG,
                // AUTH,
                // IPV6_DEST_OPTIONS,
                // MOBILITY,
                // HIP,
                // SHIM6,

                let mut hop_by_hop = hop_by_hop.clone();
                hop_by_hop.next_header = IPV6_DEST_OPTIONS;
                buffer.extend(hop_by_hop.to_bytes());

                let mut dst_opt1 = dst_opt1.clone();
                dst_opt1.next_header = IPV6_ROUTE;
                buffer.extend(dst_opt1.to_bytes());

                let mut route = route.clone();
                route.next_header = IPV6_FRAG;
                buffer.extend(route.to_bytes());

                let mut frag = frag.clone();
                frag.next_header = AUTH;
                buffer.extend(frag.to_bytes());

                let mut auth = auth.clone();
                auth.next_header = IPV6_DEST_OPTIONS;
                buffer.extend(auth.to_bytes());

                let mut dst_opt2 = dst_opt2.clone();
                dst_opt2.next_header = MOBILITY;
                buffer.extend(dst_opt2.to_bytes());

                let mut mobility = mobility.clone();
                mobility.next_header = HIP;
                buffer.extend(mobility.to_bytes());

                let mut hip = hip.clone();
                hip.next_header = SHIM6;
                buffer.extend(hip.to_bytes());

                let mut shim6 = shim6.clone();
                shim6.next_header = TCP;
                buffer.extend(shim6.to_bytes());

                buffer
            };

            // ok skip case with all extension headers
            {
                let (next, rest) = Ipv6Header::skip_all_header_extensions_in_slice(&buffer, IPV6_HOP_BY_HOP).unwrap();
                assert_eq!(next, TCP);
                assert_eq!(rest, &[]);
            }

            // length error
            {
                let len_ranges: [usize;9] = [
                    hop_by_hop.header_len(),
                    dst_opt1.header_len(),
                    route.header_len(),
                    frag.header_len(),
                    auth.header_len(),
                    dst_opt2.header_len(),
                    mobility.header_len(),
                    hip.header_len(),
                    shim6.header_len()
                ];
                let get_expected = |len: usize| -> usize{
                    let mut curr = 0;
                    for next in &len_ranges {
                        if len < curr {
                            break;
                        }
                        if len < curr + 2 {
                            curr += 2;
                            break;
                        }
                        curr += next;
                    }
                    curr
                };

                let get_offset = |len: usize| -> usize{
                    let mut curr = 0;
                    for next in &len_ranges {
                        if len < curr + next {
                            break;
                        }
                        curr += next;
                    }
                    curr
                };

                for len in 0..buffer.len() {
                    assert_eq!(
                        Ipv6Header::skip_all_header_extensions_in_slice(&buffer[..len], IPV6_HOP_BY_HOP)
                            .unwrap_err(),
                        err::LenError {
                            required_len: get_expected(len) - get_offset(len),
                            len: len - get_offset(len),
                            len_source: LenSource::Slice,
                            layer: err::Layer::Ipv6ExtHeader,
                            layer_start_offset: get_offset(len),
                        }
                    );
                }
            }
        }
    }

    #[test]
    fn skip_header_extension() {
        use crate::ip_number::*;
        {
            let buffer: [u8; 8] = [0; 8];
            let mut cursor = Cursor::new(&buffer);
            assert_eq!(
                Ipv6Header::skip_header_extension(&mut cursor, ICMP).unwrap(),
                ICMP
            );
            assert_eq!(0, cursor.position());
        }
        {
            let buffer: [u8; 8] = [0; 8];
            let mut cursor = Cursor::new(&buffer);
            assert_eq!(
                Ipv6Header::skip_header_extension(&mut cursor, IPV6_HOP_BY_HOP).unwrap(),
                IpNumber(0)
            );
            assert_eq!(8, cursor.position());
        }
        {
            #[rustfmt::skip]
            let buffer: [u8; 8 * 3] = [
                4, 2, 0, 0, 0, 0, 0, 0,
                0, 0, 0, 0, 0, 0, 0, 0,
                0, 0, 0, 0, 0, 0, 0, 0,
            ];
            let mut cursor = Cursor::new(&buffer);
            assert_eq!(
                Ipv6Header::skip_header_extension(&mut cursor, IPV6_ROUTE).unwrap(),
                IpNumber(4)
            );
            assert_eq!(8 * 3, cursor.position());
        }
        {
            //fragmentation header has a fixed size -> the 2 should be ignored
            #[rustfmt::skip]
            let buffer: [u8; 8 * 3] = [
                4, 2, 0, 0, 0, 0, 0, 0,
                0, 0, 0, 0, 0, 0, 0, 0,
                0, 0, 0, 0, 0, 0, 0, 0,
            ];
            let mut cursor = Cursor::new(&buffer);
            assert_eq!(
                Ipv6Header::skip_header_extension(&mut cursor, IPV6_FRAG).unwrap(),
                IpNumber(4)
            );
            assert_eq!(8, cursor.position());
        }
    }

    proptest! {
        #[test]
        fn skip_all_header_extensions(
            hop_by_hop in ipv6_raw_ext_any(),
            dst_opt1 in ipv6_raw_ext_any(),
            route in ipv6_raw_ext_any(),
            frag in ipv6_fragment_any(),
            auth in ip_auth_any(),
            dst_opt2 in ipv6_raw_ext_any(),
            mobility in ipv6_raw_ext_any(),
            hip in ipv6_raw_ext_any(),
            shim6 in ipv6_raw_ext_any()
        ) {
            // no extension header
            {
                let mut cursor = Cursor::new(&[]);
                let next = Ipv6Header::skip_all_header_extensions(&mut cursor, UDP).unwrap();
                assert_eq!(UDP, next);
                assert_eq!(0, cursor.position());
            }

            // setup a buffer with all extension headers present
            let buffer = {
                let mut buffer = ArrayVec::<u8, {
                    Ipv6RawExtHeader::MAX_LEN * 8 + IpAuthHeader::MAX_LEN
                }>::new();

                // based on RFC 8200 4.1. Extension Header Order
                // & IANA https://www.iana.org/assignments/ipv6-parameters/ipv6-parameters.xhtml
                //
                // IPV6_HOP_BY_HOP,
                // IPV6_DEST_OPTIONS,
                // IPV6_ROUTE,
                // IPV6_FRAG,
                // AUTH,
                // IPV6_DEST_OPTIONS,
                // MOBILITY,
                // HIP,
                // SHIM6,

                let mut hop_by_hop = hop_by_hop.clone();
                hop_by_hop.next_header = IPV6_DEST_OPTIONS;
                buffer.extend(hop_by_hop.to_bytes());

                let mut dst_opt1 = dst_opt1.clone();
                dst_opt1.next_header = IPV6_ROUTE;
                buffer.extend(dst_opt1.to_bytes());

                let mut route = route.clone();
                route.next_header = IPV6_FRAG;
                buffer.extend(route.to_bytes());

                let mut frag = frag.clone();
                frag.next_header = AUTH;
                buffer.extend(frag.to_bytes());

                let mut auth = auth.clone();
                auth.next_header = IPV6_DEST_OPTIONS;
                buffer.extend(auth.to_bytes());

                let mut dst_opt2 = dst_opt2.clone();
                dst_opt2.next_header = MOBILITY;
                buffer.extend(dst_opt2.to_bytes());

                let mut mobility = mobility.clone();
                mobility.next_header = HIP;
                buffer.extend(mobility.to_bytes());

                let mut hip = hip.clone();
                hip.next_header = SHIM6;
                buffer.extend(hip.to_bytes());

                let mut shim6 = shim6.clone();
                shim6.next_header = TCP;
                buffer.extend(shim6.to_bytes());

                buffer
            };

            // ok skip case with all extension headers
            {
                let mut cursor = Cursor::new(&buffer);
                let last = Ipv6Header::skip_all_header_extensions(&mut cursor, IPV6_HOP_BY_HOP).unwrap();
                assert_eq!(last, TCP);
                assert_eq!(cursor.position(), buffer.len() as u64);
            }

            // length error
            for len in 0..buffer.len() {
                let mut cursor = Cursor::new(&buffer[..len]);
                assert!(
                    Ipv6Header::skip_all_header_extensions(&mut cursor, IPV6_HOP_BY_HOP)
                    .is_err()
                );
            }
        }
    }

    proptest! {
        #[test]
        fn write(header in ipv6_any()) {
            let mut buffer = [0u8;Ipv6Header::LEN];
            let len = {
                let mut cursor = Cursor::new(&mut buffer[..]);
                header.write(&mut cursor).unwrap();
                cursor.position() as usize
            };
            assert_eq!(len, header.header_len());
            assert_eq!(
                Ipv6Header::from_slice(&buffer[..len]).unwrap().0,
                header
            );
        }
    }

    proptest! {
        #[test]
        fn source_addr(header in ipv6_any()) {
            assert_eq!(
                header.source_addr().octets(),
                header.source
            );
        }
    }

    proptest! {
        #[test]
        fn destination_addr(header in ipv6_any()) {
            assert_eq!(
                header.destination_addr().octets(),
                header.destination
            );
        }
    }

    proptest! {
        #[test]
        fn to_bytes(header in ipv6_any()) {
            let bytes = header.to_bytes();
            assert_eq!(
                Ipv6Header::from_slice(&bytes).unwrap().0,
                header
            );
        }
    }
}