package io.netty.handler.codec.http2;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.http2.Http2Connection;
import io.netty.handler.codec.http2.Http2Exception;
import io.netty.handler.codec.http2.Http2Stream;
import io.netty.util.internal.ObjectUtil;
import io.netty.util.internal.PlatformDependent;

/* JADX INFO: loaded from: classes.dex */
public class DefaultHttp2LocalFlowController implements Http2LocalFlowController {
    public static final /* synthetic */ boolean $assertionsDisabled = false;
    public static final float DEFAULT_WINDOW_UPDATE_RATIO = 0.5f;
    private static final FlowState REDUCED_FLOW_STATE = new FlowState() { // from class: io.netty.handler.codec.http2.DefaultHttp2LocalFlowController.2
        @Override // io.netty.handler.codec.http2.DefaultHttp2LocalFlowController.FlowState
        public boolean consumeBytes(int i2) {
            return false;
        }

        @Override // io.netty.handler.codec.http2.DefaultHttp2LocalFlowController.FlowState
        public void endOfStream(boolean z2) {
            throw new UnsupportedOperationException();
        }

        @Override // io.netty.handler.codec.http2.DefaultHttp2LocalFlowController.FlowState
        public void incrementFlowControlWindows(int i2) {
        }

        @Override // io.netty.handler.codec.http2.DefaultHttp2LocalFlowController.FlowState
        public void incrementInitialStreamWindow(int i2) {
        }

        @Override // io.netty.handler.codec.http2.DefaultHttp2LocalFlowController.FlowState
        public int initialWindowSize() {
            return 0;
        }

        @Override // io.netty.handler.codec.http2.DefaultHttp2LocalFlowController.FlowState
        public void receiveFlowControlledFrame(int i2) {
            throw new UnsupportedOperationException();
        }

        @Override // io.netty.handler.codec.http2.DefaultHttp2LocalFlowController.FlowState
        public int unconsumedBytes() {
            return 0;
        }

        @Override // io.netty.handler.codec.http2.DefaultHttp2LocalFlowController.FlowState
        public void window(int i2) {
            throw new UnsupportedOperationException();
        }

        @Override // io.netty.handler.codec.http2.DefaultHttp2LocalFlowController.FlowState
        public int windowSize() {
            return 0;
        }

        @Override // io.netty.handler.codec.http2.DefaultHttp2LocalFlowController.FlowState
        public float windowUpdateRatio() {
            throw new UnsupportedOperationException();
        }

        @Override // io.netty.handler.codec.http2.DefaultHttp2LocalFlowController.FlowState
        public void windowUpdateRatio(float f2) {
            throw new UnsupportedOperationException();
        }

        @Override // io.netty.handler.codec.http2.DefaultHttp2LocalFlowController.FlowState
        public boolean writeWindowUpdateIfNeeded() {
            throw new UnsupportedOperationException();
        }
    };
    private final Http2Connection connection;
    private ChannelHandlerContext ctx;
    private Http2FrameWriter frameWriter;
    private int initialWindowSize;
    private final Http2Connection.PropertyKey stateKey;
    private float windowUpdateRatio;

    public final class AutoRefillState extends DefaultState {
        public AutoRefillState(Http2Stream http2Stream, int i2) {
            super(http2Stream, i2);
        }

        @Override // io.netty.handler.codec.http2.DefaultHttp2LocalFlowController.DefaultState, io.netty.handler.codec.http2.DefaultHttp2LocalFlowController.FlowState
        public boolean consumeBytes(int i2) {
            return false;
        }

        @Override // io.netty.handler.codec.http2.DefaultHttp2LocalFlowController.DefaultState, io.netty.handler.codec.http2.DefaultHttp2LocalFlowController.FlowState
        public void receiveFlowControlledFrame(int i2) throws Http2Exception {
            super.receiveFlowControlledFrame(i2);
            super.consumeBytes(i2);
        }
    }

    public class DefaultState implements FlowState {
        public static final /* synthetic */ boolean $assertionsDisabled = false;
        private boolean endOfStream;
        private int initialStreamWindowSize;
        private int lowerBound;
        private int processedWindow;
        private final Http2Stream stream;
        private float streamWindowUpdateRatio;
        private int window;

        public DefaultState(Http2Stream http2Stream, int i2) {
            this.stream = http2Stream;
            window(i2);
            this.streamWindowUpdateRatio = DefaultHttp2LocalFlowController.this.windowUpdateRatio;
        }

