package c5;

import android.util.Log;
import androidx.annotation.Nullable;
import java.util.HashMap;
import java.util.NavigableMap;
import java.util.Queue;
import java.util.TreeMap;

/* JADX INFO: loaded from: classes.dex */
public final class k implements b {

    /* JADX INFO: renamed from: a, reason: collision with root package name */
    public final i f4885a = new i();

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    public final d f4886b = new d(1);

    /* JADX INFO: renamed from: c, reason: collision with root package name */
    public final HashMap f4887c = new HashMap();

    /* JADX INFO: renamed from: d, reason: collision with root package name */
    public final HashMap f4888d = new HashMap();

    /* JADX INFO: renamed from: e, reason: collision with root package name */
    public final int f4889e;

    /* JADX INFO: renamed from: f, reason: collision with root package name */
    public int f4890f;

    public k(int i10) {
        this.f4889e = i10;
    }

    @Nullable
    private <T> T getArrayForKey(j jVar) {
        return (T) this.f4885a.get(jVar);
    }

    public final void a(int i10, Class cls) {
        NavigableMap navigableMapF = f(cls);
        Integer num = (Integer) navigableMapF.get(Integer.valueOf(i10));
        if (num != null) {
            if (num.intValue() == 1) {
                navigableMapF.remove(Integer.valueOf(i10));
                return;
            } else {
                navigableMapF.put(Integer.valueOf(i10), Integer.valueOf(num.intValue() - 1));
                return;
            }
        }
        throw new NullPointerException("Tried to decrement empty size, size: " + i10 + ", this: " + this);
    }

    public final void b(int i10) {
        int i11;
        String str;
        while (this.f4890f > i10) {
            Object objRemoveLast = this.f4885a.removeLast();
            t5.n.checkNotNull(objRemoveLast);
            a aVarD = d(objRemoveLast.getClass());
            int i12 = this.f4890f;
            g gVar = (g) aVarD;
            int iA = gVar.a(objRemoveLast);
            int i13 = gVar.f4875a;
            switch (i13) {
                case 0:
                    i11 = 1;
                    break;
                default:
                    i11 = 4;
                    break;
            }
            this.f4890f = i12 - (iA * i11);
            a(gVar.a(objRemoveLast), objRemoveLast.getClass());
            switch (i13) {
                case 0:
                    str = "ByteArrayPool";
                    break;
                default:
                    str = "IntegerArrayPool";
                    break;
            }
            if (Log.isLoggable(str, 2)) {
                gVar.a(objRemoveLast);
            }
        }
    }

    public final synchronized Object c(int i10, Class cls) {
        j jVar;
        int i11;
        try {
            Integer num = (Integer) f(cls).ceilingKey(Integer.valueOf(i10));
            if (num == null || ((i11 = this.f4890f) != 0 && this.f4889e / i11 < 2 && num.intValue() > i10 * 8)) {
                d dVar = this.f4886b;
                n nVarX = (n) ((Queue) dVar.f31277a).poll();
                if (nVarX == null) {
                    nVarX = dVar.x();
                }
                jVar = (j) nVarX;
                jVar.f4883b = i10;
                jVar.f4884c = cls;
            } else {
                d dVar2 = this.f4886b;
                int iIntValue = num.intValue();
                n nVarX2 = (n) ((Queue) dVar2.f31277a).poll();
                if (nVarX2 == null) {
                    nVarX2 = dVar2.x();
                }
                jVar = (j) nVarX2;
                jVar.f4883b = iIntValue;
                jVar.f4884c = cls;
            }
        } catch (Throwable th) {
            throw th;
        }
        return e(jVar, cls);
    }

    public final a d(Class cls) {
        HashMap map = this.f4888d;
        a gVar = (a) map.get(cls);
        if (gVar == null) {
            if (cls.equals(int[].class)) {
                gVar = new g(1);
            } else {
                if (!cls.equals(byte[].class)) {
                    throw new IllegalArgumentException("No array pool found for: ".concat(cls.getSimpleName()));
                }
                gVar = new g(0);
            }
            map.put(cls, gVar);
        }
        return gVar;
    }

    /* JADX WARN: Failed to find 'out' block for switch in B:11:0x002c. Please report as an issue. */
    public final Object e(j jVar, Class cls) {
        Object obj;
        int i10;
        a aVarD = d(cls);
        Object arrayForKey = getArrayForKey(jVar);
        if (arrayForKey != null) {
            int i11 = this.f4890f;
            g gVar = (g) aVarD;
            int iA = gVar.a(arrayForKey);
            switch (gVar.f4875a) {
                case 0:
                    i10 = 1;
                    break;
                default:
                    i10 = 4;
                    break;
            }
            this.f4890f = i11 - (iA * i10);
            a(gVar.a(arrayForKey), cls);
        }
        if (arrayForKey != null) {
            return arrayForKey;
        }
        int i12 = ((g) aVarD).f4875a;
        switch (i12) {
        }
        int i13 = jVar.f4883b;
        switch (i12) {
            case 0:
                obj = new byte[i13];
                break;
            default:
                obj = new int[i13];
                break;
        }
        return obj;
    }

    public final NavigableMap f(Class cls) {
        HashMap map = this.f4887c;
        NavigableMap navigableMap = (NavigableMap) map.get(cls);
        if (navigableMap != null) {
            return navigableMap;
        }
        TreeMap treeMap = new TreeMap();
        map.put(cls, treeMap);
        return treeMap;
    }

    public final synchronized void g(Object obj) {
        int i10;
        Class<?> cls = obj.getClass();
        a aVarD = d(cls);
        int iA = ((g) aVarD).a(obj);
        int iIntValue = 1;
        switch (((g) aVarD).f4875a) {
            case 0:
                i10 = 1;
                break;
            default:
                i10 = 4;
                break;
        }
        int i11 = i10 * iA;
        if (i11 <= this.f4889e / 2) {
            d dVar = this.f4886b;
            n nVarX = (n) ((Queue) dVar.f31277a).poll();
            if (nVarX == null) {
                nVarX = dVar.x();
            }
            j jVar = (j) nVarX;
            jVar.f4883b = iA;
            jVar.f4884c = cls;
            this.f4885a.a(jVar, obj);
            NavigableMap navigableMapF = f(cls);
            Integer num = (Integer) navigableMapF.get(Integer.valueOf(jVar.f4883b));
            Integer numValueOf = Integer.valueOf(jVar.f4883b);
            if (num != null) {
                iIntValue = 1 + num.intValue();
            }
            navigableMapF.put(numValueOf, Integer.valueOf(iIntValue));
            this.f4890f += i11;
            b(this.f4889e);
        }
    }
}