internet 0.0.2

//! Encoding for IPv4 options following [RFC 791].
//!
//! [IETF RFC 791]: https://datatracker.ietf.org/doc/html/rfc791

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

/// IPv4 options.
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Ipv4Option<'a> {
    /// End of Option List (Type 0).
    EndOfOptionList(EndOfOptionList),
    /// No-Operation (Type 1).
    NoOperation(NoOperation),
    /// Security (Type 130).
    Security(Security<'a>),
    /// Loose Source Routing (Type 131).
    LooseSourceRoute(LooseSourceRoute<'a>),
    /// Strict Source Routing (Type 137).
    StrictSourceRoute(StrictSourceRoute<'a>),
    /// Record Route (Type 7).
    RecordRoute(RecordRoute<'a>),
    /// Stream ID (Type 136).
    StreamId(StreamId),
    /// Internet Timestamp (Type 68).
    InternetTimestamp(InternetTimestamp<'a>),
    /// Router Alert (Type 148).
    RouterAlert(RouterAlert),
}

impl<'a> Codec for Ipv4Option<'a> {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        match self {
            Ipv4Option::EndOfOptionList(opt) => opt.encode(writer, ()),
            Ipv4Option::NoOperation(opt) => opt.encode(writer, ()),
            Ipv4Option::Security(opt) => opt.encode(writer, ()),
            Ipv4Option::LooseSourceRoute(opt) => opt.encode(writer, ()),
            Ipv4Option::StrictSourceRoute(opt) => opt.encode(writer, ()),
            Ipv4Option::RecordRoute(opt) => opt.encode(writer, ()),
            Ipv4Option::StreamId(opt) => opt.encode(writer, ()),
            Ipv4Option::InternetTimestamp(opt) => opt.encode(writer, ()),
            Ipv4Option::RouterAlert(opt) => opt.encode(writer, ()),
        }
    }

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

        match typ_peek {
            0 => Ok(Self::EndOfOptionList(EndOfOptionList::decode(reader, ())?)),
            1 => Ok(Self::NoOperation(NoOperation::decode(reader, ())?)),
            7 => Ok(Self::RecordRoute(RecordRoute::decode(reader, ())?)),
            68 => Ok(Self::InternetTimestamp(InternetTimestamp::decode(
                reader,
                (),
            )?)),
            130 => Ok(Self::Security(Security::decode(reader, ())?)),
            131 => Ok(Self::LooseSourceRoute(LooseSourceRoute::decode(
                reader,
                (),
            )?)),
            136 => Ok(Self::StreamId(StreamId::decode(reader, ())?)),
            137 => Ok(Self::StrictSourceRoute(StrictSourceRoute::decode(
                reader,
                (),
            )?)),
            148 => Ok(Self::RouterAlert(RouterAlert::decode(reader, ())?)),
            _ => Err(BufError::UnexpectedValue),
        }
    }
}

///
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum Type {
    /// End of Option List (EOOL).
    EndOfOptionList = 0,
    /// No-Operation (NOP).
    NoOperation = 1,
    /// Record Route (RR).
    RecordRoute = 7,
    /// Internet Timestamp (TS).
    InternetTimestamp = 68,
    /// Security (SEC).
    Security = 130,
    /// Loose Source Routing (LSRR).
    LooseSourceRoute = 131,
    /// Stream ID (SID).
    StreamId = 136,
    /// Strict Source Routing (SSRR).
    StrictSourceRoute = 137,
    /// Router Alert (RA) [RFC 2113].
    RouterAlert = 148,
}

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::EndOfOptionList as u8 => Ok(Self::EndOfOptionList),
            x if x == Self::NoOperation as u8 => Ok(Self::NoOperation),
            x if x == Self::RecordRoute as u8 => Ok(Self::RecordRoute),
            x if x == Self::InternetTimestamp as u8 => Ok(Self::InternetTimestamp),
            x if x == Self::Security as u8 => Ok(Self::Security),
            x if x == Self::LooseSourceRoute as u8 => Ok(Self::LooseSourceRoute),
            x if x == Self::StreamId as u8 => Ok(Self::StreamId),
            x if x == Self::StrictSourceRoute as u8 => Ok(Self::StrictSourceRoute),
            x if x == Self::RouterAlert as u8 => Ok(Self::RouterAlert),
            _ => Err(BufError::UnexpectedValue),
        }
    }
}

/// End of Option List (EOOL)
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct EndOfOptionList;

impl EndOfOptionList {
    /// The Type
    pub const TYPE: Type = Type::EndOfOptionList;
}

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

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        if Type::decode(reader, ())? != Self::TYPE {
            return Err(BufError::UnexpectedValue);
        }
        Ok(Self)
    }
}

/// No-Operation (NOP)
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct NoOperation;

impl NoOperation {
    ///
    pub const TYPE: Type = Type::NoOperation;
}

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

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        if Type::decode(reader, ())? != Self::TYPE {
            return Err(BufError::UnexpectedValue);
        }
        Ok(Self)
    }
}

/// Router Alert
///
/// ...
///
/// [RFC 2113]: https://datatracker.ietf.org/doc/html/rfc2113
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct RouterAlert {
    /// .
    pub value: u16,
}

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

impl Codec for RouterAlert {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        Self::TYPE.encode(writer, ())?;
        4u8.encode(writer, ())?; // length
        self.value.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        if Type::decode(reader, ())? != Self::TYPE {
            return Err(BufError::UnexpectedValue);
        }
        let _length = u8::decode(reader, ())?;
        Ok(Self {
            value: u16::decode(reader, ())?,
        })
    }
}