        private void returnProcessedBytes(int i2) throws Http2Exception {
            int i3 = this.processedWindow;
            if (i3 - i2 < this.window) {
                throw Http2Exception.streamError(this.stream.id(), Http2Error.INTERNAL_ERROR, "Attempting to return too many bytes for stream %d", Integer.valueOf(this.stream.id()));
            }
            this.processedWindow = i3 - i2;
        }

        private void writeWindowUpdate() throws Http2Exception {
            int i2 = this.initialStreamWindowSize - this.processedWindow;
            try {
                incrementFlowControlWindows(i2);
                DefaultHttp2LocalFlowController.this.frameWriter.writeWindowUpdate(DefaultHttp2LocalFlowController.this.ctx, this.stream.id(), i2, DefaultHttp2LocalFlowController.this.ctx.newPromise());
            } catch (Throwable th) {
                throw Http2Exception.connectionError(Http2Error.INTERNAL_ERROR, th, "Attempting to return too many bytes for stream %d", Integer.valueOf(this.stream.id()));
            }
        }

        @Override // io.netty.handler.codec.http2.DefaultHttp2LocalFlowController.FlowState
        public boolean consumeBytes(int i2) throws Http2Exception {
            returnProcessedBytes(i2);
            return writeWindowUpdateIfNeeded();
        }

        @Override // io.netty.handler.codec.http2.DefaultHttp2LocalFlowController.FlowState
        public void endOfStream(boolean z2) {
            this.endOfStream = z2;
        }

        @Override // io.netty.handler.codec.http2.DefaultHttp2LocalFlowController.FlowState
        public void incrementFlowControlWindows(int i2) throws Http2Exception {
            if (i2 > 0 && this.window > Integer.MAX_VALUE - i2) {
                throw Http2Exception.streamError(this.stream.id(), Http2Error.FLOW_CONTROL_ERROR, "Flow control window overflowed for stream: %d", Integer.valueOf(this.stream.id()));
            }
            this.window += i2;
            this.processedWindow += i2;
            if (i2 >= 0) {
                i2 = 0;
            }
            this.lowerBound = i2;
        }

        @Override // io.netty.handler.codec.http2.DefaultHttp2LocalFlowController.FlowState
        public void incrementInitialStreamWindow(int i2) {
            int iMin = (int) Math.min(2147483647L, Math.max(0L, ((long) this.initialStreamWindowSize) + ((long) i2)));
            int i3 = this.initialStreamWindowSize;
            this.initialStreamWindowSize = (iMin - i3) + i3;
        }

        @Override // io.netty.handler.codec.http2.DefaultHttp2LocalFlowController.FlowState
        public int initialWindowSize() {
            return this.initialStreamWindowSize;
        }

        @Override // io.netty.handler.codec.http2.DefaultHttp2LocalFlowController.FlowState
        public void receiveFlowControlledFrame(int i2) throws Http2Exception {
            int i3 = this.window - i2;
            this.window = i3;
            if (i3 < this.lowerBound) {
                throw Http2Exception.streamError(this.stream.id(), Http2Error.FLOW_CONTROL_ERROR, "Flow control window exceeded for stream: %d", Integer.valueOf(this.stream.id()));
            }
        }

        @Override // io.netty.handler.codec.http2.DefaultHttp2LocalFlowController.FlowState
        public int unconsumedBytes() {
            return this.processedWindow - this.window;
        }

        @Override // io.netty.handler.codec.http2.DefaultHttp2LocalFlowController.FlowState
        public void window(int i2) {
            this.initialStreamWindowSize = i2;
            this.processedWindow = i2;
            this.window = i2;
        }

        @Override // io.netty.handler.codec.http2.DefaultHttp2LocalFlowController.FlowState
        public int windowSize() {
            return this.window;
        }

        @Override // io.netty.handler.codec.http2.DefaultHttp2LocalFlowController.FlowState
        public float windowUpdateRatio() {
            return this.streamWindowUpdateRatio;
        }

        @Override // io.netty.handler.codec.http2.DefaultHttp2LocalFlowController.FlowState
        public void windowUpdateRatio(float f2) {
            this.streamWindowUpdateRatio = f2;
        }

        @Override // io.netty.handler.codec.http2.DefaultHttp2LocalFlowController.FlowState
        public boolean writeWindowUpdateIfNeeded() throws Http2Exception {
            int i2;
            if (!this.endOfStream && (i2 = this.initialStreamWindowSize) > 0) {
                if (this.processedWindow <= ((int) (i2 * this.streamWindowUpdateRatio))) {
                    writeWindowUpdate();
                    return true;
                }
            }
            return false;
        }
    }

    public interface FlowState {
        boolean consumeBytes(int i2);

