package jxl.read.biff;

import common.Assert;
import jxl.WorkbookSettings;
import jxl.biff.IntegerHelper;
import jxl.biff.RecordData;
import jxl.biff.StringHelper;

/* JADX INFO: loaded from: classes.dex */
public class SSTRecord extends RecordData {
    private int[] continuationBreaks;
    private String[] strings;
    private int totalStrings;
    private int uniqueStrings;

    public static class BooleanHolder {
        public boolean value;

        private BooleanHolder() {
        }
    }

    public static class ByteArrayHolder {
        public byte[] bytes;

        private ByteArrayHolder() {
        }
    }

    public SSTRecord(Record record, Record[] recordArr, WorkbookSettings workbookSettings) {
        super(record);
        int length = 0;
        for (Record record2 : recordArr) {
            length += record2.getLength();
        }
        byte[] bArr = new byte[getRecord().getLength() + length];
        System.arraycopy(getRecord().getData(), 0, bArr, 0, getRecord().getLength());
        int length2 = getRecord().getLength() + 0;
        this.continuationBreaks = new int[recordArr.length];
        for (int i2 = 0; i2 < recordArr.length; i2++) {
            Record record3 = recordArr[i2];
            System.arraycopy(record3.getData(), 0, bArr, length2, record3.getLength());
            this.continuationBreaks[i2] = length2;
            length2 += record3.getLength();
        }
        this.totalStrings = IntegerHelper.getInt(bArr[0], bArr[1], bArr[2], bArr[3]);
        int i3 = IntegerHelper.getInt(bArr[4], bArr[5], bArr[6], bArr[7]);
        this.uniqueStrings = i3;
        this.strings = new String[i3];
        readStrings(bArr, 8, workbookSettings);
    }

    private int getChars(byte[] bArr, ByteArrayHolder byteArrayHolder, int i2, BooleanHolder booleanHolder, int i3) {
        int[] iArr;
        if (booleanHolder.value) {
            byteArrayHolder.bytes = new byte[i3];
        } else {
            byteArrayHolder.bytes = new byte[i3 * 2];
        }
        boolean z = false;
        int i4 = 0;
        while (true) {
            iArr = this.continuationBreaks;
            if (i4 >= iArr.length || z) {
                break;
            }
            z = i2 <= iArr[i4] && byteArrayHolder.bytes.length + i2 > iArr[i4];
            if (!z) {
                i4++;
            }
        }
        if (z) {
            int i5 = iArr[i4] - i2;
            System.arraycopy(bArr, i2, byteArrayHolder.bytes, 0, i5);
            return i5 + getContinuedString(bArr, byteArrayHolder, i5, i4, booleanHolder, i3 - (booleanHolder.value ? i5 : i5 / 2));
        }
        byte[] bArr2 = byteArrayHolder.bytes;
        System.arraycopy(bArr, i2, bArr2, 0, bArr2.length);
        return byteArrayHolder.bytes.length;
    }

