package io.netty.handler.codec.spdy;

import io.netty.channel.ChannelPromise;
import io.netty.util.internal.PlatformDependent;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Map;
import java.util.Queue;
import java.util.TreeMap;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.atomic.AtomicInteger;

/* JADX INFO: loaded from: classes.dex */
public final class SpdySession {
    private final AtomicInteger receiveWindowSize;
    private final AtomicInteger sendWindowSize;
    private final AtomicInteger activeLocalStreams = new AtomicInteger();
    private final AtomicInteger activeRemoteStreams = new AtomicInteger();
    private final Map<Integer, StreamState> activeStreams = PlatformDependent.newConcurrentHashMap();
    private final StreamComparator streamComparator = new StreamComparator();

    public static final class PendingWrite {
        public final ChannelPromise promise;
        public final SpdyDataFrame spdyDataFrame;

        public PendingWrite(SpdyDataFrame spdyDataFrame, ChannelPromise channelPromise) {
            this.spdyDataFrame = spdyDataFrame;
            this.promise = channelPromise;
        }

        public void fail(Throwable th) {
            this.spdyDataFrame.release();
            this.promise.setFailure(th);
        }
    }

    public final class StreamComparator implements Comparator<Integer> {
        public StreamComparator() {
        }

        @Override // java.util.Comparator
        public int compare(Integer num, Integer num2) {
            int priority = ((StreamState) SpdySession.this.activeStreams.get(num)).getPriority() - ((StreamState) SpdySession.this.activeStreams.get(num2)).getPriority();
            return priority != 0 ? priority : num.intValue() - num2.intValue();
        }
    }

    public static final class StreamState {
        private boolean localSideClosed;
        private final Queue<PendingWrite> pendingWriteQueue = new ConcurrentLinkedQueue();
        private final byte priority;
        private final AtomicInteger receiveWindowSize;
        private int receiveWindowSizeLowerBound;
        private boolean receivedReply;
        private boolean remoteSideClosed;
        private final AtomicInteger sendWindowSize;

        public StreamState(byte b2, boolean z2, boolean z3, int i2, int i3) {
            this.priority = b2;
            this.remoteSideClosed = z2;
            this.localSideClosed = z3;
            this.sendWindowSize = new AtomicInteger(i2);
            this.receiveWindowSize = new AtomicInteger(i3);
        }

        public void clearPendingWrites(Throwable th) {
            while (true) {
                PendingWrite pendingWritePoll = this.pendingWriteQueue.poll();
                if (pendingWritePoll == null) {
                    return;
                } else {
                    pendingWritePoll.fail(th);
                }
            }
        }

        public void closeLocalSide() {
            this.localSideClosed = true;
        }

        public void closeRemoteSide() {
            this.remoteSideClosed = true;
        }

        public PendingWrite getPendingWrite() {
            return this.pendingWriteQueue.peek();
        }

        public byte getPriority() {
            return this.priority;
        }

        public int getReceiveWindowSizeLowerBound() {
            return this.receiveWindowSizeLowerBound;
        }

        public int getSendWindowSize() {
            return this.sendWindowSize.get();
        }

        public boolean hasReceivedReply() {
            return this.receivedReply;
        }

        public boolean isLocalSideClosed() {
            return this.localSideClosed;
        }

        public boolean isRemoteSideClosed() {
            return this.remoteSideClosed;
        }

        public boolean putPendingWrite(PendingWrite pendingWrite) {
            return this.pendingWriteQueue.offer(pendingWrite);
        }

        public void receivedReply() {
            this.receivedReply = true;
        }

        public PendingWrite removePendingWrite() {
            return this.pendingWriteQueue.poll();
        }

        public void setReceiveWindowSizeLowerBound(int i2) {
            this.receiveWindowSizeLowerBound = i2;
        }

        public int updateReceiveWindowSize(int i2) {
            return this.receiveWindowSize.addAndGet(i2);
        }

        public int updateSendWindowSize(int i2) {
            return this.sendWindowSize.addAndGet(i2);
        }
    }

    public SpdySession(int i2, int i3) {
        this.sendWindowSize = new AtomicInteger(i2);
        this.receiveWindowSize = new AtomicInteger(i3);
    }

    private StreamState removeActiveStream(int i2, boolean z2) {
        StreamState streamStateRemove = this.activeStreams.remove(Integer.valueOf(i2));
        if (streamStateRemove != null) {
            (z2 ? this.activeRemoteStreams : this.activeLocalStreams).decrementAndGet();
        }
        return streamStateRemove;
    }

    public void acceptStream(int i2, byte b2, boolean z2, boolean z3, int i3, int i4, boolean z4) {
        if (!(z2 && z3) && this.activeStreams.put(Integer.valueOf(i2), new StreamState(b2, z2, z3, i3, i4)) == null) {
            (z4 ? this.activeRemoteStreams : this.activeLocalStreams).incrementAndGet();
        }
    }

    public Map<Integer, StreamState> activeStreams() {
        TreeMap treeMap = new TreeMap(this.streamComparator);
        treeMap.putAll(this.activeStreams);
        return treeMap;
    }