        void endOfStream(boolean z2);

        void incrementFlowControlWindows(int i2);

        void incrementInitialStreamWindow(int i2);

        int initialWindowSize();

        void receiveFlowControlledFrame(int i2);

        int unconsumedBytes();

        void window(int i2);

        int windowSize();

        float windowUpdateRatio();

        void windowUpdateRatio(float f2);

        boolean writeWindowUpdateIfNeeded();
    }

    public final class WindowUpdateVisitor implements Http2StreamVisitor {
        private Http2Exception.CompositeStreamException compositeException;
        private final int delta;

        public WindowUpdateVisitor(int i2) {
            this.delta = i2;
        }

        public void throwIfError() throws Http2Exception.CompositeStreamException {
            Http2Exception.CompositeStreamException compositeStreamException = this.compositeException;
            if (compositeStreamException != null) {
                throw compositeStreamException;
            }
        }

        @Override // io.netty.handler.codec.http2.Http2StreamVisitor
        public boolean visit(Http2Stream http2Stream) {
            try {
                FlowState flowStateState = DefaultHttp2LocalFlowController.this.state(http2Stream);
                flowStateState.incrementFlowControlWindows(this.delta);
                flowStateState.incrementInitialStreamWindow(this.delta);
                return true;
            } catch (Http2Exception.StreamException e2) {
                if (this.compositeException == null) {
                    this.compositeException = new Http2Exception.CompositeStreamException(e2.error(), 4);
                }
                this.compositeException.add(e2);
                return true;
            }
        }
    }

    public DefaultHttp2LocalFlowController(Http2Connection http2Connection) {
        this(http2Connection, 0.5f, false);
    }

    public DefaultHttp2LocalFlowController(Http2Connection http2Connection, float f2, boolean z2) {
        this.initialWindowSize = 65535;
        this.connection = (Http2Connection) ObjectUtil.checkNotNull(http2Connection, "connection");
        windowUpdateRatio(f2);
        Http2Connection.PropertyKey propertyKeyNewKey = http2Connection.newKey();
        this.stateKey = propertyKeyNewKey;
        http2Connection.connectionStream().setProperty(propertyKeyNewKey, z2 ? new AutoRefillState(http2Connection.connectionStream(), this.initialWindowSize) : new DefaultState(http2Connection.connectionStream(), this.initialWindowSize));
        http2Connection.addListener(new Http2ConnectionAdapter() { // from class: io.netty.handler.codec.http2.DefaultHttp2LocalFlowController.1
            @Override // io.netty.handler.codec.http2.Http2ConnectionAdapter, io.netty.handler.codec.http2.Http2Connection.Listener
            public void onStreamActive(Http2Stream http2Stream) {
                Http2Connection.PropertyKey propertyKey = DefaultHttp2LocalFlowController.this.stateKey;
                DefaultHttp2LocalFlowController defaultHttp2LocalFlowController = DefaultHttp2LocalFlowController.this;
                http2Stream.setProperty(propertyKey, defaultHttp2LocalFlowController.new DefaultState(http2Stream, defaultHttp2LocalFlowController.initialWindowSize));
            }

            @Override // io.netty.handler.codec.http2.Http2ConnectionAdapter, io.netty.handler.codec.http2.Http2Connection.Listener
            public void onStreamAdded(Http2Stream http2Stream) {
                http2Stream.setProperty(DefaultHttp2LocalFlowController.this.stateKey, DefaultHttp2LocalFlowController.REDUCED_FLOW_STATE);
            }

            @Override // io.netty.handler.codec.http2.Http2ConnectionAdapter, io.netty.handler.codec.http2.Http2Connection.Listener
            public void onStreamClosed(Http2Stream http2Stream) {
                try {
                    try {
                        FlowState flowStateState = DefaultHttp2LocalFlowController.this.state(http2Stream);
                        int iUnconsumedBytes = flowStateState.unconsumedBytes();
                        if (DefaultHttp2LocalFlowController.this.ctx != null && iUnconsumedBytes > 0) {
                            DefaultHttp2LocalFlowController.this.connectionState().consumeBytes(iUnconsumedBytes);
                            flowStateState.consumeBytes(iUnconsumedBytes);
                        }
                    } catch (Http2Exception e2) {
                        PlatformDependent.throwException(e2);
                    }
                } finally {
                    http2Stream.setProperty(DefaultHttp2LocalFlowController.this.stateKey, DefaultHttp2LocalFlowController.REDUCED_FLOW_STATE);
                }
            }
        });
    }

