class="kw">package com.hypixel.hytale.builtin.hytalegenerator.plugin;

class="kw">import com.hypixel.hytale.builtin.hytalegenerator.engine.chunkgenerator.ChunkRequest;
class="kw">import it.unimi.dsi.fastutil.ints.IntArrayList;
class="kw">import it.unimi.dsi.fastutil.ints.IntList;
class="kw">import java.util.ArrayList;
class="kw">import java.util.List;
class="kw">import java.util.concurrent.BlockingDeque;
class="kw">import java.util.concurrent.LinkedBlockingDeque;
class="kw">import java.util.concurrent.locks.Condition;
class="kw">import java.util.concurrent.locks.ReentrantLock;
class="kw">import javax.annotation.Nonnull;

class="kw">public class RequestQueue {
   class="kw">private class="kw">static class="kw">final int QUEUE_CAPACITY = 5;
   @Nonnull
   class="kw">private class="kw">final BlockingDeque<ChunkRequest> queue = new LinkedBlockingDeque<>();
   @Nonnull
   class="kw">private class="kw">final List<ChunkRequest> pool = new ArrayList<>();
   @Nonnull
   class="kw">private class="kw">final ReentrantLock lock = new ReentrantLock();
   @Nonnull
   class="kw">private class="kw">final Condition notEmpty = this.lock.newCondition();
   class="kw">private boolean shutdown = false;
   @Nonnull
   class="kw">private class="kw">final List<RequestQueue.Entry> rEntryBuffer = new ArrayList<>(6);
   @Nonnull
   class="kw">private class="kw">final List<ChunkRequest> rRequestBuffer;
   @Nonnull
   class="kw">private class="kw">final IntList rIndexBuffer = new IntArrayList(5);

   class="kw">public RequestQueue() {
      this.rRequestBuffer = new ArrayList<>();
   }

   class="kw">public void submit(@Nonnull ChunkRequest var1) {
      List var2 = List.of();
      this.lock.lock();

      try {
         if (this.shutdown || !isStillNeeded(var1)) {
            var2 = List.of(var1);
            class="kw">return;
         }

         if (!this.queue.isEmpty() || !this.pool.isEmpty()) {
            if (this.queue.isEmpty()) {
               this.pool.add(var1);
               var2 = this.fillQueue();
               class="kw">return;
            }

            if (this.insertInQueue(var1)) {
               class="kw">return;
            }

            this.pool.add(var1);
            class="kw">return;
         }

         this.queue.add(var1);
         this.notEmpty.signal();
      } class="kw">finally {
         this.lock.unlock();
         completeAll(var2);
      }
   }

   @Nonnull
   class="kw">public ChunkRequest takeFirst() class="kw">throws InterruptedException {
      boolean var3;
      do {
         ChunkRequest var2 = null;
         var3 = false;
         this.lock.lock();

         List var1;
         try {
            var1 = this.fillQueue();
            if (!this.queue.isEmpty()) {
               var2 = this.queue.takeFirst();
            } else if (this.shutdown) {
               var3 = true;
            } else if (var1.isEmpty()) {
               this.notEmpty.await();
            }
         } class="kw">finally {
            this.lock.unlock();
         }

         completeAll(var1);
         if (var2 != null) {
            class="kw">return var2;
         }
      } while (!var3);

      throw new InterruptedException();
   }

   class="kw">public void shutdownRequestsFromProfile(@Nonnull ChunkRequest.GeneratorProfile var1) {
      List var2 = new ArrayList<>();
      this.lock.lock();

      try {
         while (!this.queue.isEmpty()) {
            this.pool.add(this.queue.removeFirst());
         }

         for (int var3 = this.pool.size() - 1; var3 >= 0; var3--) {
            ChunkRequest var4 = this.pool.get(var3);
            if (var4.generatorProfile() == var1) {
               this.pool.remove(var3);
               var2.add(var4);
            }
         }
      } class="kw">finally {
         this.lock.unlock();
      }

      completeAll(var2);
   }

   class="kw">public void shutdown() {
      List var1 = new ArrayList<>(this.queue.size() + this.pool.size());
      this.lock.lock();

      try {
         this.shutdown = true;
         var1.addAll(this.queue);
         var1.addAll(this.pool);
         this.queue.clear();
         this.pool.clear();
         this.notEmpty.signalAll();
      } class="kw">finally {
         this.lock.unlock();
      }

      completeAll(var1);
   }

