internet 0.0.5

//! LABEL
//!
//! > description

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

/// A Frame Types following [Section 12.4].
///
/// The `Type` field values of all frames.
///
/// [Section 12.4](https://datatracker.ietf.org/doc/html/rfc9000#section-12.4).
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u64)]
pub enum FrameType {
    /// (PADDING frame)[PaddingFrame].
    Padding = 0x00,

    /// (PING frame)[PaddingFrame].
    Ping = 0x01,

    /// (PING frame)[PaddingFrame].
    Ack = 0x02,

    /// (PING frame)[PaddingFrame].
    ResetStream = 0x04,

    /// (PING frame)[PaddingFrame].
    StopSending = 0x05,

    /// (PING frame)[PaddingFrame].
    Crypto = 0x06,

    /// (PING frame)[PaddingFrame].
    NewToken = 0x07,

    /// (PING frame)[PaddingFrame].
    Stream = 0x08,

    /// The (MAX_DATA frame)[MaxDataFrame].
    MaxData = 0x10,

    /// The (MaxStreamData frame)[MaxStreamDataFrame].
    MaxStreamData = 0x11,

    /// The (MaxStreams frame)[MaxStreamsFrame].
    MaxStreams = 0x12,

    /// The (DataBlocked frame)[DataBlockedFrame].
    DataBlocked = 0x14,

    /// The (StreamDataBlocked frame)[StreamDataBlockedFrame].
    StreamDataBlocked = 0x15,

    /// The (StreamsBlocked frame)[StreamsBlockedFrame].
    StreamsBlocked = 0x16,

    /// The (NewConnectionId frame)[NewConnectionIdFrame].
    NewConnectionId = 0x18,

    /// The (RetireConnectionId frame)[RetireConnectionIdFrame].
    RetireConnectionId = 0x19,

    /// The (PathChallenge frame)[PathChallengeFrame].
    PathChallenge = 0x1a,

    /// The (PathResponse frame)[PathResponseFrame].
    PathResponse = 0x1b,

    /// The (ConnectionClose frame)[ConnectionCloseFrame].
    ConnectionClose = 0x1c,

    /// The (HandshakeDone frame)[HandshakeDoneFrame].
    HandshakeDone = 0x1e,
}

impl Codec for FrameType {
    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::Padding as u8) => Ok(Self::Padding),
            _ => Err(BufError::UnexpectedValue),
        }
    }
}

/// A frame following [Section 7.1].
///
/// > descrption
///
/// [Section 7.1]: https://datatracker.ietf.org/doc/html/rfc9114#section-7.1
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Frame {
    ///
    pub r#type: VarInt,
    ///
    pub frame_payload: Vec<u8>,
}

impl Codec for Frame {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        self.r#type.encode(writer, ())?;
        self.frame_payload.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        let r#type = VarInt::decode(reader, ())?;
        let _length = VarInt::decode(reader, ())?;
        let frame_payload = Vec::decode(reader, ())?;
        Ok(Self {
            r#type,
            frame_payload,
        })
    }
}

/// A DATA frame following [Section 7.2.1].
///
/// > descrption
///
/// [Section 7.2.1]: https://datatracker.ietf.org/doc/html/rfc9114#section-7.2.1
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct DataFrame {
    ///
    pub r#type: VarInt,
    ///
    pub frame_payload: Vec<u8>,
}

impl Codec for DataFrame {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        self.r#type.encode(writer, ())?;
        self.frame_payload.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        let r#type = VarInt::decode(reader, ())?;
        let _length = VarInt::decode(reader, ())?;
        let frame_payload = Vec::decode(reader, ())?;
        Ok(Self {
            r#type,
            frame_payload,
        })
    }
}

/// A HEADERS frame following [Section 7.2.2].
///
/// > descrption
///
/// [Section 7.2.2]: https://datatracker.ietf.org/doc/html/rfc9114#section-7.2.2
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct HeadersFrame {
    ///
    pub r#type: VarInt,
    ///
    pub frame_payload: Vec<u8>,
}

impl Codec for HeadersFrame {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        self.r#type.encode(writer, ())?;
        self.frame_payload.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        let r#type = VarInt::decode(reader, ())?;
        let _length = VarInt::decode(reader, ())?;
        let frame_payload = Vec::decode(reader, ())?;
        Ok(Self {
            r#type,
            frame_payload,
        })
    }
}

/// A CANCEL_PUSH frame following [Section 7.2.3].
///
/// > descrption
///
/// [Section 7.2.3]: https://datatracker.ietf.org/doc/html/rfc9114#section-7.2.3
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct CancelPush {
    ///
    pub r#type: VarInt,
    ///
    pub frame_payload: Vec<u8>,
}

