package defpackage;

import java.io.ByteArrayInputStream;
import java.io.DataInput;
import java.io.DataInputStream;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteOrder;

/* renamed from: ᵕˆᵎˌ, reason: contains not printable characters */
/* loaded from: classes3.dex */
public class C2280 extends InputStream implements DataInput {

    /* renamed from: ᵢˇᵭ, reason: contains not printable characters */
    public ByteOrder f8914;

    /* renamed from: ᵧᵾˀˈ, reason: contains not printable characters */
    public final DataInputStream f8915;

    /* renamed from: ᵾᵬ, reason: contains not printable characters */
    public byte[] f8916;

    /* renamed from: ᵿʗᵝʽ, reason: contains not printable characters */
    public int f8917;

    /* renamed from: ᵤᵙᵷ, reason: contains not printable characters */
    public static final ByteOrder f8913 = ByteOrder.LITTLE_ENDIAN;

    /* renamed from: ᵡⁱᵥ, reason: contains not printable characters */
    public static final ByteOrder f8912 = ByteOrder.BIG_ENDIAN;

    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
    public C2280(InputStream inputStream) {
        this(inputStream, 0);
        ByteOrder byteOrder = ByteOrder.BIG_ENDIAN;
    }

    public C2280(InputStream inputStream, int i) {
        ByteOrder byteOrder = ByteOrder.BIG_ENDIAN;
        this.f8914 = byteOrder;
        DataInputStream dataInputStream = new DataInputStream(inputStream);
        this.f8915 = dataInputStream;
        dataInputStream.mark(0);
        this.f8917 = 0;
        this.f8914 = byteOrder;
    }