   class="kw">private boolean insertInQueue(@Nonnull ChunkRequest var1) {
      ChunkRequest var2 = this.queue.peekFirst();
      ChunkRequest var3 = this.queue.peekLast();
      float var4 = getDistanceSqr(var1);
      float var5 = getDistanceSqr(var2);
      float var6 = getDistanceSqr(var3);
      if (var4 < var5) {
         if (this.queue.size() == 5) {
            this.pool.add(this.queue.removeLast());
         }

         this.queue.addFirst(var1);
         class="kw">return true;
      } else {
         if (!(var4 < var6)) {
            class="kw">return false;
         }

         this.rRequestBuffer.clear();

         while (!this.queue.isEmpty()) {
            this.rRequestBuffer.add(this.queue.removeFirst());
         }

         for (int var7 = 0; var7 < this.rRequestBuffer.size(); var7++) {
            float var8 = getDistanceSqr(this.rRequestBuffer.get(var7));
            if (var8 > var4) {
               if (this.rRequestBuffer.size() == 5) {
                  this.pool.add(this.rRequestBuffer.removeLast());
               }

               this.rRequestBuffer.add(var7, var1);

               for (int var9 = 0; var9 < this.rRequestBuffer.size(); var9++) {
                  this.queue.addLast(this.rRequestBuffer.get(var9));
               }

               this.rRequestBuffer.clear();
               class="kw">return true;
            }
         }

         for (int var10 = 0; var10 < this.rRequestBuffer.size(); var10++) {
            this.queue.addLast(this.rRequestBuffer.get(var10));
         }

         this.rRequestBuffer.clear();
         class="kw">return false;
      }
   }

   class="kw">private void trimBuffer() {
      if (this.rEntryBuffer.size() > 5) {
         while (this.rEntryBuffer.size() > 5) {
            this.rEntryBuffer.removeLast();
         }
      }
   }

   @Nonnull
   class="kw">private List<ChunkRequest> fillQueue() {
      if (this.queue.isEmpty() && !this.pool.isEmpty()) {
         this.rEntryBuffer.clear();
         this.rIndexBuffer.clear();

         for (int var1 = 0; var1 < this.pool.size(); var1++) {
            ChunkRequest var2 = this.pool.get(var1);
            float var3 = getDistanceSqr(var2);
            if (var2.arguments().stillNeeded() != null && !var2.arguments().stillNeeded().test(var2.arguments().index())) {
               this.rIndexBuffer.add(var1);
            } else if (this.rEntryBuffer.isEmpty()) {
               this.rEntryBuffer.add(toEntry(var2, var1));
               this.trimBuffer();
            } else {
               float var4 = this.rEntryBuffer.getFirst().distance();
               if (var4 > var3) {
                  this.rEntryBuffer.addFirst(toEntry(var2, var1));
                  this.trimBuffer();
               } else {
                  float var5 = this.rEntryBuffer.getLast().distance();
                  if (this.rEntryBuffer.size() < 5 || !(var5 <= var3)) {
                     if (this.rEntryBuffer.size() < 5 && var5 <= var3) {
                        this.rEntryBuffer.addLast(toEntry(var2, var1));
                        this.trimBuffer();
                     } else if (var4 <= var3 && var5 > var3) {
                        for (int var6 = 1; var6 < this.rEntryBuffer.size(); var6++) {
                           if (this.rEntryBuffer.get(var6).distance() > var3) {
                              this.rEntryBuffer.add(var6, toEntry(var2, var1));
                              this.trimBuffer();
                              break;
                           }
                        }
                     }
                  }
               }
            }
         }

         List var7 = this.rIndexBuffer.isEmpty() ? List.of() : new ArrayList<>(this.rIndexBuffer.size());

         for (int var8 = 0; var8 < this.rIndexBuffer.size(); var8++) {
            var7.add(this.pool.get(this.rIndexBuffer.getInt(var8)));
         }

         for (int var9 = 0; var9 < this.rEntryBuffer.size(); var9++) {
            RequestQueue.Entry var11 = this.rEntryBuffer.get(var9);
            this.queue.addLast(var11.request());
            this.rIndexBuffer.add(var11.index());
         }

         if (!this.queue.isEmpty()) {
            this.notEmpty.signalAll();
         }

         this.rIndexBuffer.sort(null);

         for (int var10 = this.rIndexBuffer.size() - 1; var10 >= 0; var10--) {
            this.pool.remove(this.rIndexBuffer.getInt(var10));
         }

         this.rIndexBuffer.clear();
         this.rEntryBuffer.clear();
         class="kw">return var7;
      } else {
         class="kw">return List.of();
      }
   }

   class="kw">private class="kw">static float getDistanceSqr(@Nonnull ChunkRequest var0) {
      ChunkRequest.Arguments var1 = var0.arguments();
      class="kw">return var1.priority() == null ? 1.0F : var1.priority().get(var1.index());
   }

   class="kw">private class="kw">static boolean isStillNeeded(@Nonnull ChunkRequest var0) {
      long var1 = var0.arguments().index();
      class="kw">return var0.arguments().stillNeeded() == null || var0.arguments().stillNeeded().test(var1);
   }

   @Nonnull
   class="kw">private class="kw">static RequestQueue.Entry toEntry(@Nonnull ChunkRequest var0, int var1) {
      class="kw">return new RequestQueue.Entry(var0, getDistanceSqr(var0), var1);
   }

   class="kw">private class="kw">static void completeAll(@Nonnull List<ChunkRequest> var0) {
      for (int var1 = 0; var1 < var0.size(); var1++) {
         var0.get(var1).getFutureGeneratedChunk().complete(null);
      }
   }

   class="kw">private record Entry(@Nonnull ChunkRequest request, float distance, int index) {
      class="kw">private Entry {
      }
   }
}