package io.netty.handler.codec.spdy;

import g.a.a.a.a;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufAllocator;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToMessageDecoder;
import io.netty.handler.codec.TooLongFrameException;
import io.netty.handler.codec.http.DefaultFullHttpRequest;
import io.netty.handler.codec.http.DefaultFullHttpResponse;
import io.netty.handler.codec.http.FullHttpMessage;
import io.netty.handler.codec.http.FullHttpRequest;
import io.netty.handler.codec.http.FullHttpResponse;
import io.netty.handler.codec.http.HttpHeaderNames;
import io.netty.handler.codec.http.HttpMethod;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.netty.handler.codec.http.HttpUtil;
import io.netty.handler.codec.http.HttpVersion;
import io.netty.handler.codec.spdy.SpdyHeaders;
import io.netty.handler.codec.spdy.SpdyHttpHeaders;
import io.netty.util.AsciiString;
import io.netty.util.ReferenceCountUtil;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;

/* JADX INFO: loaded from: classes.dex */
public class SpdyHttpDecoder extends MessageToMessageDecoder<SpdyFrame> {
    private final int maxContentLength;
    private final Map<Integer, FullHttpMessage> messageMap;
    private final int spdyVersion;
    private final boolean validateHeaders;

    public SpdyHttpDecoder(SpdyVersion spdyVersion, int i2) {
        this(spdyVersion, i2, new HashMap(), true);
    }

    public SpdyHttpDecoder(SpdyVersion spdyVersion, int i2, Map<Integer, FullHttpMessage> map) {
        this(spdyVersion, i2, map, true);
    }

    public SpdyHttpDecoder(SpdyVersion spdyVersion, int i2, Map<Integer, FullHttpMessage> map, boolean z2) {
        Objects.requireNonNull(spdyVersion, "version");
        if (i2 <= 0) {
            throw new IllegalArgumentException(a.l("maxContentLength must be a positive integer: ", i2));
        }
        this.spdyVersion = spdyVersion.getVersion();
        this.maxContentLength = i2;
        this.messageMap = map;
        this.validateHeaders = z2;
    }

    public SpdyHttpDecoder(SpdyVersion spdyVersion, int i2, boolean z2) {
        this(spdyVersion, i2, new HashMap(), z2);
    }

    private static FullHttpRequest createHttpRequest(SpdyHeadersFrame spdyHeadersFrame, ByteBufAllocator byteBufAllocator) {
        SpdyHeaders spdyHeadersHeaders = spdyHeadersFrame.headers();
        AsciiString asciiString = SpdyHeaders.HttpNames.METHOD;
        HttpMethod httpMethodValueOf = HttpMethod.valueOf(spdyHeadersHeaders.getAsString(asciiString));
        AsciiString asciiString2 = SpdyHeaders.HttpNames.PATH;
        String asString = spdyHeadersHeaders.getAsString(asciiString2);
        AsciiString asciiString3 = SpdyHeaders.HttpNames.VERSION;
        HttpVersion httpVersionValueOf = HttpVersion.valueOf(spdyHeadersHeaders.getAsString(asciiString3));
        spdyHeadersHeaders.remove(asciiString);
        spdyHeadersHeaders.remove(asciiString2);
        spdyHeadersHeaders.remove(asciiString3);
        ByteBuf byteBufBuffer = byteBufAllocator.buffer();
        try {
            DefaultFullHttpRequest defaultFullHttpRequest = new DefaultFullHttpRequest(httpVersionValueOf, httpMethodValueOf, asString, byteBufBuffer);
            spdyHeadersHeaders.remove(SpdyHeaders.HttpNames.SCHEME);
            AsciiString asciiString4 = SpdyHeaders.HttpNames.HOST;
            CharSequence charSequence = spdyHeadersHeaders.get(asciiString4);
            spdyHeadersHeaders.remove(asciiString4);
            defaultFullHttpRequest.headers().set(HttpHeaderNames.HOST, charSequence);
            for (Map.Entry<CharSequence, CharSequence> entry : spdyHeadersFrame.headers()) {
                defaultFullHttpRequest.headers().add(entry.getKey(), entry.getValue());
            }
            HttpUtil.setKeepAlive(defaultFullHttpRequest, true);
            defaultFullHttpRequest.headers().remove(HttpHeaderNames.TRANSFER_ENCODING);
            return defaultFullHttpRequest;
        } catch (Throwable th) {
            byteBufBuffer.release();
            throw th;
        }
    }

