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

pub mod packet_mapper;
pub mod types;

pub use packet_mapper::{PacketMapper, PacketMapperSwitch, PacketSwitch};
use serde::de::{MapAccess, Visitor};
use serde::{de, Deserialize, Deserializer};
use serde_json::Value;
use std::borrow::Cow;
use std::fmt;
pub use types::{BitField, NativeType, PacketDataType, PacketDataTypes};

#[derive(Deserialize, Debug, Clone)]
pub struct Protocol {
    pub types: PacketDataTypes,
    pub handshaking: PacketGrouping,
    pub status: PacketGrouping,
    pub login: PacketGrouping,
    pub play: PacketGrouping,
}

#[derive(Deserialize, Debug, Clone)]
pub struct PacketGrouping {
    #[serde(rename = "toServer")]
    pub to_server: PacketTypes,
    #[serde(rename = "toClient")]
    pub to_client: PacketTypes,
}

#[derive(Debug, Clone)]
pub enum DataTypeReference {
    Simple(String),
    Complex { name: String, properties: Value },
}

impl From<DataTypeReference> for PacketDataType {
    fn from(val: DataTypeReference) -> Self {
        let (name, properties) = match val {
            DataTypeReference::Simple(simple) => (simple, Value::Null),
            DataTypeReference::Complex { name, properties } => (name, properties),
        };

        PacketDataType::new(name.as_str(), Cow::Borrowed(&properties))
            .or_else(|| {
                let option = NativeType::new(name.as_str(), Cow::Borrowed(&properties));
                option.map(PacketDataType::Native)
            })
            .unwrap_or_else(|| PacketDataType::Other {
                name: Some(name.into()),
                value: properties,
            })
    }
}

#[derive(Debug, Clone)]
pub struct Packet {
    pub name: String,
    pub data: PacketDataType,
}

#[derive(Debug, Clone)]
pub struct PacketTypes {
    pub packet_mapper: PacketMapperSwitch,
    pub types: Vec<Packet>,
}

impl<'de> Deserialize<'de> for PacketTypes {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct PacketTypesVisitor;

        impl<'de> Visitor<'de> for PacketTypesVisitor {
            type Value = PacketTypes;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("Expected a map")
            }

            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
            where
                A: MapAccess<'de>,
            {
                while let Some(key) = map.next_key::<String>()? {
                    if key.eq("types") {
                        let mut packets = Vec::new();
                        let mut packet_mapper = None;
                        let value = map.next_value::<Value>()?;

                        if let Value::Object(obj) = value {
                            for (key, value) in obj.into_iter() {
                                if key.eq("packet") {
                                    if let Value::Array(mut array) = value {
                                        let value = array.pop().ok_or_else(|| {
                                            de::Error::missing_field("missing content")
                                        })?;
                                        let value: PacketMapperSwitch =
                                            serde_json::from_value(value)
                                                .map_err(de::Error::custom)?;
                                        packet_mapper = Some(value);
                                    } else {
                                        return Err(de::Error::custom("Invalid Packet Mapper"));
                                    }
                                } else if let Value::Array(array) = value {
                                    let value1 = Value::Array(vec![
                                        Value::String(key.clone()),
                                        Value::Array(array),
                                    ]);
                                    let inner_type = types::build_inner_type(value1);
                                    packets.push(Packet {
                                        name: key,
                                        data: *inner_type,
                                    });
                                } else {
                                    return Err(de::Error::custom(format!(
                                        "Invalid Packet  Expected Array {}",
                                        key
                                    )));
                                }
                            }
                        }

                        let packet_mapper = packet_mapper
                            .ok_or_else(|| de::Error::missing_field("packet_mapper"))?;
                        return Ok(PacketTypes {
                            packet_mapper,
                            types: packets,
                        });
                    }
                }
                Err(de::Error::custom("Expected a types"))
            }
        }

        deserializer.deserialize_map(PacketTypesVisitor)
    }
}