class="kw">package com.hypixel.hytale.server.core.io;

class="kw">import com.hypixel.hytale.common.plugin.PluginManifest;
class="kw">import com.hypixel.hytale.common.util.CompletableFutureUtil;
class="kw">import com.hypixel.hytale.common.util.FormatUtil;
class="kw">import com.hypixel.hytale.common.util.NetworkUtil;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.logger.sentry.SkipSentryException;
class="kw">import com.hypixel.hytale.protocol.io.ServerListener;
class="kw">import com.hypixel.hytale.server.core.Constants;
class="kw">import com.hypixel.hytale.server.core.HytaleServer;
class="kw">import com.hypixel.hytale.server.core.Options;
class="kw">import com.hypixel.hytale.server.core.event.events.ShutdownEvent;
class="kw">import com.hypixel.hytale.server.core.io.commands.BindingsCommand;
class="kw">import com.hypixel.hytale.server.core.io.handlers.IPacketHandler;
class="kw">import com.hypixel.hytale.server.core.io.handlers.SubPacketHandler;
class="kw">import com.hypixel.hytale.server.core.io.handlers.game.GamePacketHandler;
class="kw">import com.hypixel.hytale.server.core.io.handlers.game.InventoryPacketHandler;
class="kw">import com.hypixel.hytale.server.core.io.ice.IceModule;
class="kw">import com.hypixel.hytale.server.core.io.transport.QUICTransport;
class="kw">import com.hypixel.hytale.server.core.io.transport.QuicheTransport;
class="kw">import com.hypixel.hytale.server.core.io.transport.Transport;
class="kw">import com.hypixel.hytale.server.core.io.transport.TransportType;
class="kw">import com.hypixel.hytale.server.core.modules.camera.CameraSequencePacketHandler;
class="kw">import com.hypixel.hytale.server.core.plugin.JavaPlugin;
class="kw">import com.hypixel.hytale.server.core.plugin.JavaPluginInit;
class="kw">import com.hypixel.hytale.server.core.universe.Universe;
class="kw">import com.hypixel.hytale.sneakythrow.SneakyThrow;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrayList;
class="kw">import it.unimi.dsi.fastutil.objects.ReferenceArrayList;
class="kw">import java.net.InetAddress;
class="kw">import java.net.InetSocketAddress;
class="kw">import java.net.SocketException;
class="kw">import java.net.UnknownHostException;
class="kw">import java.util.Collections;
class="kw">import java.util.List;
class="kw">import java.util.concurrent.CompletableFuture;
class="kw">import java.util.concurrent.CopyOnWriteArrayList;
class="kw">import java.util.concurrent.ExecutionException;
class="kw">import java.util.concurrent.TimeUnit;
class="kw">import java.util.concurrent.TimeoutException;
class="kw">import java.util.function.Function;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class ServerManager class="kw">extends JavaPlugin {
   class="kw">public class="kw">static class="kw">final PluginManifest MANIFEST = PluginManifest.corePlugin(ServerManager.class).build();
   @Nonnull
   class="kw">private class="kw">static class="kw">final NetworkUtil.AddressType[] NON_PUBLIC_ADDRESS_TYPES = new NetworkUtil.AddressType[]{
      NetworkUtil.AddressType.ANY_LOCAL,
      NetworkUtil.AddressType.LOOPBACK,
      NetworkUtil.AddressType.SITE_LOCAL,
      NetworkUtil.AddressType.LINK_LOCAL,
      NetworkUtil.AddressType.MULTICAST
   };
   class="kw">private class="kw">static ServerManager instance;
   @Nonnull
   class="kw">private class="kw">final List<ServerListener> listeners = new CopyOnWriteArrayList<>();
   @Nonnull
   class="kw">private class="kw">final List<Function<IPacketHandler, SubPacketHandler>> subPacketHandlers = new ObjectArrayList();
   @Nullable
   class="kw">private Transport transport;
   @Nullable
   class="kw">private CompletableFuture<Void> registerFuture;
   @Nullable
   class="kw">private CompletableFuture<Void> bootFuture;

   class="kw">public class="kw">static ServerManager get() {
      class="kw">return instance;
   }

   class="kw">public ServerManager(@Nonnull JavaPluginInit var1) {
      super(var1);
      instance = this;
      if (!Options.isBare()) {
         this.init();
      }
   }

   class="kw">public void init() {
      this.registerFuture = CompletableFutureUtil._catch(CompletableFuture.runAsync(SneakyThrow.sneakyRunnable(() -> {
         long var1 = System.nanoTime();

         this.transport = class="kw">switch ((TransportType)Options.getOptionSet().valuesOf(Options.TRANSPORT).getFirst()) {
            case QUIC -> new QUICTransport();
            case QUICHE -> new QuicheTransport();
         };
         this.getLogger().at(Level.INFO).log("Took %s to setup transport!", FormatUtil.nanosToString(System.nanoTime() - var1));
         this.registerFuture = null;
      })));
   }

