package io.netty.buffer;

import io.netty.util.internal.StringUtil;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;

/* JADX INFO: loaded from: classes.dex */
final class PoolChunkList<T> implements PoolChunkListMetric {
    static final /* synthetic */ boolean $assertionsDisabled = false;
    private static final Iterator<PoolChunkMetric> EMPTY_METRICS = Collections.emptyList().iterator();
    private PoolChunk<T> head;
    private final int maxCapacity;
    private final int maxUsage;
    private final int minUsage;
    private final PoolChunkList<T> nextList;
    private PoolChunkList<T> prevList;

    PoolChunkList(PoolChunkList<T> poolChunkList, int i2, int i3, int i4) {
        this.nextList = poolChunkList;
        this.minUsage = i2;
        this.maxUsage = i3;
        this.maxCapacity = calculateMaxCapacity(i2, i4);
    }

    private static int calculateMaxCapacity(int i2, int i3) {
        int iMinUsage0 = minUsage0(i2);
        if (iMinUsage0 == 100) {
            return 0;
        }
        return (int) ((((long) i3) * (100 - ((long) iMinUsage0))) / 100);
    }

    private static int minUsage0(int i2) {
        return Math.max(1, i2);
    }

    private boolean move(PoolChunk<T> poolChunk) {
        if (poolChunk.usage() < this.minUsage) {
            return move0(poolChunk);
        }
        add0(poolChunk);
        return true;
    }

    private boolean move0(PoolChunk<T> poolChunk) {
        PoolChunkList<T> poolChunkList = this.prevList;
        if (poolChunkList == null) {
            return false;
        }
        return poolChunkList.move(poolChunk);
    }

    private void remove(PoolChunk<T> poolChunk) {
        if (poolChunk == this.head) {
            PoolChunk<T> poolChunk2 = poolChunk.next;
            this.head = poolChunk2;
            if (poolChunk2 != null) {
                poolChunk2.prev = null;
                return;
            }
            return;
        }
        PoolChunk<T> poolChunk3 = poolChunk.next;
        PoolChunk<T> poolChunk4 = poolChunk.prev;
        poolChunk4.next = poolChunk3;
        if (poolChunk3 != null) {
            poolChunk3.prev = poolChunk4;
        }
    }

    void add(PoolChunk<T> poolChunk) {
        if (poolChunk.usage() >= this.maxUsage) {
            this.nextList.add(poolChunk);
        } else {
            add0(poolChunk);
        }
    }

    void add0(PoolChunk<T> poolChunk) {
        poolChunk.parent = this;
        PoolChunk<T> poolChunk2 = this.head;
        if (poolChunk2 == null) {
            this.head = poolChunk;
            poolChunk.prev = null;
            poolChunk.next = null;
        } else {
            poolChunk.prev = null;
            poolChunk.next = poolChunk2;
            poolChunk2.prev = poolChunk;
            this.head = poolChunk;
        }
    }

    boolean allocate(PooledByteBuf<T> pooledByteBuf, int i2, int i3) {
        PoolChunk<T> poolChunk = this.head;
        if (poolChunk == null || i3 > this.maxCapacity) {
            return false;
        }
        do {
            long jAllocate = poolChunk.allocate(i3);
            if (jAllocate >= 0) {
                poolChunk.initBuf(pooledByteBuf, jAllocate, i2);
                if (poolChunk.usage() < this.maxUsage) {
                    return true;
                }
                remove(poolChunk);
                this.nextList.add(poolChunk);
                return true;
            }
            poolChunk = poolChunk.next;
        } while (poolChunk != null);
        return false;
    }

    boolean free(PoolChunk<T> poolChunk, long j2) {
        poolChunk.free(j2);
        if (poolChunk.usage() >= this.minUsage) {
            return true;
        }
        remove(poolChunk);
        return move0(poolChunk);
    }

    @Override // java.lang.Iterable
    public Iterator<PoolChunkMetric> iterator() {
        if (this.head == null) {
            return EMPTY_METRICS;
        }
        ArrayList arrayList = new ArrayList();
        PoolChunk<T> poolChunk = this.head;
        do {
            arrayList.add(poolChunk);
            poolChunk = poolChunk.next;
        } while (poolChunk != null);
        return arrayList.iterator();
    }

    @Override // io.netty.buffer.PoolChunkListMetric
    public int maxUsage() {
        return Math.min(this.maxUsage, 100);
    }

    @Override // io.netty.buffer.PoolChunkListMetric
    public int minUsage() {
        return minUsage0(this.minUsage);
    }

    void prevList(PoolChunkList<T> poolChunkList) {
        this.prevList = poolChunkList;
    }

    public String toString() {
        if (this.head == null) {
            return "none";
        }
        StringBuilder sb = new StringBuilder();
        PoolChunk<T> poolChunk = this.head;
        while (true) {
            sb.append(poolChunk);
            poolChunk = poolChunk.next;
            if (poolChunk == null) {
                return sb.toString();
            }
            sb.append(StringUtil.NEWLINE);
        }
    }
}