package net.minecraft.server;

// NeonPaper start
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import java.lang.ref.WeakReference;
import java.util.Iterator;
import java.util.List;
// NeonPaper end

public class IntCache {
    // NeonPaper start - Refactored IntCache to be thread local instead of static
    private static final ThreadLocal<IntCache> caches = new ThreadLocal<IntCache>() {
        @Override
        protected IntCache initialValue() {
            IntCache cache = new IntCache();
            synchronized (ALL_CACHES) {
                ALL_CACHES.add(new WeakReference<>(cache));
            }
            return new IntCache();
        }
    };

    private static final List<WeakReference<IntCache>> ALL_CACHES = new ObjectArrayList<>();

    private int a = 256;
    private final List<int[]> b = new ObjectArrayList<>();
    private final List<int[]> c = new ObjectArrayList<>();
    private final List<int[]> d = new ObjectArrayList<>();
    private final List<int[]> e = new ObjectArrayList<>();

    private final int cacheLimit = org.spigotmc.SpigotConfig.intCacheLimit;

    public static int[] a(int i) {
        return caches.get().aNonStatic(i);
    }

    public int[] aNonStatic(int i) {
        int[] aint;

        if (i <= 256) {
            if (this.b.isEmpty()) {
                aint = new int[256];
				if (c.size() < cacheLimit) this.c.add(aint);
                return aint;
            } else {
                aint = this.b.remove(this.b.size() - 1);
                if (c.size() < cacheLimit) this.c.add(aint);
                return aint;
            }
        } else if (i > this.a) {
            this.a = i;
            this.d.clear();
            this.e.clear();
            aint = new int[this.a];
            if (e.size() < cacheLimit) this.e.add(aint);
            return aint;
        } else if (this.d.isEmpty()) {
            aint = new int[this.a];
            if (e.size() < cacheLimit) this.e.add(aint);
            return aint;
        } else {
            aint = this.d.remove(this.d.size() - 1);
            if (e.size() < cacheLimit) this.e.add(aint);
            return aint;
        }
    }

    public static void a() {
        caches.get().aNonStatic();
    }

    public void aNonStatic() {
        if (!this.d.isEmpty()) {
            this.d.remove(this.d.size() - 1);
        }

        if (!this.b.isEmpty()) {
            this.b.remove(this.b.size() - 1);
        }

        this.d.addAll(this.e);
        this.b.addAll(this.c);
        this.e.clear();
        this.c.clear();
    }

    public static String b() {
        int cache = 0;
        int tcache = 0;
        int allocated = 0;
        int tallocated = 0;
        int numberOfCaches;

        synchronized (ALL_CACHES) {
            numberOfCaches = ALL_CACHES.size();
            Iterator<WeakReference<IntCache>> iter = ALL_CACHES.iterator();
            while (iter.hasNext()) {
                WeakReference<IntCache> reference = iter.next();
                IntCache intcache = reference.get();
                if (intcache != null) {
                    cache += intcache.d.size();
                    tcache += intcache.b.size();
                    allocated += intcache.e.size();
                    tallocated += intcache.c.size();
                } else {
                    iter.remove();
                }
            }
        }
        return numberOfCaches + " IntCaches. In Total => cache: " + cache + ", tcache: " + tcache + ", allocated: " + allocated + ", tallocated: " + tallocated;
    }
// NeonPaper end
}