   @Override
   class="kw">protected void setup() {
      this.getEventRegistry().register((short)-40, ShutdownEvent.class, var1 -> {
         IceModule.shutdown();
         this.unbindAllListeners();
      });
      get().registerSubPacketHandlers(InventoryPacketHandler::new);
      get().registerSubPacketHandlers(CameraSequencePacketHandler::new);
      this.getCommandRegistry().registerCommand(new BindingsCommand());
   }

   @Override
   class="kw">protected void start() {
      this.bootFuture = CompletableFuture.<CompletableFuture[]>supplyAsync(() -> {
         CompletableFuture var1 = this.registerFuture;
         if (var1 != null) {
            var1.getNow(null);
         }

         if (HytaleServer.get().isShuttingDown()) {
            class="kw">return null;
         }

         ReferenceArrayList var2 = new ReferenceArrayList();
         if (Options.getOptionSet().has(Options.MIGRATIONS) || Options.isBare()) {
            class="kw">return (CompletableFuture[])var2.toArray(CompletableFuture[]::new);
         }

         if (Constants.SINGLEPLAYER) {
            try {
               InetAddress[] var3 = InetAddress.getAllByName("localhost");

               for (InetAddress var7 : var3) {
                  var2.add(this.bind(new InetSocketAddress(var7, ((InetSocketAddress)Options.getOptionSet().valueOf(Options.BIND)).getPort())));
               }

               class="kw">return (CompletableFuture[])var2.toArray(CompletableFuture[]::new);
            } catch (UnknownHostException var8) {
               throw SneakyThrow.sneakyThrow(var8);
            }
         } else {
            for (InetSocketAddress var10 : Options.getOptionSet().valuesOf(Options.BIND)) {
               var2.add(this.bind(var10));
            }

            class="kw">return (CompletableFuture[])var2.toArray(CompletableFuture[]::new);
         }
      }).thenCompose(var0 -> var0 == null ? CompletableFuture.completedFuture(null) : CompletableFuture.allOf(var0)).thenRun(() -> {
         if (this.listeners.isEmpty()) {
            throw new IllegalArgumentException("Listeners is empty after starting ServerManager!!");
         }

         this.bootFuture = null;
      });
   }

   @Override
   class="kw">protected void shutdown() {
      Universe.get().disconnectAllPLayers();
      this.unbindAllListeners();
      this.transport.shutdown();
      this.transport = null;
      this.getLogger().at(Level.INFO).log("Finished shutting down ServerManager...");
   }

   class="kw">public void unbindAllListeners() {
      for (ServerListener var2 : this.listeners) {
         this.unbind0(var2);
      }

      this.listeners.clear();
   }

   @Nonnull
   class="kw">public List<ServerListener> getListeners() {
      class="kw">return Collections.unmodifiableList(this.listeners);
   }

   class="kw">public CompletableFuture<Integer> bind(@Nonnull InetSocketAddress var1) {
      class="kw">return !var1.getAddress().isAnyLocalAddress()
         ? this.bind0(var1).thenApply(this::registerListener)
         : this.bind0(new InetSocketAddress(NetworkUtil.ANY_IPV6_ADDRESS, var1.getPort()))
            .thenCompose(
               var2 -> {
                  int var3 = this.registerListener(var2);
                  int var4 = var1.getPort() != 0 ? var1.getPort() : var3;
                  class="kw">return this.bind0(new InetSocketAddress(NetworkUtil.ANY_IPV4_ADDRESS, var4))
                     .thenCompose(
                        var2x -> {
                           int var3 = this.registerListener(var2x);
                           int var4 = var3 != 0 ? var3 : var3;
                           class="kw">return var4 == 0
                              ? CompletableFuture.completedFuture(0)
                              : this.bind0(new InetSocketAddress(NetworkUtil.LOOPBACK_IPV6_ADDRESS, var4)).thenApply(var2xx -> {
                                 this.registerListener(var2xx);
                                 class="kw">return var4;
                              });
                        }
                     );
               }
            );
   }

   class="kw">private int registerListener(@Nullable ServerListener var1) {
      if (var1 == null) {
         class="kw">return 0;
      }

      this.listeners.add(var1);
      class="kw">return var1.localAddress() class="kw">instanceof InetSocketAddress var2 ? var2.getPort() : 0;
   }