    private int getContinuedString(byte[] bArr, ByteArrayHolder byteArrayHolder, int i2, int i3, BooleanHolder booleanHolder, int i4) {
        int i5;
        int i6 = i3;
        int i7 = i4;
        int i8 = this.continuationBreaks[i3];
        int i9 = 0;
        int i10 = i2;
        while (i7 > 0) {
            Assert.verify(i6 < this.continuationBreaks.length, "continuation break index");
            boolean z = booleanHolder.value;
            if (z && bArr[i8] == 0) {
                int[] iArr = this.continuationBreaks;
                int iMin = i6 == iArr.length - 1 ? i7 : Math.min(i7, (iArr[i6 + 1] - i8) - 1);
                System.arraycopy(bArr, i8 + 1, byteArrayHolder.bytes, i10, iMin);
                i10 += iMin;
                i7 -= iMin;
                booleanHolder.value = true;
                i9 = iMin + 1 + i9;
            } else {
                if (!z && bArr[i8] != 0) {
                    int[] iArr2 = this.continuationBreaks;
                    int iMin2 = i6 == iArr2.length - 1 ? i7 * 2 : Math.min(i7 * 2, (iArr2[i6 + 1] - i8) - 1);
                    System.arraycopy(bArr, i8 + 1, byteArrayHolder.bytes, i10, iMin2);
                    i10 += iMin2;
                    i5 = iMin2 + 1 + i9;
                    i7 -= iMin2 / 2;
                    booleanHolder.value = false;
                } else if (z || bArr[i8] != 0) {
                    byte[] bArr2 = byteArrayHolder.bytes;
                    int i11 = i10 * 2;
                    int iMin3 = i7 * 2;
                    byteArrayHolder.bytes = new byte[i11 + iMin3];
                    for (int i12 = 0; i12 < i10; i12++) {
                        byteArrayHolder.bytes[i12 * 2] = bArr2[i12];
                    }
                    int[] iArr3 = this.continuationBreaks;
                    if (i6 != iArr3.length - 1) {
                        iMin3 = Math.min(iMin3, (iArr3[i6 + 1] - i8) - 1);
                    }
                    System.arraycopy(bArr, i8 + 1, byteArrayHolder.bytes, i11, iMin3);
                    i7 -= iMin3 / 2;
                    booleanHolder.value = false;
                    i9 = iMin3 + 1 + i9;
                    i10 = i11 + iMin3;
                } else {
                    int[] iArr4 = this.continuationBreaks;
                    int iMin4 = i6 == iArr4.length - 1 ? i7 : Math.min(i7, (iArr4[i6 + 1] - i8) - 1);
                    for (int i13 = 0; i13 < iMin4; i13++) {
                        byteArrayHolder.bytes[i10] = bArr[i8 + i13 + 1];
                        i10 += 2;
                    }
                    i5 = iMin4 + 1 + i9;
                    i7 -= iMin4;
                    booleanHolder.value = false;
                }
                i9 = i5;
            }
            i6++;
            int[] iArr5 = this.continuationBreaks;
            if (i6 < iArr5.length) {
                i8 = iArr5[i6];
            }
        }
        return i9;
    }

    private void readStrings(byte[] bArr, int i2, WorkbookSettings workbookSettings) {
        int i3 = i2;
        int i4 = 0;
        int i5 = 0;
        int i6 = 0;
        while (i6 < this.uniqueStrings) {
            int i7 = IntegerHelper.getInt(bArr[i3], bArr[i3 + 1]);
            int i8 = i3 + 2;
            byte b2 = bArr[i8];
            int i9 = i8 + 1;
            boolean z = (b2 & 4) != 0;
            boolean z2 = (b2 & 8) != 0;
            if (z2) {
                i4 = IntegerHelper.getInt(bArr[i9], bArr[i9 + 1]);
                i9 += 2;
            }
            int i10 = i4;
            if (z) {
                i5 = IntegerHelper.getInt(bArr[i9], bArr[i9 + 1], bArr[i9 + 2], bArr[i9 + 3]);
                i9 += 4;
            }
            int i11 = i9;
            int i12 = i5;
            boolean z3 = (b2 & 1) == 0;
            ByteArrayHolder byteArrayHolder = new ByteArrayHolder();
            BooleanHolder booleanHolder = new BooleanHolder();
            booleanHolder.value = z3;
            int chars = i11 + getChars(bArr, byteArrayHolder, i11, booleanHolder, i7);
            this.strings[i6] = booleanHolder.value ? StringHelper.getString(byteArrayHolder.bytes, i7, 0, workbookSettings) : StringHelper.getUnicodeString(byteArrayHolder.bytes, i7, 0);
            if (z2) {
                chars += i10 * 4;
            }
            if (z) {
                chars += i12;
            }
            i3 = chars;
            if (i3 > bArr.length) {
                Assert.verify(false, "pos exceeds record length");
            }
            i6++;
            i4 = i10;
            i5 = i12;
        }
    }

    public String getString(int i2) {
        Assert.verify(i2 < this.uniqueStrings);
        return this.strings[i2];
    }
}