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

class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.sneakythrow.SneakyThrow;
class="kw">import java.util.List;
class="kw">import java.util.concurrent.CompletableFuture;
class="kw">import java.util.concurrent.TimeUnit;
class="kw">import java.util.function.Consumer;
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 AsyncEventBusRegistry<KeyType, EventType class="kw">extends IAsyncEvent<KeyType>>
   class="kw">extends EventBusRegistry<KeyType, EventType, AsyncEventBusRegistry.AsyncEventConsumerMap<EventType>> {
   @Nonnull
   class="kw">private class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   @Nonnull
   class="kw">public class="kw">static class="kw">final IEventDispatcher NO_OP = new IEventDispatcher<IAsyncEvent, CompletableFuture<IAsyncEvent>>() {
      @Override
      class="kw">public boolean hasListener() {
         class="kw">return false;
      }

      @Nonnull
      class="kw">public CompletableFuture<IAsyncEvent> dispatch(IAsyncEvent var1) {
         class="kw">return CompletableFuture.completedFuture(var1);
      }
   };
   @Nonnull
   class="kw">private class="kw">final IEventDispatcher<EventType, CompletableFuture<EventType>> globalDispatcher = var1x -> {
      CompletableFuture var2 = CompletableFuture.completedFuture(var1x);
      CompletableFuture var3 = var2;
      var2 = this.dispatchGlobal(var2);
      if (var3 == var2) {
         var2 = this.dispatchUnhandled(var2);
      }

      class="kw">return var2;
   };

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

   @Nonnull
   class="kw">public EventRegistration<KeyType, EventType> registerAsync(
      short var1, @Nonnull KeyType var2, @Nonnull Function<CompletableFuture<EventType>, CompletableFuture<EventType>> var3
   ) {
      class="kw">return this.registerAsync0(var1, var2, var3, var3.toString());
   }

   @Nonnull
   class="kw">private EventRegistration<KeyType, EventType> registerAsync0(
      short var1, @Nullable KeyType var2, @Nonnull Function<CompletableFuture<EventType>, CompletableFuture<EventType>> var3, @Nonnull String var4
   ) {
      if (this.shutdown) {
         class="kw">return this.deadRegistration("register");
      }

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

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

   @Nonnull
   class="kw">public EventRegistration<KeyType, EventType> registerAsyncGlobal(
      short var1, @Nonnull Function<CompletableFuture<EventType>, CompletableFuture<EventType>> var2
   ) {
      class="kw">return this.registerAsyncGlobal0(var1, var2, var2.toString());
   }

   @Nonnull
   class="kw">private EventRegistration<KeyType, EventType> registerAsyncGlobal0(
      short var1, @Nonnull Function<CompletableFuture<EventType>, CompletableFuture<EventType>> var2, @Nonnull String var3
   ) {
      if (this.shutdown) {
         class="kw">return this.deadRegistration("registerGlobal");
      }

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

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

   @Nonnull
   class="kw">public EventRegistration<KeyType, EventType> registerAsyncUnhandled(
      short var1, @Nonnull Function<CompletableFuture<EventType>, CompletableFuture<EventType>> var2
   ) {
      class="kw">return this.registerAsyncUnhandled0(var1, var2, var2.toString());
   }

   @Nonnull
   class="kw">private EventRegistration<KeyType, EventType> registerAsyncUnhandled0(
      short var1, @Nonnull Function<CompletableFuture<EventType>, CompletableFuture<EventType>> var2, @Nonnull String var3
   ) {
      if (this.shutdown) {
         class="kw">return this.deadRegistration("registerUnhandled");
      }

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

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

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

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

   class="kw">private CompletableFuture<EventType> dispatchEventMap(
      @Nonnull CompletableFuture<EventType> var1, @Nonnull AsyncEventBusRegistry.AsyncEventConsumerMap<EventType> var2, @Nonnull String var3
   ) {
      for (short var7 : var2.getPriorities()) {
         List var8 = var2.get(var7);
         if (var8 != null) {
            for (AsyncEventBusRegistry.AsyncEventConsumer var10 : var8) {
               try {
                  Function var11 = this.timeEvents ? var10.getTimedFunction() : var10.getFunction();
                  var1 = var11.apply(var1).whenComplete((var3x, var4) -> {
                     if (var3x class="kw">instanceof IProcessedEvent var5) {
                        var5.processEvent(var10.getConsumerString());
                     }

                     if (var4 != null) {
                        ((HytaleLogger.Api)this.logger.at(Level.SEVERE).withCause(var4)).log("%s %s to %s", var3, var3x, var10);
                     }
                  });
               } catch (Throwable var12) {
                  ((HytaleLogger.Api)this.logger.at(Level.SEVERE).withCause(var12)).log("%s %s to %s", var3, var1, var10);
               }
            }
         }
      }

      class="kw">return var1;
   }

   @Nonnull
   @Override
   class="kw">public EventRegistration<KeyType, EventType> register(short var1, KeyType var2, @Nonnull Consumer<EventType> var3) {
      class="kw">return this.registerAsync0(var1, var2, var1x -> var1x.thenApply(var1xx -> {
         var3.accept((EventType)var1xx);
         class="kw">return (EventType)var1xx;
      }), var3.toString());
   }

   @Nonnull
   @Override
   class="kw">public EventRegistration<KeyType, EventType> registerGlobal(short var1, @Nonnull Consumer<EventType> var2) {
      class="kw">return this.registerAsyncGlobal0(var1, var1x -> var1x.thenApply(var1xx -> {
         var2.accept((EventType)var1xx);
         class="kw">return (EventType)var1xx;
      }), var2.toString());
   }

   @Nonnull
   @Override
   class="kw">public EventRegistration<KeyType, EventType> registerUnhandled(short var1, @Nonnull Consumer<EventType> var2) {
      class="kw">return this.registerAsyncUnhandled0(var1, var1x -> var1x.thenApply(var1xx -> {
         var2.accept((EventType)var1xx);
         class="kw">return (EventType)var1xx;
      }), var2.toString());
   }

   @Nonnull
   @Override
   class="kw">public IEventDispatcher<EventType, CompletableFuture<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);
         AsyncEventBusRegistry.AsyncEventConsumerMap 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">protected class="kw">static class AsyncEventConsumer<EventType class="kw">extends IAsyncEvent> class="kw">extends EventBusRegistry.EventConsumer {
      @Nonnull
      class="kw">private class="kw">final Function<CompletableFuture<EventType>, CompletableFuture<EventType>> function;
      @Nonnull
      class="kw">private class="kw">final Function<CompletableFuture<EventType>, CompletableFuture<EventType>> timedFunction;

      class="kw">public AsyncEventConsumer(short var1, @Nonnull String var2, @Nonnull Function<CompletableFuture<EventType>, CompletableFuture<EventType>> var3) {
         super(var1, var2);
         this.function = var3;
         this.timedFunction = var2x -> {
            long var3 = System.nanoTime();
            class="kw">return var3.apply(var2x).whenComplete((var3x, var4) -> {
               long var5 = System.nanoTime();
               this.timer.add(var5 - var3);
               if (var4 != null) {
                  throw SneakyThrow.sneakyThrow(var4);
               }
            });
         };
      }

      @Nonnull
      class="kw">public Function<CompletableFuture<EventType>, CompletableFuture<EventType>> getFunction() {
         class="kw">return this.function;
      }

      @Nonnull
      class="kw">public Function<CompletableFuture<EventType>, CompletableFuture<EventType>> getTimedFunction() {
         class="kw">return this.timedFunction;
      }

      @Nonnull
      @Override
      class="kw">public String toString() {
         class="kw">return "AsyncEventConsumer{function=" + this.function + ", timedFunction=" + this.timedFunction + "} " + super.toString();
      }
   }

   class="kw">protected class="kw">static class AsyncEventConsumerMap<EventType class="kw">extends IAsyncEvent>
      class="kw">extends EventBusRegistry.EventConsumerMap<EventType, AsyncEventBusRegistry.AsyncEventConsumer<EventType>, CompletableFuture<EventType>> {
      class="kw">protected AsyncEventBusRegistry registry;

      class="kw">public AsyncEventConsumerMap(AsyncEventBusRegistry var1) {
         this.registry = var1;
      }

      @Nonnull
      class="kw">public CompletableFuture<EventType> dispatch(EventType var1) {
         class="kw">return CompletableFuture.completedFuture(var1).thenComposeAsync(this::dispatch0);
      }

      class="kw">private CompletableFuture<EventType> dispatch0(EventType var1) {
         CompletableFuture var2 = CompletableFuture.completedFuture(var1);
         CompletableFuture var3 = var2;
         var2 = this.registry.dispatchEventMap(var2, this, "Failed to dispatch event");
         CompletableFuture var4 = var2;
         var2 = this.registry.dispatchGlobal(var2);
         if (var4 == var2 && var3 == var4) {
            var2 = this.registry.dispatchUnhandled(var2);
         }

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