impl Codec for CancelPush {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        self.r#type.encode(writer, ())?;
        self.frame_payload.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        let r#type = VarInt::decode(reader, ())?;
        let _length = VarInt::decode(reader, ())?;
        let frame_payload = Vec::decode(reader, ())?;
        Ok(Self {
            r#type,
            frame_payload,
        })
    }
}

/// A SETTINGS frame following [Section 7.2.4].
///
/// > descrption
///
/// [Section 7.2.4]: https://datatracker.ietf.org/doc/html/rfc9114#section-7.2.4
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct SettingsFrame {
    ///
    pub r#type: VarInt,
    ///
    pub frame_payload: Vec<u8>,
}

impl Codec for SettingsFrame {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        self.r#type.encode(writer, ())?;
        self.frame_payload.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        let r#type = VarInt::decode(reader, ())?;
        let _length = VarInt::decode(reader, ())?;
        let frame_payload = Vec::decode(reader, ())?;
        Ok(Self {
            r#type,
            frame_payload,
        })
    }
}

/// A PUSH_PROMISE frame following [Section 7.2.5].
///
/// > descrption
///
/// [Section 7.2.5]: https://datatracker.ietf.org/doc/html/rfc9114#section-7.2.5
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct PushPromise {
    ///
    pub r#type: VarInt,
    ///
    pub frame_payload: Vec<u8>,
}

impl Codec for PushPromise {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        self.r#type.encode(writer, ())?;
        self.frame_payload.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        let r#type = VarInt::decode(reader, ())?;
        let _length = VarInt::decode(reader, ())?;
        let frame_payload = Vec::decode(reader, ())?;
        Ok(Self {
            r#type,
            frame_payload,
        })
    }
}

/// A GOAWAY frame following [Section 7.2.6].
///
/// > descrption
///
/// [Section 7.2.6]: https://datatracker.ietf.org/doc/html/rfc9114#section-7.2.6
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Goaway {
    ///
    pub r#type: VarInt,
    ///
    pub frame_payload: Vec<u8>,
}

impl Codec for Goaway {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        self.r#type.encode(writer, ())?;
        self.frame_payload.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        let r#type = VarInt::decode(reader, ())?;
        let _length = VarInt::decode(reader, ())?;
        let frame_payload = Vec::decode(reader, ())?;
        Ok(Self {
            r#type,
            frame_payload,
        })
    }
}

/// A MAX_PUSH_ID frame following [Section 7.2.7].
///
/// > descrption
///
/// [Section 7.2.7]: https://datatracker.ietf.org/doc/html/rfc9114#section-7.2.7
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct MaxPushId {
    ///
    pub r#type: VarInt,
    ///
    pub frame_payload: Vec<u8>,
}

impl Codec for MaxPushId {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        self.r#type.encode(writer, ())?;
        self.frame_payload.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        let r#type = VarInt::decode(reader, ())?;
        let _length = VarInt::decode(reader, ())?;
        let frame_payload = Vec::decode(reader, ())?;
        Ok(Self {
            r#type,
            frame_payload,
        })
    }
}

/// Error Codes of the [CONNECTION_CLOSE frame] by [Section 8.1].
///
/// > description
///
/// [CONNECTION_CLOSE frame]: ConnectionCloseFrame
/// [Section 8.1]: https://datatracker.ietf.org/doc/html/rfc9114#section-8.1
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u64)]
pub enum ErrorCode {
    /// NO_ERROR 0x00: No error
    /// [Section 8.1](https://datatracker.ietf.org/doc/html/rfc9114#section-8.1)
    H3NoError = 0x0100,

    /// INTERNAL_ERROR 0x01: Implementation error
    /// [Section 8.1](https://datatracker.ietf.org/doc/html/rfc9114#section-8.1)
    H3GeneralProtocolError = 0x0101,

    /// CONNECTION_REFUSED 0x02: Server refuses a connection
    /// [Section 8.1](https://datatracker.ietf.org/doc/html/rfc9114#section-8.1)
    H3InternalError = 0x0102,

    /// FLOW_CONTROL_ERROR 0x03: Flow control error
    /// [Section 8.1](https://datatracker.ietf.org/doc/html/rfc9114#section-8.1)
    FlowControlError = 0x0103,

    /// STREAM_LIMIT_ERROR 0x04: Too many streams opened
    /// [Section 8.1](https://datatracker.ietf.org/doc/html/rfc9114#section-8.1)
    StreamLimitError = 0x0104,

    /// STREAM_STATE_ERROR 0x05: Frame received in invalid stream state
    /// [Section 8.1](https://datatracker.ietf.org/doc/html/rfc9114#section-8.1)
    StreamStateError = 0x0105,

