- Updated to new repo

src/main/java/org/openautonomousconnection/protocol/ProtocolBridge.java

@@ -0,0 +1,159 @@
+package org.openautonomousconnection.protocol;
+
+import org.openautonomousconnection.protocol.listeners.ClientListener;
+import org.openautonomousconnection.protocol.listeners.ServerListener;
+import org.openautonomousconnection.protocol.packets.OACPacket;
+import org.openautonomousconnection.protocol.packets.v1_0_0.beta.AuthPacket;
+import org.openautonomousconnection.protocol.packets.v1_0_0.beta.GetDestinationPacket;
+import org.openautonomousconnection.protocol.packets.v1_0_0.beta.UnsupportedClassicPacket;
+import org.openautonomousconnection.protocol.packets.v1_0_0.beta.ValidateDomainPacket;
+import org.openautonomousconnection.protocol.packets.v1_0_0.classic.Classic_DomainPacket;
+import org.openautonomousconnection.protocol.side.client.ProtocolClient;
+import org.openautonomousconnection.protocol.side.server.ProtocolServer;
+import org.openautonomousconnection.protocol.versions.ProtocolVersion;
+import org.openautonomousconnection.protocol.versions.v1_0_0.classic.ClassicHandlerClient;
+import org.openautonomousconnection.protocol.versions.v1_0_0.classic.ClassicHandlerServer;
+import org.openautonomousconnection.protocol.versions.v1_0_0.classic.Classic_ClientListener;
+import lombok.Getter;
+import lombok.Setter;
+import dev.unlegitdqrk.unlegitlibrary.utils.Logger;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+
+public class ProtocolBridge {
+
+    @Getter
+    private static ProtocolBridge instance;
+    @Getter
+    private final ProtocolSettings protocolSettings;
+    @Getter
+    private final ProtocolVersion protocolVersion;
+    @Getter
+    private final Logger logger;
+    @Getter
+    private ProtocolServer protocolServer;
+    @Getter
+    private ProtocolClient protocolClient;
+    @Getter
+    @Setter
+    private ClassicHandlerServer classicHandlerServer;
+    @Getter
+    @Setter
+    private ClassicHandlerClient classicHandlerClient;
+
+    public ProtocolBridge(ProtocolServer protocolServer, ProtocolSettings protocolSettings, ProtocolVersion protocolVersion, File logFolder) throws InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchMethodException {
+        this.protocolServer = protocolServer;
+        this.protocolSettings = protocolSettings;
+        this.protocolVersion = protocolVersion;
+
+        Logger tmpLogger = null;
+        try {
+            tmpLogger = new Logger(logFolder, false, true);
+        } catch (IOException | NoSuchFieldException | IllegalAccessException exception) {
+            exception.printStackTrace();
+            tmpLogger = null;
+            System.exit(1);
+        }
+
+        this.logger = tmpLogger;
+        protocolSettings.eventManager.registerListener(new ServerListener());
+        protocolSettings.eventManager.unregisterListener(new ClientListener());
+
+        if (!validateProtocolSide()) {
+            this.logger.error("Invalid protocol version '" + protocolVersion.toString() + "'!");
+            System.exit(1);
+        }
+
+        if (isClassicSupported()) protocolSettings.eventManager.unregisterListener(new Classic_ClientListener());
+        registerPackets();
+
+        instance = this;
+    }
+
+    public ProtocolBridge(ProtocolClient protocolClient, ProtocolSettings protocolSettings, ProtocolVersion protocolVersion, File logFolder) throws InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchMethodException {
+        this.protocolClient = protocolClient;
+        this.protocolSettings = protocolSettings;
+        this.protocolVersion = protocolVersion;
+
+        Logger tmpLogger = null;
+        try {
+            tmpLogger = new Logger(logFolder, false, true);
+        } catch (IOException | NoSuchFieldException | IllegalAccessException exception) {
+            exception.printStackTrace();
+            tmpLogger = null;
+            System.exit(1);
+        }
+
+        this.logger = tmpLogger;
+        protocolSettings.eventManager.registerListener(new ClientListener());
+        protocolSettings.eventManager.unregisterListener(new ServerListener());
+
+        if (!validateProtocolSide()) {
+            this.logger.error("Invalid protocol version '" + protocolVersion.toString() + "'!");
+            System.exit(1);
+        }
+
+        if (isClassicSupported()) protocolSettings.eventManager.registerListener(new Classic_ClientListener());
+        registerPackets();
+
+        instance = this;
+    }
+
+    private void registerPackets() {
+        // Classic packets
+        Classic_DomainPacket cDomainPacket = new Classic_DomainPacket();
+        Classic_DomainPacket cMessagePacket = new Classic_DomainPacket();
+        Classic_DomainPacket cPingPacket = new Classic_DomainPacket();
+
+        if (isPacketSupported(cDomainPacket)) protocolSettings.packetHandler.registerPacket(cDomainPacket);
+        if (isPacketSupported(cMessagePacket)) protocolSettings.packetHandler.registerPacket(cMessagePacket);
+        if (isPacketSupported(cPingPacket)) protocolSettings.packetHandler.registerPacket(cPingPacket);
+
+        // 1.0.0-BETA packets
+        AuthPacket v100bAuthPath = new AuthPacket();
+        UnsupportedClassicPacket v100bUnsupportedClassicPacket = new UnsupportedClassicPacket();
+        ValidateDomainPacket v100bValidateDomainPacket = new ValidateDomainPacket();
+        GetDestinationPacket v100bGetDestinationPacket = new GetDestinationPacket();
+
+        if (isPacketSupported(v100bAuthPath)) protocolSettings.packetHandler.registerPacket(v100bAuthPath);
+        if (isPacketSupported(v100bUnsupportedClassicPacket))
+            protocolSettings.packetHandler.registerPacket(v100bUnsupportedClassicPacket);
+        if (isPacketSupported(v100bValidateDomainPacket))
+            protocolSettings.packetHandler.registerPacket(v100bValidateDomainPacket);
+        if (isPacketSupported(v100bGetDestinationPacket))
+            protocolSettings.packetHandler.registerPacket(v100bGetDestinationPacket);
+    }
+
+    public boolean isPacketSupported(OACPacket packet) {
+        return isVersionSupported(packet.getProtocolVersion());
+    }
+
+    public boolean isClassicSupported() {
+        boolean yes = false;
+        for (ProtocolVersion compatibleVersion : protocolVersion.getCompatibleVersions()) {
+            yes = compatibleVersion.getProtocolType() == ProtocolVersion.ProtocolType.CLASSIC;
+            if (yes) break;
+        }
+
+        return protocolVersion.getProtocolType() == ProtocolVersion.ProtocolType.CLASSIC || yes;
+    }
+
+    public boolean isRunningAsServer() {
+        return protocolServer != null;
+    }
+
+    public boolean isRunningAsClient() {
+        return protocolClient != null;
+    }
+
+    private boolean validateProtocolSide() {
+        return (isRunningAsServer() && protocolVersion.getProtocolSide() != ProtocolVersion.ProtocolSide.CLIENT) ||
+                (isRunningAsClient() && protocolVersion.getProtocolSide() != ProtocolVersion.ProtocolSide.SERVER);
+    }
+
+    public boolean isVersionSupported(ProtocolVersion targetVersion) {
+        return protocolVersion == targetVersion || protocolVersion.getCompatibleVersions().contains(targetVersion);
+    }
+}