/// Record Route (RR)
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct RecordRoute<'a> {
    ///
    pub pointer: u8,
    ///
    pub route_data: &'a [u8],
}

impl<'a> RecordRoute<'a> {
    ///
    pub const TYPE: Type = Type::RecordRoute;

    fn encoded_len(&self) -> usize {
        3 + self.route_data.len() // 1 (kind) + 1 (length) + 1 (pointer) + data
    }
}

impl<'a> Codec for RecordRoute<'a> {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        Self::TYPE.encode(writer, ())?;
        (self.encoded_len() as u8).encode(writer, ())?;
        self.pointer.encode(writer, ())?;

        todo!("Encode variable length slice: self.route_data");
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        if Type::decode(reader, ())? != Self::TYPE {
            return Err(BufError::UnexpectedValue);
        }
        let length = u8::decode(reader, ())?;
        let _pointer = u8::decode(reader, ())?;
        let _data_len = length.saturating_sub(3);

        todo!("Decode variable length slice of length: _data_len into route_data");
    }
}

/// Loose Source Routing (LSRR)
///
/// ...
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct LooseSourceRoute<'a> {
    ///
    pub pointer: u8,
    ///
    pub route_data: &'a [u8],
}

impl<'a> LooseSourceRoute<'a> {
    ///
    pub const TYPE: Type = Type::LooseSourceRoute;

    fn encoded_len(&self) -> usize {
        3 + self.route_data.len()
    }
}

impl<'a> Codec for LooseSourceRoute<'a> {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        Self::TYPE.encode(writer, ())?;
        (self.encoded_len() as u8).encode(writer, ())?;
        self.pointer.encode(writer, ())?;

        todo!("Encode variable length slice: self.route_data");
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        if Type::decode(reader, ())? != Self::TYPE {
            return Err(BufError::UnexpectedValue);
        }
        let length = u8::decode(reader, ())?;
        let _pointer = u8::decode(reader, ())?;
        let _data_len = length.saturating_sub(3);

        todo!("Decode variable length slice of length: _data_len into route_data");
    }
}

/// Strict Source Routing (SSRR)
///
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct StrictSourceRoute<'a> {
    ///
    pub pointer: u8,
    ///
    pub route_data: &'a [u8],
}

impl<'a> StrictSourceRoute<'a> {
    ///
    pub const TYPE: Type = Type::StrictSourceRoute;

    fn encoded_len(&self) -> usize {
        3 + self.route_data.len()
    }
}

impl<'a> Codec for StrictSourceRoute<'a> {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        Self::TYPE.encode(writer, ())?;
        (self.encoded_len() as u8).encode(writer, ())?;
        self.pointer.encode(writer, ())?;

        todo!("Encode variable length slice: self.route_data");
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        if Type::decode(reader, ())? != Self::TYPE {
            return Err(BufError::UnexpectedValue);
        }
        let length = u8::decode(reader, ())?;
        let _pointer = u8::decode(reader, ())?;
        let _data_len = length.saturating_sub(3);

        todo!("Decode variable length slice of length: _data_len into route_data");
    }
}

/// Internet Timestamp (TS)
///
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct InternetTimestamp<'a> {
    ///
    pub pointer: u8,
    ///
    pub overflow_and_flags: u8,
    ///
    pub data: &'a [u8],
}

impl<'a> InternetTimestamp<'a> {
    ///
    pub const TYPE: Type = Type::InternetTimestamp;

    fn encoded_len(&self) -> usize {
        4 + self.data.len() // 1 (kind) + 1 (length) + 1 (pointer) + 1 (oflw+flg) + data
    }
}

impl<'a> Codec for InternetTimestamp<'a> {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        Self::TYPE.encode(writer, ())?;
        (self.encoded_len() as u8).encode(writer, ())?;
        self.pointer.encode(writer, ())?;
        self.overflow_and_flags.encode(writer, ())?;

        todo!("Encode variable length slice: self.data");
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        if Type::decode(reader, ())? != Self::TYPE {
            return Err(BufError::UnexpectedValue);
        }
        let length = u8::decode(reader, ())?;
        let _pointer = u8::decode(reader, ())?;
        let _overflow_and_flags = u8::decode(reader, ())?;
        let _data_len = length.saturating_sub(4);

        todo!("Decode variable length slice of length: _data_len into data");
    }
}

/// Stream ID (SID)
///
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct StreamId {
    ///
    pub id: u16,
}

impl StreamId {
    ///
    pub const TYPE: Type = Type::StreamId;
}

impl Codec for StreamId {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        Self::TYPE.encode(writer, ())?;
        4u8.encode(writer, ())?; // length (must be 4)
        self.id.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        if Type::decode(reader, ())? != Self::TYPE {
            return Err(BufError::UnexpectedValue);
        }
        let _length = u8::decode(reader, ())?;
        Ok(Self {
            id: u16::decode(reader, ())?,
        })
    }
}

/// Security (SEC)
///
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Security<'a> {
    ///
    pub data: &'a [u8],
}

impl<'a> Security<'a> {
    ///
    pub const TYPE: Type = Type::Security;

    fn encoded_len(&self) -> usize {
        2 + self.data.len()
    }
}

impl<'a> Codec for Security<'a> {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        Self::TYPE.encode(writer, ())?;
        (self.encoded_len() as u8).encode(writer, ())?;

        todo!("Encode variable length slice: self.data");
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        if Type::decode(reader, ())? != Self::TYPE {
            return Err(BufError::UnexpectedValue);
        }
        let length = u8::decode(reader, ())?;
        let _data_len = length.saturating_sub(2);

        todo!("Decode variable length slice of length: _data_len into data");
    }
}

#[cfg(test)]
mod tests {
    #[test]
    fn test() {}
}