   class="kw">public boolean unbind(@Nonnull ServerListener var1) {
      boolean var2 = this.unbind0(var1);
      if (var2) {
         this.listeners.remove(var1);
      }

      class="kw">return var2;
   }

   @Nullable
   class="kw">public InetSocketAddress getLocalOrPublicAddress() class="kw">throws SocketException {
      for (ServerListener var2 : this.listeners) {
         if (var2.localAddress() class="kw">instanceof InetSocketAddress var4) {
            InetAddress var5 = var4.getAddress();
            if (var5.isLoopbackAddress()) {
               class="kw">return var4;
            }

            if (var5.isAnyLocalAddress()) {
               InetAddress var6 = NetworkUtil.getFirstNonLoopbackAddress();
               if (var6 == null) {
                  class="kw">return null;
               }

               class="kw">return new InetSocketAddress(var6, var4.getPort());
            }

            class="kw">return var4;
         }
      }

      class="kw">return null;
   }

   @Nullable
   class="kw">public InetSocketAddress getNonLoopbackAddress() class="kw">throws SocketException {
      for (ServerListener var2 : this.listeners) {
         if (var2.localAddress() class="kw">instanceof InetSocketAddress var4) {
            InetAddress var5 = var4.getAddress();
            if (!var5.isLoopbackAddress()) {
               if (var5.isAnyLocalAddress()) {
                  InetAddress var6 = NetworkUtil.getFirstNonLoopbackAddress();
                  if (var6 == null) {
                     class="kw">return null;
                  }

                  class="kw">return new InetSocketAddress(var6, var4.getPort());
               }

               class="kw">return var4;
            }
         }
      }

      class="kw">return null;
   }

   @Nullable
   class="kw">public InetSocketAddress getPublicAddress() class="kw">throws SocketException {
      for (ServerListener var2 : this.listeners) {
         if (var2.localAddress() class="kw">instanceof InetSocketAddress var4) {
            InetAddress var5 = var4.getAddress();
            if (!var5.isLoopbackAddress() && !var5.isSiteLocalAddress()) {
               if (var5.isAnyLocalAddress()) {
                  InetAddress var6 = NetworkUtil.getFirstAddressWithout(NON_PUBLIC_ADDRESS_TYPES);
                  if (var6 == null) {
                     class="kw">return null;
                  }

                  class="kw">return new InetSocketAddress(var6, var4.getPort());
               }

               class="kw">return var4;
            }
         }
      }

      class="kw">return null;
   }

   class="kw">public void waitForBindComplete() {
      CompletableFuture var1 = this.bootFuture;
      if (var1 != null) {
         var1.getNow(null);
      }
   }

   class="kw">public void registerSubPacketHandlers(@Nonnull Function<IPacketHandler, SubPacketHandler> var1) {
      this.subPacketHandlers.add(var1);
   }

   class="kw">public void populateSubPacketHandlers(@Nonnull GamePacketHandler var1) {
      for (Function var3 : this.subPacketHandlers) {
         var1.registerSubPacketHandler(var3.apply(var1));
      }
   }

   class="kw">private CompletableFuture<ServerListener> bind0(@Nonnull InetSocketAddress var1) {
      long var2 = System.nanoTime();
      this.getLogger().at(Level.FINE).log("Binding to %s (%s)", var1, this.transport.getType());
      class="kw">return this.transport.bind(var1).thenApply(var3 -> {
         this.getLogger().at(Level.INFO).log("Listening on %s and took %s", var3.localAddress(), FormatUtil.nanosToString(System.nanoTime() - var2));
         class="kw">return (ServerListener)var3;
      }).exceptionally(var2x -> {
         ((HytaleLogger.Api)this.getLogger().at(Level.SEVERE).withCause(new SkipSentryException(var2x))).log("Failed to bind to %s", var1);
         class="kw">return null;
      });
   }

   class="kw">private boolean unbind0(@Nonnull ServerListener var1) {
      long var2 = System.nanoTime();
      this.getLogger().at(Level.FINE).log("Closing listener %s", var1);

      try {
         var1.close().get(1L, TimeUnit.SECONDS);
         this.getLogger().at(Level.INFO).log("Closed listener %s and took %s", var1, FormatUtil.nanosToString(System.nanoTime() - var2));
         class="kw">return true;
      } catch (InterruptedException var5) {
         ((HytaleLogger.Api)this.getLogger().at(Level.SEVERE).withCause(var5)).log("Failed to await for listener to close!");
         Thread.currentThread().interrupt();
         class="kw">return false;
      } catch (ExecutionException | TimeoutException var6) {
         ((HytaleLogger.Api)this.getLogger().at(Level.SEVERE).withCause(var6)).log("Failed to await for listener to close!");
         class="kw">return false;
      }
   }
}