package io.netty.handler.codec.http;

import g.a.a.a.a;
import io.netty.handler.codec.http.websocketx.WebSocketServerHandshaker;
import io.netty.util.AsciiString;
import io.netty.util.CharsetUtil;
import io.netty.util.NetUtil;
import java.net.InetSocketAddress;
import java.net.URI;
import java.nio.charset.Charset;
import java.nio.charset.UnsupportedCharsetException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;

/* JADX INFO: loaded from: classes.dex */
public final class HttpUtil {
    private static final AsciiString CHARSET_EQUALS = AsciiString.of(((Object) HttpHeaderValues.CHARSET) + "=");
    private static final AsciiString SEMICOLON = AsciiString.cached(";");

    private HttpUtil() {
    }

    public static String formatHostnameForHttp(InetSocketAddress inetSocketAddress) {
        String hostname = NetUtil.getHostname(inetSocketAddress);
        if (!NetUtil.isValidIpV6Address(hostname)) {
            return hostname;
        }
        if (!inetSocketAddress.isUnresolved()) {
            hostname = NetUtil.toAddressString(inetSocketAddress.getAddress());
        }
        return a.u("[", hostname, "]");
    }

    public static Charset getCharset(HttpMessage httpMessage) {
        return getCharset(httpMessage, CharsetUtil.ISO_8859_1);
    }

    public static Charset getCharset(HttpMessage httpMessage, Charset charset) {
        String str = httpMessage.headers().get(HttpHeaderNames.CONTENT_TYPE);
        return str != null ? getCharset(str, charset) : charset;
    }

    public static Charset getCharset(CharSequence charSequence) {
        return charSequence != null ? getCharset(charSequence, CharsetUtil.ISO_8859_1) : CharsetUtil.ISO_8859_1;
    }

    public static Charset getCharset(CharSequence charSequence, Charset charset) {
        CharSequence charsetAsSequence;
        if (charSequence != null && (charsetAsSequence = getCharsetAsSequence(charSequence)) != null) {
            try {
                return Charset.forName(charsetAsSequence.toString());
            } catch (UnsupportedCharsetException unused) {
            }
        }
        return charset;
    }

    public static CharSequence getCharsetAsSequence(HttpMessage httpMessage) {
        String str = httpMessage.headers().get(HttpHeaderNames.CONTENT_TYPE);
        if (str != null) {
            return getCharsetAsSequence(str);
        }
        return null;
    }

    public static CharSequence getCharsetAsSequence(CharSequence charSequence) {
        int length;
        Objects.requireNonNull(charSequence, "contentTypeValue");
        AsciiString asciiString = CHARSET_EQUALS;
        int iIndexOfIgnoreCaseAscii = AsciiString.indexOfIgnoreCaseAscii(charSequence, asciiString, 0);
        if (iIndexOfIgnoreCaseAscii == -1 || (length = asciiString.length() + iIndexOfIgnoreCaseAscii) >= charSequence.length()) {
            return null;
        }
        return charSequence.subSequence(length, charSequence.length());
    }

    @Deprecated
    public static CharSequence getCharsetAsString(HttpMessage httpMessage) {
        return getCharsetAsSequence(httpMessage);
    }

    public static int getContentLength(HttpMessage httpMessage, int i2) {
        return (int) Math.min(2147483647L, getContentLength(httpMessage, i2));
    }

    public static long getContentLength(HttpMessage httpMessage) {
        HttpHeaders httpHeadersHeaders = httpMessage.headers();
        AsciiString asciiString = HttpHeaderNames.CONTENT_LENGTH;
        String str = httpHeadersHeaders.get(asciiString);
        if (str != null) {
            return Long.parseLong(str);
        }
        long webSocketContentLength = getWebSocketContentLength(httpMessage);
        if (webSocketContentLength >= 0) {
            return webSocketContentLength;
        }
        throw new NumberFormatException("header not found: " + ((Object) asciiString));
    }

    public static long getContentLength(HttpMessage httpMessage, long j2) {
        String str = httpMessage.headers().get(HttpHeaderNames.CONTENT_LENGTH);
        if (str != null) {
            return Long.parseLong(str);
        }
        long webSocketContentLength = getWebSocketContentLength(httpMessage);
        return webSocketContentLength >= 0 ? webSocketContentLength : j2;
    }

    public static CharSequence getMimeType(HttpMessage httpMessage) {
        String str = httpMessage.headers().get(HttpHeaderNames.CONTENT_TYPE);
        if (str != null) {
            return getMimeType(str);
        }
        return null;
    }

    public static CharSequence getMimeType(CharSequence charSequence) {
        Objects.requireNonNull(charSequence, "contentTypeValue");
        int iIndexOfIgnoreCaseAscii = AsciiString.indexOfIgnoreCaseAscii(charSequence, SEMICOLON, 0);
        if (iIndexOfIgnoreCaseAscii != -1) {
            return charSequence.subSequence(0, iIndexOfIgnoreCaseAscii);
        }
        if (charSequence.length() > 0) {
            return charSequence;
        }
        return null;
    }

    private static int getWebSocketContentLength(HttpMessage httpMessage) {
        HttpHeaders httpHeadersHeaders = httpMessage.headers();
        return httpMessage instanceof HttpRequest ? (HttpMethod.GET.equals(((HttpRequest) httpMessage).method()) && httpHeadersHeaders.contains(HttpHeaderNames.SEC_WEBSOCKET_KEY1) && httpHeadersHeaders.contains(HttpHeaderNames.SEC_WEBSOCKET_KEY2)) ? 8 : -1 : ((httpMessage instanceof HttpResponse) && ((HttpResponse) httpMessage).status().code() == 101 && httpHeadersHeaders.contains(HttpHeaderNames.SEC_WEBSOCKET_ORIGIN) && httpHeadersHeaders.contains(HttpHeaderNames.SEC_WEBSOCKET_LOCATION)) ? 16 : -1;
    }