    /// FINAL_SIZE_ERROR 0x06: Change to final size
    /// [Section 8.1](https://datatracker.ietf.org/doc/html/rfc9114#section-8.1)
    FinalSizeError = 0x0106,

    /// FRAME_ENCODING_ERROR 0x07: Frame encoding error
    /// [Section 8.1](https://datatracker.ietf.org/doc/html/rfc9114#section-8.1)
    FrameEncodingError = 0x0107,

    /// TRANSPORT_PARAMETER_ERROR 0x08: Error in transport parameters
    /// [Section 8.1](https://datatracker.ietf.org/doc/html/rfc9114#section-8.1)
    TransportParameterError = 0x0108,

    /// CONNECTION_ID_LIMIT_ERROR 0x09: Too many connection IDs received
    /// [Section 8.1](https://datatracker.ietf.org/doc/html/rfc9114#section-8.1)
    ConnectionIdLimitError = 0x0109,

    /// PROTOCOL_VIOLATION 0x0a: Generic protocol violation
    /// [Section 8.1](https://datatracker.ietf.org/doc/html/rfc9114#section-8.1)
    ProtocolViolation = 0x010a,

    /// INVALID_TOKEN 0x0b: Invalid Token received
    /// [Section 8.1](https://datatracker.ietf.org/doc/html/rfc9114#section-8.1)
    InvalidToken = 0x010b,

    /// APPLICATION_ERROR 0x0c: Application error
    /// [Section 8.1](https://datatracker.ietf.org/doc/html/rfc9114#section-8.1)
    ApplicationError = 0x010c,

    /// CRYPTO_BUFFER_EXCEEDED 0x0d: CRYPTO data buffer overflowed
    /// [Section 8.1](https://datatracker.ietf.org/doc/html/rfc9114#section-8.1)
    CryptoBufferExceeded = 0x010d,

    /// KEY_UPDATE_ERROR 0x0e: Invalid packet protection update
    /// [Section 8.1](https://datatracker.ietf.org/doc/html/rfc9114#section-8.1)
    KeyUpdateError = 0x010e,

    /// AEAD_LIMIT_REACHED 0x0f: Excessive use of packet protection keys
    /// [Section 8.1](https://datatracker.ietf.org/doc/html/rfc9114#section-8.1)
    AeadLimitReached = 0x010f,

    /// NO_VIABLE_PATH 0x10: No viable network path exists
    /// [Section 8.1](https://datatracker.ietf.org/doc/html/rfc9114#section-8.1)
    NoViablePath = 0x0110,
}

impl From<ErrorCode> for VarInt {
    fn from(value: ErrorCode) -> Self {
        Self(value as u64)
    }
}

impl TryFrom<VarInt> for ErrorCode {
    type Error = BufError;

    fn try_from(value: VarInt) -> Result<Self, Self::Error> {
        Self::try_from(value.into_inner())
    }
}

impl From<ErrorCode> for u64 {
    fn from(value: ErrorCode) -> Self {
        value as u64
    }
}

impl TryFrom<u64> for ErrorCode {
    type Error = BufError;

    fn try_from(value: u64) -> Result<Self, Self::Error> {
        match value {
            x if x == Self::H3NoError as u64 => Ok(Self::H3NoError),
            x if x == Self::H3GeneralProtocolError as u64 => Ok(Self::H3GeneralProtocolError),
            x if x == Self::H3InternalError as u64 => Ok(Self::H3InternalError),
            x if x == Self::FlowControlError as u64 => Ok(Self::FlowControlError),
            x if x == Self::StreamLimitError as u64 => Ok(Self::StreamLimitError),
            x if x == Self::StreamStateError as u64 => Ok(Self::StreamStateError),
            x if x == Self::FinalSizeError as u64 => Ok(Self::FinalSizeError),
            x if x == Self::FrameEncodingError as u64 => Ok(Self::FrameEncodingError),
            x if x == Self::TransportParameterError as u64 => Ok(Self::TransportParameterError),
            x if x == Self::ConnectionIdLimitError as u64 => Ok(Self::ConnectionIdLimitError),
            x if x == Self::ProtocolViolation as u64 => Ok(Self::ProtocolViolation),
            x if x == Self::InvalidToken as u64 => Ok(Self::InvalidToken),
            x if x == Self::ApplicationError as u64 => Ok(Self::ApplicationError),
            x if x == Self::CryptoBufferExceeded as u64 => Ok(Self::CryptoBufferExceeded),
            x if x == Self::KeyUpdateError as u64 => Ok(Self::KeyUpdateError),
            x if x == Self::AeadLimitReached as u64 => Ok(Self::AeadLimitReached),
            x if x == Self::NoViablePath as u64 => Ok(Self::NoViablePath),
            _ => Err(BufError::UnexpectedValue),
        }
    }
}

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