    private static FullHttpResponse createHttpResponse(SpdyHeadersFrame spdyHeadersFrame, ByteBufAllocator byteBufAllocator, boolean z2) {
        SpdyHeaders spdyHeadersHeaders = spdyHeadersFrame.headers();
        AsciiString asciiString = SpdyHeaders.HttpNames.STATUS;
        HttpResponseStatus line = HttpResponseStatus.parseLine(spdyHeadersHeaders.get(asciiString));
        AsciiString asciiString2 = SpdyHeaders.HttpNames.VERSION;
        HttpVersion httpVersionValueOf = HttpVersion.valueOf(spdyHeadersHeaders.getAsString(asciiString2));
        spdyHeadersHeaders.remove(asciiString);
        spdyHeadersHeaders.remove(asciiString2);
        ByteBuf byteBufBuffer = byteBufAllocator.buffer();
        try {
            DefaultFullHttpResponse defaultFullHttpResponse = new DefaultFullHttpResponse(httpVersionValueOf, line, byteBufBuffer, z2);
            for (Map.Entry<CharSequence, CharSequence> entry : spdyHeadersFrame.headers()) {
                defaultFullHttpResponse.headers().add(entry.getKey(), entry.getValue());
            }
            HttpUtil.setKeepAlive(defaultFullHttpResponse, true);
            defaultFullHttpResponse.headers().remove(HttpHeaderNames.TRANSFER_ENCODING);
            defaultFullHttpResponse.headers().remove(HttpHeaderNames.TRAILER);
            return defaultFullHttpResponse;
        } catch (Throwable th) {
            byteBufBuffer.release();
            throw th;
        }
    }

    @Override // io.netty.channel.ChannelInboundHandlerAdapter, io.netty.channel.ChannelInboundHandler
    public void channelInactive(ChannelHandlerContext channelHandlerContext) {
        Iterator<Map.Entry<Integer, FullHttpMessage>> it = this.messageMap.entrySet().iterator();
        while (it.hasNext()) {
            ReferenceCountUtil.safeRelease(it.next().getValue());
        }
        this.messageMap.clear();
        super.channelInactive(channelHandlerContext);
    }