    public static boolean is100ContinueExpected(HttpMessage httpMessage) {
        if (!isExpectHeaderValid(httpMessage)) {
            return false;
        }
        return HttpHeaderValues.CONTINUE.toString().equalsIgnoreCase(httpMessage.headers().get(HttpHeaderNames.EXPECT));
    }

    public static boolean isAsteriskForm(URI uri) {
        return WebSocketServerHandshaker.SUB_PROTOCOL_WILDCARD.equals(uri.getPath()) && uri.getScheme() == null && uri.getSchemeSpecificPart() == null && uri.getHost() == null && uri.getAuthority() == null && uri.getQuery() == null && uri.getFragment() == null;
    }

    public static boolean isContentLengthSet(HttpMessage httpMessage) {
        return httpMessage.headers().contains(HttpHeaderNames.CONTENT_LENGTH);
    }

    private static boolean isExpectHeaderValid(HttpMessage httpMessage) {
        return (httpMessage instanceof HttpRequest) && httpMessage.protocolVersion().compareTo(HttpVersion.HTTP_1_1) >= 0;
    }

    public static boolean isKeepAlive(HttpMessage httpMessage) {
        String str = httpMessage.headers().get(HttpHeaderNames.CONNECTION);
        if (str == null || !HttpHeaderValues.CLOSE.contentEqualsIgnoreCase(str)) {
            return httpMessage.protocolVersion().isKeepAliveDefault() ? !HttpHeaderValues.CLOSE.contentEqualsIgnoreCase(str) : HttpHeaderValues.KEEP_ALIVE.contentEqualsIgnoreCase(str);
        }
        return false;
    }

    public static boolean isOriginForm(URI uri) {
        return uri.getScheme() == null && uri.getSchemeSpecificPart() == null && uri.getHost() == null && uri.getAuthority() == null;
    }

    public static boolean isTransferEncodingChunked(HttpMessage httpMessage) {
        return httpMessage.headers().contains((CharSequence) HttpHeaderNames.TRANSFER_ENCODING, (CharSequence) HttpHeaderValues.CHUNKED, true);
    }

    public static boolean isUnsupportedExpectation(HttpMessage httpMessage) {
        String str;
        return (!isExpectHeaderValid(httpMessage) || (str = httpMessage.headers().get(HttpHeaderNames.EXPECT)) == null || HttpHeaderValues.CONTINUE.toString().equalsIgnoreCase(str)) ? false : true;
    }

    public static void set100ContinueExpected(HttpMessage httpMessage, boolean z2) {
        HttpHeaders httpHeadersHeaders = httpMessage.headers();
        if (z2) {
            httpHeadersHeaders.set(HttpHeaderNames.EXPECT, HttpHeaderValues.CONTINUE);
        } else {
            httpHeadersHeaders.remove(HttpHeaderNames.EXPECT);
        }
    }

    public static void setContentLength(HttpMessage httpMessage, long j2) {
        httpMessage.headers().set(HttpHeaderNames.CONTENT_LENGTH, Long.valueOf(j2));
    }

    public static void setKeepAlive(HttpHeaders httpHeaders, HttpVersion httpVersion, boolean z2) {
        AsciiString asciiString;
        AsciiString asciiString2;
        if (httpVersion.isKeepAliveDefault()) {
            if (!z2) {
                asciiString = HttpHeaderNames.CONNECTION;
                asciiString2 = HttpHeaderValues.CLOSE;
                httpHeaders.set(asciiString, asciiString2);
                return;
            }
            httpHeaders.remove(HttpHeaderNames.CONNECTION);
        }
        if (z2) {
            asciiString = HttpHeaderNames.CONNECTION;
            asciiString2 = HttpHeaderValues.KEEP_ALIVE;
            httpHeaders.set(asciiString, asciiString2);
            return;
        }
        httpHeaders.remove(HttpHeaderNames.CONNECTION);
    }

    public static void setKeepAlive(HttpMessage httpMessage, boolean z2) {
        setKeepAlive(httpMessage.headers(), httpMessage.protocolVersion(), z2);
    }

    public static void setTransferEncodingChunked(HttpMessage httpMessage, boolean z2) {
        HttpHeaders httpHeadersHeaders;
        AsciiString asciiString;
        if (z2) {
            httpMessage.headers().set(HttpHeaderNames.TRANSFER_ENCODING, HttpHeaderValues.CHUNKED);
            httpHeadersHeaders = httpMessage.headers();
            asciiString = HttpHeaderNames.CONTENT_LENGTH;
        } else {
            List<String> all = httpMessage.headers().getAll(HttpHeaderNames.TRANSFER_ENCODING);
            if (all.isEmpty()) {
                return;
            }
            ArrayList arrayList = new ArrayList(all);
            Iterator it = arrayList.iterator();
            while (it.hasNext()) {
                if (HttpHeaderValues.CHUNKED.contentEqualsIgnoreCase((CharSequence) it.next())) {
                    it.remove();
                }
            }
            boolean zIsEmpty = arrayList.isEmpty();
            httpHeadersHeaders = httpMessage.headers();
            if (!zIsEmpty) {
                httpHeadersHeaders.set((CharSequence) HttpHeaderNames.TRANSFER_ENCODING, (Iterable<?>) arrayList);
                return;
            }
            asciiString = HttpHeaderNames.TRANSFER_ENCODING;
        }
        httpHeadersHeaders.remove(asciiString);
    }
}