class="kw">package com.hypixel.hytale.event;

class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.logger.sentry.SkipSentryException;
class="kw">import java.util.List;
class="kw">import java.util.concurrent.TimeUnit;
class="kw">import java.util.function.Consumer;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class SyncEventBusRegistry<KeyType, EventType class="kw">extends IEvent<KeyType>>
   class="kw">extends EventBusRegistry<KeyType, EventType, SyncEventBusRegistry.SyncEventConsumerMap<EventType>> {
   class="kw">private class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   class="kw">public class="kw">static class="kw">final IEventDispatcher NO_OP = new IEventDispatcher<IBaseEvent, IBaseEvent>() {
      @Override
      class="kw">public boolean hasListener() {
         class="kw">return false;
      }

      class="kw">public IBaseEvent dispatch(IBaseEvent var1) {
         class="kw">return var1;
      }
   };
   class="kw">private class="kw">final IEventDispatcher<EventType, EventType> globalDispatcher = var1x -> {
      if (!this.dispatchGlobal(var1x)) {
         this.dispatchUnhandled(var1x);
      }

      class="kw">return var1x;
   };
   class="kw">private class="kw">static class="kw">final String THIRD_PARTY_CLASSLOADER_PREFIX = "ThirdParty";

   class="kw">public SyncEventBusRegistry(HytaleLogger var1, Class<EventType> var2) {
      super(var1, var2, new SyncEventBusRegistry.SyncEventConsumerMap<>(null), new SyncEventBusRegistry.SyncEventConsumerMap<>(null));
      this.global.registry = this.unhandled.registry = this;
   }

   @Nonnull
   @Override
   class="kw">public EventRegistration<KeyType, EventType> register(short var1, @Nullable KeyType var2, @Nonnull Consumer<EventType> var3) {
      if (this.shutdown) {
         class="kw">return this.deadRegistration("register");
      }

      Object var4 = (KeyType)(var2 != null ? var2 : NULL);
      SyncEventBusRegistry.SyncEventConsumerMap var5 = this.map.computeIfAbsent(var4, var1x -> new SyncEventBusRegistry.SyncEventConsumerMap<>(this));
      SyncEventBusRegistry.SyncEventConsumer var6 = new SyncEventBusRegistry.SyncEventConsumer<>(var1, var3);
      var5.add(var6);
      class="kw">return new EventRegistration<>(this.eventClass, this::isAlive, () -> this.unregister(var2, var6));
   }

   class="kw">private void unregister(@Nullable KeyType var1, @Nonnull SyncEventBusRegistry.SyncEventConsumer<EventType> var2) {
      if (!this.shutdown) {
         Object var3 = (KeyType)(var1 != null ? var1 : NULL);
         SyncEventBusRegistry.SyncEventConsumerMap var4 = this.map.get(var3);
         if (var4 != null && !var4.remove(var2)) {
            throw new IllegalArgumentException(String.valueOf(var2));
         }
      }
   }

   @Nonnull
   @Override
   class="kw">public EventRegistration<KeyType, EventType> registerGlobal(short var1, @Nonnull Consumer<EventType> var2) {
      if (this.shutdown) {
         class="kw">return this.deadRegistration("registerGlobal");
      }

      SyncEventBusRegistry.SyncEventConsumer var3 = new SyncEventBusRegistry.SyncEventConsumer<>(var1, var2);
      this.global.add(var3);
      class="kw">return new EventRegistration<>(this.eventClass, this::isAlive, () -> this.unregisterGlobal(var3));
   }

   class="kw">private void unregisterGlobal(@Nonnull SyncEventBusRegistry.SyncEventConsumer<EventType> var1) {
      if (!this.shutdown) {
         if (!this.global.remove(var1)) {
            throw new IllegalArgumentException(String.valueOf(var1));
         }
      }
   }

   @Nonnull
   @Override
   class="kw">public EventRegistration<KeyType, EventType> registerUnhandled(short var1, @Nonnull Consumer<EventType> var2) {
      if (this.shutdown) {
         class="kw">return this.deadRegistration("registerUnhandled");
      }

      SyncEventBusRegistry.SyncEventConsumer var3 = new SyncEventBusRegistry.SyncEventConsumer<>(var1, var2);
      this.unhandled.add(var3);
      class="kw">return new EventRegistration<>(this.eventClass, this::isAlive, () -> this.unregisterUnhandled(var3));
   }

   class="kw">private void unregisterUnhandled(@Nonnull SyncEventBusRegistry.SyncEventConsumer<EventType> var1) {
      if (!this.shutdown) {
         if (!this.unhandled.remove(var1)) {
            throw new IllegalArgumentException(String.valueOf(var1));
         }
      }
   }

   @Nonnull
   @Override
   class="kw">public IEventDispatcher<EventType, EventType> dispatchFor(@Nullable KeyType var1) {
      if (this.shutdown) {
         ((HytaleLogger.Api)LOGGER.at(Level.FINE).atMostEvery(1, TimeUnit.MINUTES))
            .log("Ignoring dispatchFor on shut-down EventRegistry for %s", this.eventClass.getName());
         class="kw">return NO_OP;
      } else {
         Object var2 = (KeyType)(var1 != null ? var1 : NULL);
         SyncEventBusRegistry.SyncEventConsumerMap var3 = this.map.get(var2);
         if (var3 != null && !var3.isEmpty()) {
            class="kw">return var3;
         } else {
            class="kw">return this.global.isEmpty() && this.unhandled.isEmpty() ? NO_OP : this.globalDispatcher;
         }
      }
   }

   class="kw">private boolean dispatchGlobal(EventType var1) {
      class="kw">return this.dispatchEventMap(var1, this.global, "Failed to dispatch event (global)");
   }

   class="kw">private boolean dispatchUnhandled(EventType var1) {
      class="kw">return this.dispatchEventMap(var1, this.unhandled, "Failed to dispatch event (unhandled)");
   }

   class="kw">private boolean dispatchEventMap(EventType var1, @Nonnull SyncEventBusRegistry.SyncEventConsumerMap<EventType> var2, String var3) {
      boolean var4 = false;

      for (short var8 : var2.getPriorities()) {
         List var9 = var2.get(var8);
         if (var9 != null) {
            for (SyncEventBusRegistry.SyncEventConsumer var11 : var9) {
               try {
                  Consumer var12 = this.timeEvents ? var11.getTimedConsumer() : var11.getConsumer();
                  var12.accept(var1);
                  if (var1 class="kw">instanceof IProcessedEvent var15) {
                     var15.processEvent(var11.getConsumerString());
                  }

                  var4 = true;
               } catch (Throwable var14) {
                  Throwable var13 = isThirdPartyConsumer(var11.getConsumer()) ? new SkipSentryException(var14) : var14;
                  ((HytaleLogger.Api)this.logger.at(Level.SEVERE).withCause(var13)).log("%s %s to %s", var3, var1, var11);
               }
            }
         }
      }

      class="kw">return var4;
   }

   class="kw">private class="kw">static boolean isThirdPartyConsumer(@Nonnull Consumer<?> var0) {
      ClassLoader var1 = var0.getClass().getClassLoader();
      class="kw">return var1 != null && var1.getName() != null && var1.getName().startsWith("ThirdParty");
   }

   class="kw">protected class="kw">static class SyncEventConsumer<EventType class="kw">extends IEvent> class="kw">extends EventBusRegistry.EventConsumer {
      @Nonnull
      class="kw">private class="kw">final Consumer<EventType> consumer;
      @Nonnull
      class="kw">private class="kw">final Consumer<EventType> timedConsumer;

      class="kw">public SyncEventConsumer(short var1, @Nonnull Consumer<EventType> var2) {
         super(var1, var2.toString());
         this.consumer = var2;
         this.timedConsumer = var2x -> {
            long var3 = System.nanoTime();
            var2.accept(var2x);
            long var5 = System.nanoTime();
            this.timer.add(var5 - var3);
         };
      }

      @Nonnull
      class="kw">protected Consumer<EventType> getConsumer() {
         class="kw">return this.consumer;
      }

      @Nonnull
      class="kw">public Consumer<EventType> getTimedConsumer() {
         class="kw">return this.timedConsumer;
      }

      @Nonnull
      @Override
      class="kw">public String toString() {
         class="kw">return "SyncEventConsumer{consumer=" + this.consumer + ", timedConsumer=" + this.timedConsumer + "} " + super.toString();
      }
   }

   class="kw">protected class="kw">static class SyncEventConsumerMap<EventType class="kw">extends IEvent>
      class="kw">extends EventBusRegistry.EventConsumerMap<EventType, SyncEventBusRegistry.SyncEventConsumer<EventType>, EventType> {
      class="kw">protected SyncEventBusRegistry registry;

      class="kw">public SyncEventConsumerMap(SyncEventBusRegistry var1) {
         this.registry = var1;
      }

      class="kw">public EventType dispatch(EventType var1) {
         boolean var2 = this.registry.dispatchEventMap(var1, this, "Failed to dispatch event");
         if (!this.registry.dispatchGlobal(var1) && !var2) {
            this.registry.dispatchUnhandled(var1);
         }

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