✨ V2 (#1)

* 🚧 WIP v2.

Signed-off-by: 秋雨落 <i@rain.cx>

* 🚧 WIP v2 * 2.

Signed-off-by: 秋雨落 <i@rain.cx>

* ✨ It works?

Signed-off-by: 秋雨落 <i@rain.cx>

* ✨ Publish to nexus.

Signed-off-by: 秋雨落 <i@rain.cx>

---------

Signed-off-by: 秋雨落 <i@rain.cx>

CrystalConnector.Protocol/Packets/C2S/AuthenticatePacket.cs

@@ -0,0 +1,53 @@
+using CrystalConnector.Protocol.Messages;
+using Google.Protobuf;
+
+namespace CrystalConnector.Protocol.Packets.C2S;
+
+public class AuthenticatePacket : IPacket
+{
+    public NamespacedName ClientId { get; set; }
+    public string ClientName { get; set; }
+    public string Key { get; set; }
+    
+    public List<Channel> Channels { get; } = [];
+    
+    public AuthenticatePacket(NamespacedName clientId, string clientName, string key, List<Channel> channels)
+    {
+        ClientId = clientId;
+        ClientName = clientName;
+        Key = key;
+        Channels.AddRange(channels);
+    }
+    
+    public AuthenticatePacket(byte[] bytes)
+    {
+        Read(bytes);
+    }
+    
+    public AuthenticatePacket()
+    {
+    }
+    
+    public void Read(byte[] bytes)
+    {
+        var message = Authenticate.Parser.ParseFrom(bytes);
+        
+        ClientId = message.ClientId;
+        ClientName = message.ClientName;
+        Key = message.SecretKey;
+        Channels.AddRange(message.Channels);
+    }
+
+    public byte[] Write()
+    {
+        var message = new Authenticate
+        {
+            ClientId = ClientId,
+            ClientName = ClientName,
+            SecretKey = Key
+        };
+        message.Channels.AddRange(Channels);
+        
+        return message.ToByteArray();
+    }
+}

CrystalConnector.Protocol/Packets/C2S/PublishPacket.cs

@@ -0,0 +1,43 @@
+using CrystalConnector.Protocol.Messages;
+using Google.Protobuf;
+
+namespace CrystalConnector.Protocol.Packets.C2S;
+
+public class PublishPacket : IPacket
+{
+    public NamespacedName Channel { get; set; }
+    public string Payload { get; set; }
+    
+    public PublishPacket(NamespacedName channel, string payload)
+    {
+        Channel = channel;
+        Payload = payload;
+    }
+    
+    public PublishPacket(byte[] bytes)
+    {
+        Read(bytes);
+    }
+
+    public PublishPacket()
+    {
+    }
+    
+    public void Read(byte[] bytes)
+    {
+        var message = Publish.Parser.ParseFrom(bytes);
+        Channel = message.Channel;
+        Payload = message.Payload;
+    }
+
+    public byte[] Write()
+    {
+        var message = new Publish
+        {
+            Channel = Channel,
+            Payload = Payload
+        };
+
+        return message.ToByteArray();
+    }
+}

CrystalConnector.Protocol/Packets/IPacket.cs

@@ -0,0 +1,50 @@
+using CrystalConnector.Protocol.Packets.C2S;
+using CrystalConnector.Protocol.Packets.S2C;
+using Google.Protobuf;
+
+namespace CrystalConnector.Protocol.Packets;
+
+public interface IPacket
+{
+    public void Read(byte[] bytes);
+
+    public byte[] Write();
+
+    public static IPacket? From(byte[] data)
+    {
+        var result = TryForm<AuthenticatePacket>(data);
+        if (result is not null)
+        {
+            return result;
+        }
+        
+        result = TryForm<PublishPacket>(data);
+        if (result is not null)
+        {
+            return result;
+        }
+        
+        result = TryForm<ForwardPacket>(data);
+        if (result is not null)
+        {
+            return result;
+        }
+        
+        result = TryForm<ResultPacket>(data);
+        return result;
+    }
+
+    private static IPacket? TryForm<T>(byte[] data) where T : IPacket, new()
+    {
+        try
+        {
+            var message = new T();
+            message.Read(data);
+            return message;
+        }
+        catch (InvalidProtocolBufferException ex)
+        {
+            return null;
+        }
+    }
+}

CrystalConnector.Protocol/Packets/S2C/ForwardPacket.cs

@@ -0,0 +1,51 @@
+using CrystalConnector.Protocol.Messages;
+using Google.Protobuf;
+
+namespace CrystalConnector.Protocol.Packets.S2C;
+
+public class ForwardPacket : IPacket
+{
+    public string Publisher { get; set; }
+    public NamespacedName Channel { get; set; }
+    public string Payload { get; set; }
+
+    public ForwardPacket(string publisher, (string Namespace, string Name) channel, string payload)
+    {
+        Publisher = publisher;
+        Channel = new NamespacedName
+        {
+            Namespace = channel.Namespace,
+            Name = channel.Name
+        };
+        Payload = payload;
+    }
+    
+    public ForwardPacket(byte[] bytes)
+    {
+        Read(bytes);
+    }
+
+    public ForwardPacket()
+    {
+    }
+    
+    public void Read(byte[] bytes)
+    {
+        var message = Forward.Parser.ParseFrom(bytes);
+        Publisher = message.Publisher;
+        Channel = message.Channel;
+        Payload = message.Payload;
+    }
+
+    public byte[] Write()
+    {
+        var message = new Forward
+        {
+            Publisher = Publisher,
+            Channel = Channel,
+            Payload = Payload
+        };
+        
+        return message.ToByteArray();
+    }
+}

CrystalConnector.Protocol/Packets/S2C/ResultPacket.cs

@@ -0,0 +1,59 @@
+using CrystalConnector.Protocol.Messages;
+using Google.Protobuf;
+
+namespace CrystalConnector.Protocol.Packets.S2C;
+
+public class ResultPacket : IPacket
+{
+    public Result.ResultOneofCase ResultOneofCase { get; set; }
+    public Error? Error { get; set; }
+    
+    public ResultPacket()
+    {
+        ResultOneofCase = Result.ResultOneofCase.Successful;
+    }
+    
+    public ResultPacket(Error error)
+    {
+        ResultOneofCase = Result.ResultOneofCase.Error;
+        Error = error;
+    }
+    
+    public ResultPacket(byte[] bytes)
+    {
+        Read(bytes);
+    }
+    
+    public void Read(byte[] bytes)
+    {
+        var message = Result.Parser.ParseFrom(bytes);
+        ResultOneofCase = message.ResultCase;
+
+        if (message.HasError)
+        {
+            Error = message.Error;
+        }
+    }
+
+    public byte[] Write()
+    {
+        var message = ResultOneofCase switch
+        {
+            Result.ResultOneofCase.None => new Result
+            {
+                Error = Messages.Error.Unknown
+            },
+            Result.ResultOneofCase.Successful => new Result
+            {
+                Successful = new Successful()
+            },
+            Result.ResultOneofCase.Error => new Result
+            {
+                Error = Error!.Value
+            },
+            _ => throw new ArgumentOutOfRangeException()
+        };
+
+        return message.ToByteArray();
+    }
+}