    public void closeLocalSide(int i2, boolean z2) {
        StreamState streamState = this.activeStreams.get(Integer.valueOf(i2));
        if (streamState != null) {
            streamState.closeLocalSide();
            if (streamState.isRemoteSideClosed()) {
                removeActiveStream(i2, z2);
            }
        }
    }

    public void closeRemoteSide(int i2, boolean z2) {
        StreamState streamState = this.activeStreams.get(Integer.valueOf(i2));
        if (streamState != null) {
            streamState.closeRemoteSide();
            if (streamState.isLocalSideClosed()) {
                removeActiveStream(i2, z2);
            }
        }
    }

    public PendingWrite getPendingWrite(int i2) {
        PendingWrite pendingWrite;
        if (i2 != 0) {
            StreamState streamState = this.activeStreams.get(Integer.valueOf(i2));
            if (streamState != null) {
                return streamState.getPendingWrite();
            }
            return null;
        }
        Iterator<Map.Entry<Integer, StreamState>> it = activeStreams().entrySet().iterator();
        while (it.hasNext()) {
            StreamState value = it.next().getValue();
            if (value.getSendWindowSize() > 0 && (pendingWrite = value.getPendingWrite()) != null) {
                return pendingWrite;
            }
        }
        return null;
    }

    public int getReceiveWindowSizeLowerBound(int i2) {
        StreamState streamState;
        if (i2 == 0 || (streamState = this.activeStreams.get(Integer.valueOf(i2))) == null) {
            return 0;
        }
        return streamState.getReceiveWindowSizeLowerBound();
    }

    public int getSendWindowSize(int i2) {
        if (i2 == 0) {
            return this.sendWindowSize.get();
        }
        StreamState streamState = this.activeStreams.get(Integer.valueOf(i2));
        if (streamState != null) {
            return streamState.getSendWindowSize();
        }
        return -1;
    }

    public boolean hasReceivedReply(int i2) {
        StreamState streamState = this.activeStreams.get(Integer.valueOf(i2));
        return streamState != null && streamState.hasReceivedReply();
    }

    public boolean isActiveStream(int i2) {
        return this.activeStreams.containsKey(Integer.valueOf(i2));
    }

    public boolean isLocalSideClosed(int i2) {
        StreamState streamState = this.activeStreams.get(Integer.valueOf(i2));
        return streamState == null || streamState.isLocalSideClosed();
    }

    public boolean isRemoteSideClosed(int i2) {
        StreamState streamState = this.activeStreams.get(Integer.valueOf(i2));
        return streamState == null || streamState.isRemoteSideClosed();
    }

    public boolean noActiveStreams() {
        return this.activeStreams.isEmpty();
    }

    public int numActiveStreams(boolean z2) {
        return (z2 ? this.activeRemoteStreams : this.activeLocalStreams).get();
    }

    public boolean putPendingWrite(int i2, PendingWrite pendingWrite) {
        StreamState streamState = this.activeStreams.get(Integer.valueOf(i2));
        return streamState != null && streamState.putPendingWrite(pendingWrite);
    }

    public void receivedReply(int i2) {
        StreamState streamState = this.activeStreams.get(Integer.valueOf(i2));
        if (streamState != null) {
            streamState.receivedReply();
        }
    }

    public PendingWrite removePendingWrite(int i2) {
        StreamState streamState = this.activeStreams.get(Integer.valueOf(i2));
        if (streamState != null) {
            return streamState.removePendingWrite();
        }
        return null;
    }

    public void removeStream(int i2, Throwable th, boolean z2) {
        StreamState streamStateRemoveActiveStream = removeActiveStream(i2, z2);
        if (streamStateRemoveActiveStream != null) {
            streamStateRemoveActiveStream.clearPendingWrites(th);
        }
    }

    public void updateAllReceiveWindowSizes(int i2) {
        for (StreamState streamState : this.activeStreams.values()) {
            streamState.updateReceiveWindowSize(i2);
            if (i2 < 0) {
                streamState.setReceiveWindowSizeLowerBound(i2);
            }
        }
    }

    public void updateAllSendWindowSizes(int i2) {
        Iterator<StreamState> it = this.activeStreams.values().iterator();
        while (it.hasNext()) {
            it.next().updateSendWindowSize(i2);
        }
    }

    public int updateReceiveWindowSize(int i2, int i3) {
        if (i2 == 0) {
            return this.receiveWindowSize.addAndGet(i3);
        }
        StreamState streamState = this.activeStreams.get(Integer.valueOf(i2));
        if (streamState == null) {
            return -1;
        }
        if (i3 > 0) {
            streamState.setReceiveWindowSizeLowerBound(0);
        }
        return streamState.updateReceiveWindowSize(i3);
    }

    public int updateSendWindowSize(int i2, int i3) {
        if (i2 == 0) {
            return this.sendWindowSize.addAndGet(i3);
        }
        StreamState streamState = this.activeStreams.get(Integer.valueOf(i2));
        if (streamState != null) {
            return streamState.updateSendWindowSize(i3);
        }
        return -1;
    }
}