package io.netty.handler.codec.http;

import g.a.a.a.a;
import io.netty.buffer.ByteBuf;
import io.netty.util.CharsetUtil;
import java.util.Objects;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/* JADX INFO: loaded from: classes.dex */
public class HttpVersion implements Comparable<HttpVersion> {
    private static final String HTTP_1_0_STRING = "HTTP/1.0";
    private static final String HTTP_1_1_STRING = "HTTP/1.1";
    private final byte[] bytes;
    private final boolean keepAliveDefault;
    private final int majorVersion;
    private final int minorVersion;
    private final String protocolName;
    private final String text;
    private static final Pattern VERSION_PATTERN = Pattern.compile("(\\S+)/(\\d+)\\.(\\d+)");
    public static final HttpVersion HTTP_1_0 = new HttpVersion("HTTP", 1, 0, false, true);
    public static final HttpVersion HTTP_1_1 = new HttpVersion("HTTP", 1, 1, true, true);

    public HttpVersion(String str, int i2, int i3, boolean z2) {
        this(str, i2, i3, z2, false);
    }

    private HttpVersion(String str, int i2, int i3, boolean z2, boolean z3) {
        Objects.requireNonNull(str, "protocolName");
        String upperCase = str.trim().toUpperCase();
        if (upperCase.isEmpty()) {
            throw new IllegalArgumentException("empty protocolName");
        }
        for (int i4 = 0; i4 < upperCase.length(); i4++) {
            if (Character.isISOControl(upperCase.charAt(i4)) || Character.isWhitespace(upperCase.charAt(i4))) {
                throw new IllegalArgumentException("invalid character in protocolName");
            }
        }
        if (i2 < 0) {
            throw new IllegalArgumentException("negative majorVersion");
        }
        if (i3 < 0) {
            throw new IllegalArgumentException("negative minorVersion");
        }
        this.protocolName = upperCase;
        this.majorVersion = i2;
        this.minorVersion = i3;
        String str2 = upperCase + '/' + i2 + '.' + i3;
        this.text = str2;
        this.keepAliveDefault = z2;
        if (z3) {
            this.bytes = str2.getBytes(CharsetUtil.US_ASCII);
        } else {
            this.bytes = null;
        }
    }

    public HttpVersion(String str, boolean z2) {
        Objects.requireNonNull(str, "text");
        String upperCase = str.trim().toUpperCase();
        if (upperCase.isEmpty()) {
            throw new IllegalArgumentException("empty text");
        }
        Matcher matcher = VERSION_PATTERN.matcher(upperCase);
        if (!matcher.matches()) {
            throw new IllegalArgumentException(a.t("invalid version format: ", upperCase));
        }
        String strGroup = matcher.group(1);
        this.protocolName = strGroup;
        int i2 = Integer.parseInt(matcher.group(2));
        this.majorVersion = i2;
        int i3 = Integer.parseInt(matcher.group(3));
        this.minorVersion = i3;
        this.text = strGroup + '/' + i2 + '.' + i3;
        this.keepAliveDefault = z2;
        this.bytes = null;
    }

    public static HttpVersion valueOf(String str) {
        Objects.requireNonNull(str, "text");
        String strTrim = str.trim();
        if (strTrim.isEmpty()) {
            throw new IllegalArgumentException("text is empty (possibly HTTP/0.9)");
        }
        HttpVersion httpVersionVersion0 = version0(strTrim);
        return httpVersionVersion0 == null ? new HttpVersion(strTrim, true) : httpVersionVersion0;
    }

    private static HttpVersion version0(String str) {
        if (HTTP_1_1_STRING.equals(str)) {
            return HTTP_1_1;
        }
        if (HTTP_1_0_STRING.equals(str)) {
            return HTTP_1_0;
        }
        return null;
    }

    @Override // java.lang.Comparable
    public int compareTo(HttpVersion httpVersion) {
        int iCompareTo = protocolName().compareTo(httpVersion.protocolName());
        if (iCompareTo != 0) {
            return iCompareTo;
        }
        int iMajorVersion = majorVersion() - httpVersion.majorVersion();
        return iMajorVersion != 0 ? iMajorVersion : minorVersion() - httpVersion.minorVersion();
    }

    public void encode(ByteBuf byteBuf) {
        byte[] bArr = this.bytes;
        if (bArr == null) {
            byteBuf.writeCharSequence(this.text, CharsetUtil.US_ASCII);
        } else {
            byteBuf.writeBytes(bArr);
        }
    }

    public boolean equals(Object obj) {
        if (!(obj instanceof HttpVersion)) {
            return false;
        }
        HttpVersion httpVersion = (HttpVersion) obj;
        return minorVersion() == httpVersion.minorVersion() && majorVersion() == httpVersion.majorVersion() && protocolName().equals(httpVersion.protocolName());
    }

    public int hashCode() {
        return minorVersion() + ((majorVersion() + (protocolName().hashCode() * 31)) * 31);
    }

    public boolean isKeepAliveDefault() {
        return this.keepAliveDefault;
    }

    public int majorVersion() {
        return this.majorVersion;
    }

    public int minorVersion() {
        return this.minorVersion;
    }

    public String protocolName() {
        return this.protocolName;
    }

    public String text() {
        return this.text;
    }

    public String toString() {
        return text();
    }
}