class="kw">package com.hypixel.hytale.server.worldgen.util.cache;

class="kw">import com.hypixel.hytale.server.core.HytaleServer;
class="kw">import java.lang.ref.WeakReference;
class="kw">import java.lang.ref.Cleaner.Cleanable;
class="kw">import java.util.Iterator;
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.function.BiConsumer;
class="kw">import java.util.function.Function;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class TimeoutCache<K, V> class="kw">implements Cache<K, V> {
   class="kw">private class="kw">final Map<K, TimeoutCache.CacheEntry<V>> map = new ConcurrentHashMap<>();
   class="kw">private class="kw">final long timeout;
   @Nonnull
   class="kw">private class="kw">final Function<K, V> func;
   @Nullable
   class="kw">private class="kw">final BiConsumer<K, V> destroyer;
   @Nonnull
   class="kw">private class="kw">final ScheduledFuture<?> future;
   @Nonnull
   class="kw">private class="kw">final Cleanable cleanable;

   class="kw">public TimeoutCache(long var1, @Nonnull TimeUnit var3, @Nonnull Function<K, V> var4, @Nullable BiConsumer<K, V> var5) {
      this.timeout = var3.toNanos(var1);
      this.func = var4;
      this.destroyer = var5;
      this.future = HytaleServer.SCHEDULED_EXECUTOR.scheduleWithFixedDelay(new CleanupRunnable(new WeakReference<>(this)), var1, var1, var3);
      this.cleanable = CleanupFutureAction.CLEANER.register(this, new CleanupFutureAction(this.future));
   }

   @Override
   class="kw">public void cleanup() {
      long var1 = System.nanoTime() - this.timeout;

      for (Entry var4 : this.map.entrySet()) {
         TimeoutCache.CacheEntry var5 = var4.getValue();
         if (var5.timestamp < var1) {
            Object var6 = var4.getKey();
            if (this.map.remove(var6, var4.getValue()) && this.destroyer != null) {
               this.destroyer.accept(var6, var5.value);
            }
         }
      }
   }

   @Override
   class="kw">public void shutdown() {
      this.cleanable.clean();
      Iterator var1 = this.map.entrySet().iterator();

      while (var1.hasNext()) {
         Entry var2 = var1.next();
         Object var3 = var2.getKey();
         TimeoutCache.CacheEntry var4 = var2.getValue();
         if (this.map.remove(var3, var4)) {
            var1.remove();
            if (this.destroyer != null) {
               this.destroyer.accept(var3, var4.value);
            }
         }
      }
   }

   @Override
   class="kw">public V get(K var1) {
      if (this.future.isCancelled()) {
         throw new IllegalStateException("Cache has been shutdown!");
      }

      TimeoutCache.CacheEntry var2 = this.map.compute(var1, (var1x, var2x) -> {
         if (var2x != null) {
            var2x.timestamp = System.nanoTime();
            class="kw">return var2x;
         } else {
            class="kw">return new TimeoutCache.CacheEntry<>(this.func.apply((K)var1x));
         }
      });
      class="kw">return var2.value;
   }

   class="kw">private class="kw">static class CacheEntry<V> {
      class="kw">private class="kw">final V value;
      class="kw">private long timestamp;

      class="kw">public CacheEntry(V var1) {
         this.value = var1;
         this.timestamp = System.nanoTime();
      }
   }
}