    /* JADX INFO: renamed from: decode, reason: avoid collision after fix types in other method */
    public void decode2(ChannelHandlerContext channelHandlerContext, SpdyFrame spdyFrame, List<Object> list) {
        Object defaultSpdyRstStreamFrame;
        Object defaultSpdyRstStreamFrame2;
        if (spdyFrame instanceof SpdySynStreamFrame) {
            SpdySynStreamFrame spdySynStreamFrame = (SpdySynStreamFrame) spdyFrame;
            int iStreamId = spdySynStreamFrame.streamId();
            if (SpdyCodecUtil.isServerId(iStreamId)) {
                int iAssociatedStreamId = spdySynStreamFrame.associatedStreamId();
                if (iAssociatedStreamId == 0) {
                    defaultSpdyRstStreamFrame2 = new DefaultSpdyRstStreamFrame(iStreamId, SpdyStreamStatus.INVALID_STREAM);
                } else if (spdySynStreamFrame.isLast()) {
                    defaultSpdyRstStreamFrame2 = new DefaultSpdyRstStreamFrame(iStreamId, SpdyStreamStatus.PROTOCOL_ERROR);
                } else {
                    if (!spdySynStreamFrame.isTruncated()) {
                        try {
                            FullHttpRequest fullHttpRequestCreateHttpRequest = createHttpRequest(spdySynStreamFrame, channelHandlerContext.alloc());
                            fullHttpRequestCreateHttpRequest.headers().setInt(SpdyHttpHeaders.Names.STREAM_ID, iStreamId);
                            fullHttpRequestCreateHttpRequest.headers().setInt(SpdyHttpHeaders.Names.ASSOCIATED_TO_STREAM_ID, iAssociatedStreamId);
                            fullHttpRequestCreateHttpRequest.headers().setInt(SpdyHttpHeaders.Names.PRIORITY, spdySynStreamFrame.priority());
                            list.add(fullHttpRequestCreateHttpRequest);
                            return;
                        } catch (Throwable unused) {
                            defaultSpdyRstStreamFrame = new DefaultSpdyRstStreamFrame(iStreamId, SpdyStreamStatus.PROTOCOL_ERROR);
                            channelHandlerContext.writeAndFlush(defaultSpdyRstStreamFrame);
                            return;
                        }
                    }
                    defaultSpdyRstStreamFrame2 = new DefaultSpdyRstStreamFrame(iStreamId, SpdyStreamStatus.INTERNAL_ERROR);
                }
                channelHandlerContext.writeAndFlush(defaultSpdyRstStreamFrame2);
            }
            if (spdySynStreamFrame.isTruncated()) {
                DefaultSpdySynReplyFrame defaultSpdySynReplyFrame = new DefaultSpdySynReplyFrame(iStreamId);
                defaultSpdySynReplyFrame.setLast(true);
                SpdyHeaders spdyHeadersHeaders = defaultSpdySynReplyFrame.headers();
                spdyHeadersHeaders.setInt(SpdyHeaders.HttpNames.STATUS, HttpResponseStatus.REQUEST_HEADER_FIELDS_TOO_LARGE.code());
                spdyHeadersHeaders.setObject(SpdyHeaders.HttpNames.VERSION, HttpVersion.HTTP_1_0);
                defaultSpdyRstStreamFrame2 = defaultSpdySynReplyFrame;
                channelHandlerContext.writeAndFlush(defaultSpdyRstStreamFrame2);
            }
            try {
                FullHttpRequest fullHttpRequestCreateHttpRequest2 = createHttpRequest(spdySynStreamFrame, channelHandlerContext.alloc());
                fullHttpRequestCreateHttpRequest2.headers().setInt(SpdyHttpHeaders.Names.STREAM_ID, iStreamId);
                if (spdySynStreamFrame.isLast()) {
                    list.add(fullHttpRequestCreateHttpRequest2);
                } else {
                    putMessage(iStreamId, fullHttpRequestCreateHttpRequest2);
                }
                return;
            } catch (Throwable unused2) {
                DefaultSpdySynReplyFrame defaultSpdySynReplyFrame2 = new DefaultSpdySynReplyFrame(iStreamId);
                defaultSpdySynReplyFrame2.setLast(true);
                SpdyHeaders spdyHeadersHeaders2 = defaultSpdySynReplyFrame2.headers();
                spdyHeadersHeaders2.setInt(SpdyHeaders.HttpNames.STATUS, HttpResponseStatus.BAD_REQUEST.code());
                spdyHeadersHeaders2.setObject(SpdyHeaders.HttpNames.VERSION, HttpVersion.HTTP_1_0);
                defaultSpdyRstStreamFrame = defaultSpdySynReplyFrame2;
                channelHandlerContext.writeAndFlush(defaultSpdyRstStreamFrame);
                return;
            }
        }
        if (spdyFrame instanceof SpdySynReplyFrame) {
            SpdySynReplyFrame spdySynReplyFrame = (SpdySynReplyFrame) spdyFrame;
            int iStreamId2 = spdySynReplyFrame.streamId();
            if (!spdySynReplyFrame.isTruncated()) {
                try {
                    FullHttpResponse fullHttpResponseCreateHttpResponse = createHttpResponse(spdySynReplyFrame, channelHandlerContext.alloc(), this.validateHeaders);
                    fullHttpResponseCreateHttpResponse.headers().setInt(SpdyHttpHeaders.Names.STREAM_ID, iStreamId2);
                    if (spdySynReplyFrame.isLast()) {
                        HttpUtil.setContentLength(fullHttpResponseCreateHttpResponse, 0L);
                        list.add(fullHttpResponseCreateHttpResponse);
                    } else {
                        putMessage(iStreamId2, fullHttpResponseCreateHttpResponse);
                    }
                    return;
                } catch (Throwable unused3) {
                    defaultSpdyRstStreamFrame = new DefaultSpdyRstStreamFrame(iStreamId2, SpdyStreamStatus.PROTOCOL_ERROR);
                    channelHandlerContext.writeAndFlush(defaultSpdyRstStreamFrame);
                    return;
                }
            }
            defaultSpdyRstStreamFrame2 = new DefaultSpdyRstStreamFrame(iStreamId2, SpdyStreamStatus.INTERNAL_ERROR);
        } else {
            if (!(spdyFrame instanceof SpdyHeadersFrame)) {
                if (!(spdyFrame instanceof SpdyDataFrame)) {
                    if (spdyFrame instanceof SpdyRstStreamFrame) {
                        removeMessage(((SpdyRstStreamFrame) spdyFrame).streamId());
                        return;
                    }
                    return;
                }
                SpdyDataFrame spdyDataFrame = (SpdyDataFrame) spdyFrame;
                int iStreamId3 = spdyDataFrame.streamId();
                FullHttpMessage message = getMessage(iStreamId3);
                if (message == null) {
                    return;
                }
                ByteBuf byteBufContent = message.content();
                if (byteBufContent.readableBytes() > this.maxContentLength - spdyDataFrame.content().readableBytes()) {
                    removeMessage(iStreamId3);
                    throw new TooLongFrameException(a.y(a.F("HTTP content length exceeded "), this.maxContentLength, " bytes."));
                }
                ByteBuf byteBufContent2 = spdyDataFrame.content();
                byteBufContent.writeBytes(byteBufContent2, byteBufContent2.readerIndex(), byteBufContent2.readableBytes());
                if (spdyDataFrame.isLast()) {
                    HttpUtil.setContentLength(message, byteBufContent.readableBytes());
                    removeMessage(iStreamId3);
                    list.add(message);
                    return;
                }
                return;
            }
            SpdyHeadersFrame spdyHeadersFrame = (SpdyHeadersFrame) spdyFrame;
            int iStreamId4 = spdyHeadersFrame.streamId();
            FullHttpMessage message2 = getMessage(iStreamId4);
            if (message2 != null) {
                if (!spdyHeadersFrame.isTruncated()) {
                    for (Map.Entry<CharSequence, CharSequence> entry : spdyHeadersFrame.headers()) {
                        message2.headers().add(entry.getKey(), entry.getValue());
                    }
                }
                if (spdyHeadersFrame.isLast()) {
                    HttpUtil.setContentLength(message2, message2.content().readableBytes());
                    removeMessage(iStreamId4);
                    list.add(message2);
                    return;
                }
                return;
            }
            if (!SpdyCodecUtil.isServerId(iStreamId4)) {
                return;
            }
            if (!spdyHeadersFrame.isTruncated()) {
                try {
                    FullHttpResponse fullHttpResponseCreateHttpResponse2 = createHttpResponse(spdyHeadersFrame, channelHandlerContext.alloc(), this.validateHeaders);
                    fullHttpResponseCreateHttpResponse2.headers().setInt(SpdyHttpHeaders.Names.STREAM_ID, iStreamId4);
                    if (spdyHeadersFrame.isLast()) {
                        HttpUtil.setContentLength(fullHttpResponseCreateHttpResponse2, 0L);
                        list.add(fullHttpResponseCreateHttpResponse2);
                    } else {
                        putMessage(iStreamId4, fullHttpResponseCreateHttpResponse2);
                    }
                    return;
                } catch (Throwable unused4) {
                    channelHandlerContext.writeAndFlush(new DefaultSpdyRstStreamFrame(iStreamId4, SpdyStreamStatus.PROTOCOL_ERROR));
                    return;
                }
            }
            defaultSpdyRstStreamFrame2 = new DefaultSpdyRstStreamFrame(iStreamId4, SpdyStreamStatus.INTERNAL_ERROR);
        }
        channelHandlerContext.writeAndFlush(defaultSpdyRstStreamFrame2);
    }

    @Override // io.netty.handler.codec.MessageToMessageDecoder
    public /* bridge */ /* synthetic */ void decode(ChannelHandlerContext channelHandlerContext, SpdyFrame spdyFrame, List list) {
        decode2(channelHandlerContext, spdyFrame, (List<Object>) list);
    }

    public FullHttpMessage getMessage(int i2) {
        return this.messageMap.get(Integer.valueOf(i2));
    }

    public FullHttpMessage putMessage(int i2, FullHttpMessage fullHttpMessage) {
        return this.messageMap.put(Integer.valueOf(i2), fullHttpMessage);
    }

    public FullHttpMessage removeMessage(int i2) {
        return this.messageMap.remove(Integer.valueOf(i2));
    }
}