package com.czhj.wire.okio;
import com.umeng.analytics.pro.cb;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.Serializable;
import java.lang.reflect.Field;
import java.nio.ByteBuffer;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import kotlin.UByte;
public class ByteString implements Serializable, Comparable<ByteString> {
public static final ByteString EMPTY = of(new byte[0]);
static final char[] a = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
private static final long serialVersionUID = 1;
final byte[] b;
transient int c;
transient String d;
ByteString(byte[] bArr) {
this.b = bArr;
}
private static int a(char c2) {
if (c2 >= '0' && c2 <= '9') {
return c2 - '0';
}
char c3 = 'a';
if (c2 < 'a' || c2 > 'f') {
c3 = 'A';
if (c2 < 'A' || c2 > 'F') {
throw new IllegalArgumentException("Unexpected hex digit: " + c2);
}
}
return (c2 - c3) + 10;
}
static int a(String str, int i) {
int length = str.length();
int i2 = 0;
int i3 = 0;
while (i2 < length) {
if (i3 == i) {
return i2;
}
int codePointAt = str.codePointAt(i2);
if ((Character.isISOControl(codePointAt) && codePointAt != 10 && codePointAt != 13) || codePointAt == 65533) {
return -1;
}
i3++;
i2 += Character.charCount(codePointAt);
}
return str.length();
}
private ByteString a(String str) {
try {
return of(MessageDigest.getInstance(str).digest(this.b));
} catch (NoSuchAlgorithmException e) {
throw new AssertionError(e);
}
}
public static ByteString decodeBase64(String str) {
if (str != null) {
byte[] decode = Base64.decode(str);
if (decode != null) {
return new ByteString(decode);
}
return null;
}
throw new IllegalArgumentException("base64 == null");
}
public static ByteString decodeHex(String str) {
if (str == null) {
throw new IllegalArgumentException("hex == null");
} else if (str.length() % 2 == 0) {
int length = str.length() / 2;
byte[] bArr = new byte[length];
for (int i = 0; i < length; i++) {
int i2 = i * 2;
bArr[i] = (byte) ((a(str.charAt(i2)) << 4) + a(str.charAt(i2 + 1)));
}
return of(bArr);
} else {
throw new IllegalArgumentException("Unexpected hex string: " + str);
}
}
public static ByteString encodeUtf8(String str) {
if (str != null) {
ByteString byteString = new ByteString(str.getBytes(Util.UTF_8));
byteString.d = str;
return byteString;
}
throw new IllegalArgumentException("s == null");
}
public static ByteString of(byte... bArr) {
if (bArr != null) {
return new ByteString((byte[]) bArr.clone());
}
throw new IllegalArgumentException("data == null");
}
public static ByteString of(byte[] bArr, int i, int i2) {
if (bArr != null) {
Util.checkOffsetAndCount((long) bArr.length, (long) i, (long) i2);
byte[] bArr2 = new byte[i2];
System.arraycopy(bArr, i, bArr2, 0, i2);
return new ByteString(bArr2);
}
throw new IllegalArgumentException("data == null");
}
public static ByteString read(InputStream inputStream, int i) throws IOException {
if (inputStream == null) {
throw new IllegalArgumentException("in == null");
} else if (i >= 0) {
byte[] bArr = new byte[i];
int i2 = 0;
while (i2 < i) {
int read = inputStream.read(bArr, i2, i - i2);
if (read != -1) {
i2 += read;
} else {
throw new EOFException();
}
}
return new ByteString(bArr);
} else {
throw new IllegalArgumentException("byteCount < 0: " + i);
}
}
private void readObject(ObjectInputStream objectInputStream) throws IOException {
ByteString read = read(objectInputStream, objectInputStream.readInt());
try {
Field declaredField = ByteString.class.getDeclaredField("b");
declaredField.setAccessible(true);
declaredField.set(this, read.b);
} catch (NoSuchFieldException unused) {
throw new AssertionError();
} catch (IllegalAccessException unused2) {
throw new AssertionError();
}
}
private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
objectOutputStream.writeInt(this.b.length);
objectOutputStream.write(this.b);
}
/* access modifiers changed from: package-private */
public void a(Buffer buffer) {
byte[] bArr = this.b;
buffer.write(bArr, 0, bArr.length);
}
/* access modifiers changed from: package-private */
public byte[] a() {
return this.b;
}
public ByteBuffer asByteBuffer() {
return ByteBuffer.wrap(this.b).asReadOnlyBuffer();
}
public String base64() {
return Base64.encode(this.b);
}
public String base64Url() {
return Base64.encodeUrl(this.b);
}
public int compareTo(ByteString byteString) {
int size = size();
int size2 = byteString.size();
int min = Math.min(size, size2);
for (int i = 0; i < min; i++) {
int i2 = getByte(i) & UByte.MAX_VALUE;
int i3 = byteString.getByte(i) & UByte.MAX_VALUE;
if (i2 != i3) {
return i2 < i3 ? -1 : 1;
}
}
if (size == size2) {
return 0;
}
return size < size2 ? -1 : 1;
}
public final boolean endsWith(ByteString byteString) {
return rangeEquals(size() - byteString.size(), byteString, 0, byteString.size());
}
public final boolean endsWith(byte[] bArr) {
return rangeEquals(size() - bArr.length, bArr, 0, bArr.length);
}
public boolean equals(Object obj) {
if (obj == this) {
return true;
}
if (obj instanceof ByteString) {
ByteString byteString = (ByteString) obj;
int size = byteString.size();
byte[] bArr = this.b;
return size == bArr.length && byteString.rangeEquals(0, bArr, 0, bArr.length);
}
}
public byte getByte(int i) {
return this.b[i];
}
public int hashCode() {
int i = this.c;
if (i != 0) {
return i;
}
int hashCode = Arrays.hashCode(this.b);
this.c = hashCode;
return hashCode;
}
public String hex() {
byte[] bArr = this.b;
char[] cArr = new char[(bArr.length * 2)];
int i = 0;
for (byte b2 : bArr) {
int i2 = i + 1;
char[] cArr2 = a;
cArr[i] = cArr2[(b2 >> 4) & 15];
i = i2 + 1;
cArr[i2] = cArr2[b2 & cb.m];
}
return new String(cArr);
}
public final int indexOf(ByteString byteString) {
return indexOf(byteString.a(), 0);
}
public final int indexOf(ByteString byteString, int i) {
return indexOf(byteString.a(), i);
}
public final int indexOf(byte[] bArr) {
return indexOf(bArr, 0);
}
public int indexOf(byte[] bArr, int i) {
int length = this.b.length - bArr.length;
for (int max = Math.max(i, 0); max <= length; max++) {
if (Util.arrayRangeEquals(this.b, max, bArr, 0, bArr.length)) {
return max;
}
}
return -1;
}
public final int lastIndexOf(ByteString byteString) {
return lastIndexOf(byteString.a(), size());
}
public final int lastIndexOf(ByteString byteString, int i) {
return lastIndexOf(byteString.a(), i);
}
public final int lastIndexOf(byte[] bArr) {
return lastIndexOf(bArr, size());
}
public int lastIndexOf(byte[] bArr, int i) {
for (int min = Math.min(i, this.b.length - bArr.length); min >= 0; min--) {
if (Util.arrayRangeEquals(this.b, min, bArr, 0, bArr.length)) {
return min;
}
}
return -1;
}
public ByteString md5() {
return a("MD5");
}
public boolean rangeEquals(int i, ByteString byteString, int i2, int i3) {
return byteString.rangeEquals(i2, this.b, i, i3);
}
public boolean rangeEquals(int i, byte[] bArr, int i2, int i3) {
if (i >= 0) {
byte[] bArr2 = this.b;
return i <= bArr2.length - i3 && i2 >= 0 && i2 <= bArr.length - i3 && Util.arrayRangeEquals(bArr2, i, bArr, i2, i3);
}
}
public ByteString sha1() {
return a("SHA-1");
}
public ByteString sha256() {
return a("SHA-256");
}
public int size() {
return this.b.length;
}
public final boolean startsWith(ByteString byteString) {
return rangeEquals(0, byteString, 0, byteString.size());
}
public final boolean startsWith(byte[] bArr) {
return rangeEquals(0, bArr, 0, bArr.length);
}
public ByteString substring(int i) {
return substring(i, this.b.length);
}
public ByteString substring(int i, int i2) {
if (i >= 0) {
byte[] bArr = this.b;
if (i2 <= bArr.length) {
int i3 = i2 - i;
if (i3 < 0) {
throw new IllegalArgumentException("endIndex < beginIndex");
} else if (i == 0 && i2 == bArr.length) {
return this;
} else {
byte[] bArr2 = new byte[i3];
System.arraycopy(bArr, i, bArr2, 0, i3);
return new ByteString(bArr2);
}
} else {
throw new IllegalArgumentException("endIndex > length(" + this.b.length + ")");
}
} else {
throw new IllegalArgumentException("beginIndex < 0");
}
}
public ByteString toAsciiLowercase() {
int i = 0;
while (true) {
byte[] bArr = this.b;
if (i >= bArr.length) {
return this;
}
byte b2 = bArr[i];
if (b2 < 65 || b2 > 90) {
i++;
} else {
byte[] bArr2 = (byte[]) bArr.clone();
bArr2[i] = (byte) (b2 + 32);
for (int i2 = i + 1; i2 < bArr2.length; i2++) {
byte b3 = bArr2[i2];
if (b3 >= 65 && b3 <= 90) {
bArr2[i2] = (byte) (b3 + 32);
}
}
return new ByteString(bArr2);
}
}
}
public ByteString toAsciiUppercase() {
int i = 0;
while (true) {
byte[] bArr = this.b;
if (i >= bArr.length) {
return this;
}
byte b2 = bArr[i];
if (b2 < 97 || b2 > 122) {
i++;
} else {
byte[] bArr2 = (byte[]) bArr.clone();
bArr2[i] = (byte) (b2 - 32);
for (int i2 = i + 1; i2 < bArr2.length; i2++) {
byte b3 = bArr2[i2];
if (b3 >= 97 && b3 <= 122) {
bArr2[i2] = (byte) (b3 - 32);
}
}
return new ByteString(bArr2);
}
}
}
public byte[] toByteArray() {
return (byte[]) this.b.clone();
}
public String toString() {
StringBuilder sb;
StringBuilder sb2;
if (this.b.length == 0) {
return "[size=0]";
}
String utf8 = utf8();
int a2 = a(utf8, 64);
if (a2 == -1) {
if (this.b.length <= 64) {
sb2 = new StringBuilder();
sb2.append("[hex=");
sb2.append(hex());
sb2.append("]");
} else {
sb2 = new StringBuilder();
sb2.append("[size=");
sb2.append(this.b.length);
sb2.append(" hex=");
sb2.append(substring(0, 64).hex());
sb2.append("…]");
}
return sb2.toString();
}
String replace = utf8.substring(0, a2).replace("\\", "\\\\").replace("\n", "\\n").replace("\r", "\\r");
if (a2 < utf8.length()) {
sb = new StringBuilder();
sb.append("[size=");
sb.append(this.b.length);
sb.append(" text=");
sb.append(replace);
sb.append("…]");
} else {
sb = new StringBuilder();
sb.append("[text=");
sb.append(replace);
sb.append("]");
}
return sb.toString();
}
public String utf8() {
String str = this.d;
if (str != null) {
return str;
}
String str2 = new String(this.b, Util.UTF_8);
this.d = str2;
return str2;
}
public void write(OutputStream outputStream) throws IOException {
if (outputStream != null) {
outputStream.write(this.b);
return;
}
throw new IllegalArgumentException("out == null");
}
}