    public C2280(byte[] bArr) {
        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bArr);
        ByteOrder byteOrder = ByteOrder.BIG_ENDIAN;
        this(byteArrayInputStream, 0);
    }

    @Override // java.io.InputStream
    public final int available() {
        return this.f8915.available();
    }

    @Override // java.io.InputStream
    public final void mark(int i) {
        throw new UnsupportedOperationException("Mark is currently unsupported");
    }

    @Override // java.io.InputStream
    public final int read() {
        this.f8917++;
        return this.f8915.read();
    }

    @Override // java.io.InputStream
    public final int read(byte[] bArr, int i, int i2) throws IOException {
        int i3 = this.f8915.read(bArr, i, i2);
        this.f8917 += i3;
        return i3;
    }

    @Override // java.io.DataInput
    public final boolean readBoolean() {
        this.f8917++;
        return this.f8915.readBoolean();
    }

    @Override // java.io.DataInput
    public final byte readByte() throws IOException {
        this.f8917++;
        int i = this.f8915.read();
        if (i >= 0) {
            return (byte) i;
        }
        throw new EOFException();
    }

    @Override // java.io.DataInput
    public final char readChar() {
        this.f8917 += 2;
        return this.f8915.readChar();
    }

    @Override // java.io.DataInput
    public final double readDouble() {
        return Double.longBitsToDouble(readLong());
    }

    @Override // java.io.DataInput
    public final float readFloat() {
        return Float.intBitsToFloat(readInt());
    }

    @Override // java.io.DataInput
    public final void readFully(byte[] bArr) throws IOException {
        this.f8917 += bArr.length;
        this.f8915.readFully(bArr);
    }

    @Override // java.io.DataInput
    public final void readFully(byte[] bArr, int i, int i2) throws IOException {
        this.f8917 += i2;
        this.f8915.readFully(bArr, i, i2);
    }

    @Override // java.io.DataInput
    public final int readInt() throws IOException {
        this.f8917 += 4;
        DataInputStream dataInputStream = this.f8915;
        int i = dataInputStream.read();
        int i2 = dataInputStream.read();
        int i3 = dataInputStream.read();
        int i4 = dataInputStream.read();
        if ((i | i2 | i3 | i4) < 0) {
            throw new EOFException();
        }
        ByteOrder byteOrder = this.f8914;
        if (byteOrder == f8913) {
            return (i4 << 24) + (i3 << 16) + (i2 << 8) + i;
        }
        if (byteOrder == f8912) {
            return (i << 24) + (i2 << 16) + (i3 << 8) + i4;
        }
        ᵨᴵᵺ.ᵸʓᵠ(this.f8914, "Invalid byte order: ");
        return 0;
    }

    @Override // java.io.DataInput
    public final String readLine() {
        return null;
    }

    @Override // java.io.DataInput
    public final long readLong() throws IOException {
        this.f8917 += 8;
        DataInputStream dataInputStream = this.f8915;
        int i = dataInputStream.read();
        int i2 = dataInputStream.read();
        int i3 = dataInputStream.read();
        int i4 = dataInputStream.read();
        int i5 = dataInputStream.read();
        int i6 = dataInputStream.read();
        int i7 = dataInputStream.read();
        int i8 = dataInputStream.read();
        if ((i | i2 | i3 | i4 | i5 | i6 | i7 | i8) < 0) {
            throw new EOFException();
        }
        ByteOrder byteOrder = this.f8914;
        if (byteOrder == f8913) {
            return (i8 << 56) + (i7 << 48) + (i6 << 40) + (i5 << 32) + (i4 << 24) + (i3 << 16) + (i2 << 8) + i;
        }
        if (byteOrder == f8912) {
            return (i << 56) + (i2 << 48) + (i3 << 40) + (i4 << 32) + (i5 << 24) + (i6 << 16) + (i7 << 8) + i8;
        }
        ᵨᴵᵺ.ᵸʓᵠ(this.f8914, "Invalid byte order: ");
        return 0L;
    }

    @Override // java.io.DataInput
    public final short readShort() throws IOException {
        this.f8917 += 2;
        DataInputStream dataInputStream = this.f8915;
        int i = dataInputStream.read();
        int i2 = dataInputStream.read();
        if ((i | i2) < 0) {
            throw new EOFException();
        }
        ByteOrder byteOrder = this.f8914;
        if (byteOrder == f8913) {
            return (short) ((i2 << 8) + i);
        }
        if (byteOrder == f8912) {
            return (short) ((i << 8) + i2);
        }
        ᵨᴵᵺ.ᵸʓᵠ(this.f8914, "Invalid byte order: ");
        return (short) 0;
    }

    @Override // java.io.DataInput
    public final String readUTF() {
        this.f8917 += 2;
        return this.f8915.readUTF();
    }

    @Override // java.io.DataInput
    public final int readUnsignedByte() {
        this.f8917++;
        return this.f8915.readUnsignedByte();
    }

    @Override // java.io.DataInput
    public final int readUnsignedShort() throws IOException {
        this.f8917 += 2;
        DataInputStream dataInputStream = this.f8915;
        int i = dataInputStream.read();
        int i2 = dataInputStream.read();
        if ((i | i2) < 0) {
            throw new EOFException();
        }
        ByteOrder byteOrder = this.f8914;
        if (byteOrder == f8913) {
            return (i2 << 8) + i;
        }
        if (byteOrder == f8912) {
            return (i << 8) + i2;
        }
        ᵨᴵᵺ.ᵸʓᵠ(this.f8914, "Invalid byte order: ");
        return 0;
    }

    @Override // java.io.InputStream
    public final void reset() {
        throw new UnsupportedOperationException("Reset is currently unsupported");
    }

    @Override // java.io.DataInput
    public final int skipBytes(int i) {
        throw new UnsupportedOperationException("skipBytes is currently unsupported");
    }

    /* renamed from: ᵥᵯˎ, reason: contains not printable characters */
    public final void m5981(int i) throws IOException {
        int i2 = 0;
        while (i2 < i) {
            int i3 = i - i2;
            DataInputStream dataInputStream = this.f8915;
            int iSkip = (int) dataInputStream.skip(i3);
            if (iSkip <= 0) {
                if (this.f8916 == null) {
                    this.f8916 = new byte[8192];
                }
                iSkip = dataInputStream.read(this.f8916, 0, Math.min(8192, i3));
                if (iSkip == -1) {
                    throw new EOFException(AbstractC3915.m8596(i, "Reached EOF while skipping ", " bytes."));
                }
            }
            i2 += iSkip;
        }
        this.f8917 += i2;
    }
}