1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
use super::message_ops::Sealed;
use super::{Message, MessageKind, MessageOps};
use crate::error::{DeserializeError, SerializeError};
use crate::message_deserializer::{MessageDeserializeError, MessageWithValueDeserializer};
use crate::message_serializer::{MessageSerializeError, MessageSerializer};
use crate::serialized_value::{SerializedValue, SerializedValueSlice};
use crate::value_deserializer::{Deserialize, Deserializer};
use crate::value_serializer::{Serialize, Serializer};
use bytes::BytesMut;
use num_enum::{IntoPrimitive, TryFromPrimitive};

#[derive(Debug, Clone, PartialEq, Eq, Default)]
#[cfg_attr(feature = "fuzzing", derive(arbitrary::Arbitrary))]
pub struct ConnectData {
    pub user: Option<SerializedValue>,
}

impl ConnectData {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn serialize_user<T: Serialize + ?Sized>(
        &mut self,
        user: &T,
    ) -> Result<&mut Self, SerializeError> {
        self.user = SerializedValue::serialize(user).map(Some)?;
        Ok(self)
    }

    pub fn deserialize_user<T: Deserialize>(&self) -> Option<Result<T, DeserializeError>> {
        self.user.as_deref().map(SerializedValueSlice::deserialize)
    }
}

#[derive(IntoPrimitive, TryFromPrimitive)]
#[repr(u32)]
enum ConnectDataField {
    User = 0,
}

impl Serialize for ConnectData {
    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
        let mut serializer = serializer.serialize_struct(1)?;
        serializer.serialize_field(ConnectDataField::User, &self.user)?;
        serializer.finish()
    }
}

impl Deserialize for ConnectData {
    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
        let mut deserializer = deserializer.deserialize_struct()?;

        let mut user = None;

        while deserializer.has_more_fields() {
            let deserializer = deserializer.deserialize_field()?;

            let Ok(field) = deserializer.try_id() else {
                deserializer.skip()?;
                continue;
            };

            match field {
                ConnectDataField::User => user = deserializer.deserialize()?,
            }
        }

        deserializer.finish(Self { user })
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "fuzzing", derive(arbitrary::Arbitrary))]
pub struct Connect2 {
    pub major_version: u32,
    pub minor_version: u32,
    pub value: SerializedValue,
}

impl Connect2 {
    pub fn with_serialize_data(
        major_version: u32,
        minor_version: u32,
        data: &ConnectData,
    ) -> Result<Self, SerializeError> {
        let value = SerializedValue::serialize(data)?;

        Ok(Self {
            major_version,
            minor_version,
            value,
        })
    }

    pub fn deserialize_connect_data(&self) -> Result<ConnectData, DeserializeError> {
        self.value.deserialize()
    }
}

impl MessageOps for Connect2 {
    fn kind(&self) -> MessageKind {
        MessageKind::Connect2
    }

    fn serialize_message(self) -> Result<BytesMut, MessageSerializeError> {
        let mut serializer = MessageSerializer::with_value(self.value, MessageKind::Connect2)?;

        serializer.put_varint_u32_le(self.major_version);
        serializer.put_varint_u32_le(self.minor_version);

        serializer.finish()
    }

    fn deserialize_message(buf: BytesMut) -> Result<Self, MessageDeserializeError> {
        let mut deserializer = MessageWithValueDeserializer::new(buf, MessageKind::Connect2)?;

        let major_version = deserializer.try_get_varint_u32_le()?;
        let minor_version = deserializer.try_get_varint_u32_le()?;
        let value = deserializer.finish()?;

        Ok(Self {
            major_version,
            minor_version,
            value,
        })
    }

    fn value(&self) -> Option<&SerializedValueSlice> {
        Some(&self.value)
    }
}

impl Sealed for Connect2 {}

impl From<Connect2> for Message {
    fn from(msg: Connect2) -> Self {
        Self::Connect2(msg)
    }
}

#[cfg(test)]
mod test {
    use super::super::test::{assert_deserialize_eq_with_value, assert_serialize_eq};
    use super::super::Message;
    use super::{Connect2, ConnectData};

    #[test]
    fn connect() {
        let serialized = [15, 0, 0, 0, 46, 4, 0, 0, 0, 39, 1, 0, 0, 1, 2];
        let value = ConnectData::new();

        let msg = Connect2::with_serialize_data(1, 2, &value).unwrap();
        assert_serialize_eq(&msg, serialized);
        assert_deserialize_eq_with_value(&msg, serialized, &value);

        let msg = Message::Connect2(msg);
        assert_serialize_eq(&msg, serialized);
        assert_deserialize_eq_with_value(&msg, serialized, &value);
    }
}