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

class="kw">import com.hypixel.hytale.lib.quiche.QuicheListener;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.protocol.io.ServerListener;
class="kw">import com.hypixel.hytale.server.core.HytaleServer;
class="kw">import com.hypixel.hytale.server.core.io.ServerManager;
class="kw">import java.net.Inet6Address;
class="kw">import java.net.InetSocketAddress;
class="kw">import java.net.SocketAddress;
class="kw">import java.nio.ByteBuffer;
class="kw">import java.util.ArrayList;
class="kw">import java.util.List;
class="kw">import java.util.Map;
class="kw">import java.util.Map.Entry;
class="kw">import java.util.concurrent.ConcurrentHashMap;
class="kw">import java.util.concurrent.ScheduledFuture;
class="kw">import java.util.concurrent.TimeUnit;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class="kw">final class IceModule {
   class="kw">private class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   class="kw">private class="kw">static class="kw">final Map<QuicheListener, IceModule.Endpoint> ENDPOINTS = new ConcurrentHashMap<>();
   @Nullable
   class="kw">private class="kw">static ScheduledFuture<?> probeTask;
   class="kw">private class="kw">static class="kw">volatile boolean iceDisabledLogged;

   class="kw">private IceModule() {
   }

   class="kw">public class="kw">static boolean registerPeer(@Nonnull IceCredentials var0, @Nonnull IceCredentials var1, @Nonnull List<InetSocketAddress> var2) {
      if (!IceServerConfig.isIceEnabled()) {
         if (!iceDisabledLogged) {
            iceDisabledLogged = true;
            LOGGER.at(Level.WARNING).log("Refusing an ICE peer: the server has ICE disabled, so joiners cannot connect");
         }

         class="kw">return false;
      } else {
         iceDisabledLogged = false;
         boolean var3 = false;

         for (Entry var5 : activeEndpoints()) {
            List var6 = var2.stream().filter(var1x -> isIpv6(var5.getKey()) == (var1x.getAddress() class="kw">instanceof Inet6Address)).toList();
            if (var5.getValue().responder().addSession(var0, var1, var6)) {
               var3 = true;
            }
         }

         startProbing();
         if (!var3) {
            LOGGER.at(Level.WARNING).log("No quiche listener available for ICE; the host must use the client proxy");
         }

         class="kw">return var3;
      }
   }

   class="kw">public class="kw">static void unregisterPeer(@Nonnull String var0) {
      for (IceModule.Endpoint var2 : ENDPOINTS.values()) {
         var2.responder().removeSession(var0);
      }
   }

   class="kw">private class="kw">static class="kw">synchronized void startProbing() {
      if (probeTask == null || probeTask.isDone()) {
         long var0 = IceResponder.CHECK_INTERVAL.toMillis();
         probeTask = HytaleServer.SCHEDULED_EXECUTOR.scheduleWithFixedDelay(() -> {
            try {
               for (IceModule.Endpoint var1 : ENDPOINTS.values()) {
                  var1.responder().tick();
               }
            } catch (Exception var2) {
               ((HytaleLogger.Api)LOGGER.at(Level.WARNING).withCause(var2)).log("ICE probe tick failed");
            }
         }, var0, var0, TimeUnit.MILLISECONDS);
      }
   }

   class="kw">private class="kw">static class="kw">synchronized void stopProbing() {
      if (probeTask != null) {
         probeTask.cancel(false);
         probeTask = null;
      }
   }

   class="kw">private class="kw">static boolean isIpv6(QuicheListener var0) {
      class="kw">return var0.localAddress() class="kw">instanceof InetSocketAddress var1 && var1.getAddress() class="kw">instanceof Inet6Address;
   }

   class="kw">public class="kw">static void shutdown() {
      stopProbing();

      for (Entry var1 : ENDPOINTS.entrySet()) {
         var1.getKey().setStunHandler(null);
         var1.getValue().responder().clear();
      }

      ENDPOINTS.clear();
   }

   class="kw">private class="kw">static List<Entry<QuicheListener, IceModule.Endpoint>> activeEndpoints() {
      ServerManager var0 = ServerManager.get();
      if (var0 == null) {
         class="kw">return List.of();
      }

      List var1 = var0.getListeners();
      ENDPOINTS.keySet().removeIf(var1x -> !var1.contains(var1x));
      ArrayList var2 = new ArrayList<>();

      for (ServerListener var4 : var1) {
         if (var4 class="kw">instanceof QuicheListener var5) {
            var2.add(Map.entry(var5, ENDPOINTS.computeIfAbsent(var5, IceModule::attach)));
         }
      }

      class="kw">return var2;
   }

   class="kw">private class="kw">static IceModule.Endpoint attach(QuicheListener var0) {
      IceResponder var1 = new IceResponder((var1x, var2) -> send(var0, var1x, var2));
      var0.setStunHandler(var1::handleDatagram);
      LOGGER.at(Level.INFO).log("ICE responder attached to %s", var0.localAddress());
      class="kw">return new IceModule.Endpoint(var1);
   }

   class="kw">private class="kw">static void send(QuicheListener var0, @Nonnull ByteBuffer var1, @Nonnull SocketAddress var2) {
      try {
         var0.sendDatagram(var1, var2);
      } catch (Exception var4) {
         LOGGER.at(Level.FINE).log("Failed to send an ICE datagram to %s: %s", var2, var4.getMessage());
      }
   }

   class="kw">private record Endpoint(@Nonnull IceResponder responder) {
      class="kw">private Endpoint {
      }
   }
}