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 */
class SSTRecord extends RecordData {
    private int[] continuationBreaks;
    private String[] strings;
    private int totalStrings;
    private int uniqueStrings;

    private static class BooleanHolder {
        public boolean value;

        private BooleanHolder() {
        }
    }

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

    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 b = bArr[i8];
            int i9 = i8 + 1;
            boolean z = (b & 4) != 0;
            boolean z2 = (b & 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 = (b & 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];
    }
}