package io.netty.handler.traffic;

import g.a.a.a.a;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelPromise;
import io.netty.util.concurrent.EventExecutor;
import java.util.ArrayDeque;
import java.util.Iterator;
import java.util.concurrent.TimeUnit;

/* JADX INFO: loaded from: classes.dex */
public class ChannelTrafficShapingHandler extends AbstractTrafficShapingHandler {
    private final ArrayDeque<ToSend> messagesQueue;
    private long queueSize;

    public static final class ToSend {
        public final ChannelPromise promise;
        public final long relativeTimeAction;
        public final Object toSend;

        private ToSend(long j2, Object obj, ChannelPromise channelPromise) {
            this.relativeTimeAction = j2;
            this.toSend = obj;
            this.promise = channelPromise;
        }
    }

    public ChannelTrafficShapingHandler(long j2) {
        super(j2);
        this.messagesQueue = new ArrayDeque<>();
    }

    public ChannelTrafficShapingHandler(long j2, long j3) {
        super(j2, j3);
        this.messagesQueue = new ArrayDeque<>();
    }

    public ChannelTrafficShapingHandler(long j2, long j3, long j4) {
        super(j2, j3, j4);
        this.messagesQueue = new ArrayDeque<>();
    }

    public ChannelTrafficShapingHandler(long j2, long j3, long j4, long j5) {
        super(j2, j3, j4, j5);
        this.messagesQueue = new ArrayDeque<>();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void sendAllValid(ChannelHandlerContext channelHandlerContext, long j2) {
        synchronized (this) {
            ToSend toSendPollFirst = this.messagesQueue.pollFirst();
            while (true) {
                ToSend toSend = toSendPollFirst;
                if (toSend != null) {
                    if (toSend.relativeTimeAction > j2) {
                        this.messagesQueue.addFirst(toSend);
                        break;
                    }
                    long jCalculateSize = calculateSize(toSend.toSend);
                    this.trafficCounter.bytesRealWriteFlowControl(jCalculateSize);
                    this.queueSize -= jCalculateSize;
                    channelHandlerContext.write(toSend.toSend, toSend.promise);
                    toSendPollFirst = this.messagesQueue.pollFirst();
                } else {
                    break;
                }
            }
            if (this.messagesQueue.isEmpty()) {
                releaseWriteSuspended(channelHandlerContext);
            }
        }
        channelHandlerContext.flush();
    }

    @Override // io.netty.channel.ChannelHandlerAdapter, io.netty.channel.ChannelHandler
    public void handlerAdded(ChannelHandlerContext channelHandlerContext) {
        EventExecutor eventExecutorExecutor = channelHandlerContext.executor();
        StringBuilder sbF = a.F("ChannelTC");
        sbF.append(channelHandlerContext.channel().hashCode());
        TrafficCounter trafficCounter = new TrafficCounter(this, eventExecutorExecutor, sbF.toString(), this.checkInterval);
        setTrafficCounter(trafficCounter);
        trafficCounter.start();
        super.handlerAdded(channelHandlerContext);
    }

    @Override // io.netty.channel.ChannelHandlerAdapter, io.netty.channel.ChannelHandler
    public void handlerRemoved(ChannelHandlerContext channelHandlerContext) {
        this.trafficCounter.stop();
        synchronized (this) {
            if (channelHandlerContext.channel().isActive()) {
                for (ToSend toSend : this.messagesQueue) {
                    long jCalculateSize = calculateSize(toSend.toSend);
                    this.trafficCounter.bytesRealWriteFlowControl(jCalculateSize);
                    this.queueSize -= jCalculateSize;
                    channelHandlerContext.write(toSend.toSend, toSend.promise);
                }
            } else {
                Iterator<ToSend> it = this.messagesQueue.iterator();
                while (it.hasNext()) {
                    Object obj = it.next().toSend;
                    if (obj instanceof ByteBuf) {
                        ((ByteBuf) obj).release();
                    }
                }
            }
            this.messagesQueue.clear();
        }
        releaseWriteSuspended(channelHandlerContext);
        releaseReadSuspended(channelHandlerContext);
        super.handlerRemoved(channelHandlerContext);
    }

    public long queueSize() {
        return this.queueSize;
    }

    @Override // io.netty.handler.traffic.AbstractTrafficShapingHandler
    public void submitWrite(final ChannelHandlerContext channelHandlerContext, Object obj, long j2, long j3, long j4, ChannelPromise channelPromise) {
        synchronized (this) {
            if (j3 == 0) {
                if (this.messagesQueue.isEmpty()) {
                    this.trafficCounter.bytesRealWriteFlowControl(j2);
                    channelHandlerContext.write(obj, channelPromise);
                    return;
                }
            }
            ToSend toSend = new ToSend(j3 + j4, obj, channelPromise);
            this.messagesQueue.addLast(toSend);
            long j5 = this.queueSize + j2;
            this.queueSize = j5;
            checkWriteSuspend(channelHandlerContext, j3, j5);
            final long j6 = toSend.relativeTimeAction;
            channelHandlerContext.executor().schedule(new Runnable() { // from class: io.netty.handler.traffic.ChannelTrafficShapingHandler.1
                @Override // java.lang.Runnable
                public void run() {
                    ChannelTrafficShapingHandler.this.sendAllValid(channelHandlerContext, j6);
                }
            }, j3, TimeUnit.MILLISECONDS);
        }
    }
}