    private static void checkValidRatio(float f2) {
        double d2 = f2;
        if (Double.compare(d2, 0.0d) <= 0 || Double.compare(d2, 1.0d) >= 0) {
            throw new IllegalArgumentException("Invalid ratio: " + f2);
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public FlowState connectionState() {
        return (FlowState) this.connection.connectionStream().getProperty(this.stateKey);
    }

    private static boolean isClosed(Http2Stream http2Stream) {
        return http2Stream.state() == Http2Stream.State.CLOSED;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public FlowState state(Http2Stream http2Stream) {
        return (FlowState) http2Stream.getProperty(this.stateKey);
    }

    @Override // io.netty.handler.codec.http2.Http2FlowController
    public void channelHandlerContext(ChannelHandlerContext channelHandlerContext) {
        this.ctx = (ChannelHandlerContext) ObjectUtil.checkNotNull(channelHandlerContext, "ctx");
    }

    @Override // io.netty.handler.codec.http2.Http2LocalFlowController
    public boolean consumeBytes(Http2Stream http2Stream, int i2) {
        if (i2 < 0) {
            throw new IllegalArgumentException("numBytes must not be negative");
        }
        if (i2 == 0 || http2Stream == null || isClosed(http2Stream)) {
            return false;
        }
        if (http2Stream.id() == 0) {
            throw new UnsupportedOperationException("Returning bytes for the connection window is not supported");
        }
        return state(http2Stream).consumeBytes(i2) | connectionState().consumeBytes(i2);
    }

    @Override // io.netty.handler.codec.http2.Http2LocalFlowController
    public DefaultHttp2LocalFlowController frameWriter(Http2FrameWriter http2FrameWriter) {
        this.frameWriter = (Http2FrameWriter) ObjectUtil.checkNotNull(http2FrameWriter, "frameWriter");
        return this;
    }

    @Override // io.netty.handler.codec.http2.Http2FlowController
    public void incrementWindowSize(Http2Stream http2Stream, int i2) {
        FlowState flowStateState = state(http2Stream);
        flowStateState.incrementInitialStreamWindow(i2);
        flowStateState.writeWindowUpdateIfNeeded();
    }

    @Override // io.netty.handler.codec.http2.Http2FlowController
    public int initialWindowSize() {
        return this.initialWindowSize;
    }

    @Override // io.netty.handler.codec.http2.Http2LocalFlowController
    public int initialWindowSize(Http2Stream http2Stream) {
        return state(http2Stream).initialWindowSize();
    }

    @Override // io.netty.handler.codec.http2.Http2FlowController
    public void initialWindowSize(int i2) throws Http2Exception.CompositeStreamException {
        int i3 = i2 - this.initialWindowSize;
        this.initialWindowSize = i2;
        WindowUpdateVisitor windowUpdateVisitor = new WindowUpdateVisitor(i3);
        this.connection.forEachActiveStream(windowUpdateVisitor);
        windowUpdateVisitor.throwIfError();
    }

    @Override // io.netty.handler.codec.http2.Http2LocalFlowController
    public void receiveFlowControlledFrame(Http2Stream http2Stream, ByteBuf byteBuf, int i2, boolean z2) {
        int i3 = byteBuf.readableBytes() + i2;
        FlowState flowStateConnectionState = connectionState();
        flowStateConnectionState.receiveFlowControlledFrame(i3);
        if (http2Stream == null || isClosed(http2Stream)) {
            if (i3 > 0) {
                flowStateConnectionState.consumeBytes(i3);
            }
        } else {
            FlowState flowStateState = state(http2Stream);
            flowStateState.endOfStream(z2);
            flowStateState.receiveFlowControlledFrame(i3);
        }
    }

    @Override // io.netty.handler.codec.http2.Http2LocalFlowController
    public int unconsumedBytes(Http2Stream http2Stream) {
        return state(http2Stream).unconsumedBytes();
    }

    @Override // io.netty.handler.codec.http2.Http2FlowController
    public int windowSize(Http2Stream http2Stream) {
        return state(http2Stream).windowSize();
    }

    public float windowUpdateRatio() {
        return this.windowUpdateRatio;
    }

    public float windowUpdateRatio(Http2Stream http2Stream) {
        return state(http2Stream).windowUpdateRatio();
    }

    public void windowUpdateRatio(float f2) {
        checkValidRatio(f2);
        this.windowUpdateRatio = f2;
    }

    public void windowUpdateRatio(Http2Stream http2Stream, float f2) {
        checkValidRatio(f2);
        FlowState flowStateState = state(http2Stream);
        flowStateState.windowUpdateRatio(f2);
        flowStateState.writeWindowUpdateIfNeeded();
    }
}