package jxl.read.biff;

import common.Logger;
import d.b.a.a.a;
import java.util.ArrayList;
import jxl.WorkbookSettings;
import jxl.biff.BaseCompoundFile;
import jxl.biff.IntegerHelper;

/* JADX INFO: loaded from: classes.dex */
public final class CompoundFile extends BaseCompoundFile {
    public static /* synthetic */ Class class$jxl$read$biff$CompoundFile;
    private static Logger logger;
    private int[] bigBlockChain;
    private int[] bigBlockDepotBlocks;
    private byte[] data;
    private int extensionBlock;
    private int numBigBlockDepotBlocks;
    private int numExtensionBlocks;
    private ArrayList propertySets;
    private byte[] rootEntry;
    private BaseCompoundFile.PropertyStorage rootEntryPropertyStorage;
    private int rootStartBlock;
    private int sbdStartBlock;
    private WorkbookSettings settings;
    private int[] smallBlockChain;

    static {
        Class clsClass$ = class$jxl$read$biff$CompoundFile;
        if (clsClass$ == null) {
            clsClass$ = class$("jxl.read.biff.CompoundFile");
            class$jxl$read$biff$CompoundFile = clsClass$;
        }
        logger = Logger.getLogger(clsClass$);
    }

    public CompoundFile(byte[] bArr, WorkbookSettings workbookSettings) throws BiffException {
        int i2;
        this.data = bArr;
        this.settings = workbookSettings;
        int i3 = 0;
        int i4 = 0;
        while (true) {
            byte[] bArr2 = BaseCompoundFile.IDENTIFIER;
            if (i4 >= bArr2.length) {
                this.propertySets = new ArrayList();
                byte[] bArr3 = this.data;
                this.numBigBlockDepotBlocks = IntegerHelper.getInt(bArr3[44], bArr3[45], bArr3[46], bArr3[47]);
                byte[] bArr4 = this.data;
                this.sbdStartBlock = IntegerHelper.getInt(bArr4[60], bArr4[61], bArr4[62], bArr4[63]);
                byte[] bArr5 = this.data;
                this.rootStartBlock = IntegerHelper.getInt(bArr5[48], bArr5[49], bArr5[50], bArr5[51]);
                byte[] bArr6 = this.data;
                this.extensionBlock = IntegerHelper.getInt(bArr6[68], bArr6[69], bArr6[70], bArr6[71]);
                byte[] bArr7 = this.data;
                int i5 = IntegerHelper.getInt(bArr7[72], bArr7[73], bArr7[74], bArr7[75]);
                this.numExtensionBlocks = i5;
                int i6 = this.numBigBlockDepotBlocks;
                this.bigBlockDepotBlocks = new int[i6];
                int i7 = 76;
                i6 = i5 != 0 ? 109 : i6;
                for (int i8 = 0; i8 < i6; i8++) {
                    this.bigBlockDepotBlocks[i8] = IntegerHelper.getInt(bArr[i7], bArr[i7 + 1], bArr[i7 + 2], bArr[i7 + 3]);
                    i7 += 4;
                }
                while (i3 < this.numExtensionBlocks) {
                    int i9 = (this.extensionBlock + 1) * 512;
                    int iMin = Math.min(this.numBigBlockDepotBlocks - i6, 127);
                    int i10 = i6;
                    while (true) {
                        i2 = i6 + iMin;
                        if (i10 >= i2) {
                            break;
                        }
                        this.bigBlockDepotBlocks[i10] = IntegerHelper.getInt(bArr[i9], bArr[i9 + 1], bArr[i9 + 2], bArr[i9 + 3]);
                        i9 += 4;
                        i10++;
                    }
                    if (i2 < this.numBigBlockDepotBlocks) {
                        this.extensionBlock = IntegerHelper.getInt(bArr[i9], bArr[i9 + 1], bArr[i9 + 2], bArr[i9 + 3]);
                    }
                    i3++;
                    i6 = i2;
                }
                readBigBlockDepot();
                readSmallBlockDepot();
                this.rootEntry = readData(this.rootStartBlock);
                readPropertySets();
                return;
            }
            if (this.data[i4] != bArr2[i4]) {
                throw new BiffException(BiffException.unrecognizedOLEFile);
            }
            i4++;
        }
    }

    public static /* synthetic */ Class class$(String str) {
        try {
            return Class.forName(str);
        } catch (ClassNotFoundException e2) {
            throw new NoClassDefFoundError(e2.getMessage());
        }
    }

    private byte[] getBigBlockStream(BaseCompoundFile.PropertyStorage propertyStorage) {
        int i2 = propertyStorage.size;
        int i3 = i2 / 512;
        if (i2 % 512 != 0) {
            i3++;
        }
        byte[] bArr = new byte[i3 * 512];
        int i4 = propertyStorage.startBlock;
        int i5 = 0;
        while (i4 != -2 && i5 < i3) {
            System.arraycopy(this.data, (i4 + 1) * 512, bArr, i5 * 512, 512);
            i5++;
            i4 = this.bigBlockChain[i4];
        }
        if (i4 != -2 && i5 == i3) {
            logger.warn("Property storage size inconsistent with block chain.");
        }
        return bArr;
    }

    private BaseCompoundFile.PropertyStorage getPropertyStorage(String str) throws BiffException {
        BaseCompoundFile.PropertyStorage propertyStorage = null;
        boolean z = false;
        boolean z2 = false;
        for (BaseCompoundFile.PropertyStorage propertyStorage2 : this.propertySets) {
            if (propertyStorage2.name.equalsIgnoreCase(str)) {
                z = z2;
                propertyStorage = propertyStorage2;
                z2 = true;
            }
        }
        if (z) {
            Logger logger2 = logger;
            StringBuffer stringBuffer = new StringBuffer();
            stringBuffer.append("found multiple copies of property set ");
            stringBuffer.append(str);
            logger2.warn(stringBuffer.toString());
        }
        if (z2) {
            return propertyStorage;
        }
        throw new BiffException(BiffException.streamNotFound);
    }

    private byte[] getSmallBlockStream(BaseCompoundFile.PropertyStorage propertyStorage) throws BiffException {
        byte[] data = readData(this.rootEntryPropertyStorage.startBlock);
        byte[] bArr = new byte[0];
        int i2 = propertyStorage.startBlock;
        while (i2 != -2) {
            byte[] bArr2 = new byte[bArr.length + 64];
            System.arraycopy(bArr, 0, bArr2, 0, bArr.length);
            System.arraycopy(data, i2 * 64, bArr2, bArr.length, 64);
            int i3 = this.smallBlockChain[i2];
            if (i3 == -1) {
                Logger logger2 = logger;
                StringBuffer stringBufferZ = a.z("Incorrect terminator for small block stream ");
                stringBufferZ.append(propertyStorage.name);
                logger2.warn(stringBufferZ.toString());
                i2 = -2;
            } else {
                i2 = i3;
            }
            bArr = bArr2;
        }
        return bArr;
    }

    private void readBigBlockDepot() {
        this.bigBlockChain = new int[(this.numBigBlockDepotBlocks * 512) / 4];
        int i2 = 0;
        for (int i3 = 0; i3 < this.numBigBlockDepotBlocks; i3++) {
            int i4 = (this.bigBlockDepotBlocks[i3] + 1) * 512;
            for (int i5 = 0; i5 < 128; i5++) {
                int[] iArr = this.bigBlockChain;
                byte[] bArr = this.data;
                iArr[i2] = IntegerHelper.getInt(bArr[i4], bArr[i4 + 1], bArr[i4 + 2], bArr[i4 + 3]);
                i4 += 4;
                i2++;
            }
        }
    }

    private byte[] readData(int i2) throws BiffException {
        byte[] bArr = new byte[0];
        while (i2 != -2) {
            byte[] bArr2 = new byte[bArr.length + 512];
            System.arraycopy(bArr, 0, bArr2, 0, bArr.length);
            System.arraycopy(this.data, (i2 + 1) * 512, bArr2, bArr.length, 512);
            int[] iArr = this.bigBlockChain;
            if (iArr[i2] == i2) {
                throw new BiffException(BiffException.corruptFileFormat);
            }
            i2 = iArr[i2];
            bArr = bArr2;
        }
        return bArr;
    }

    private void readPropertySets() {
        int i2 = 0;
        while (true) {
            byte[] bArr = this.rootEntry;
            if (i2 >= bArr.length) {
                break;
            }
            byte[] bArr2 = new byte[128];
            System.arraycopy(bArr, i2, bArr2, 0, 128);
            BaseCompoundFile.PropertyStorage propertyStorage = new BaseCompoundFile.PropertyStorage(bArr2);
            String str = propertyStorage.name;
            if (str == null || str.length() == 0) {
                if (propertyStorage.type == 5) {
                    propertyStorage.name = BaseCompoundFile.ROOT_ENTRY_NAME;
                    Logger logger2 = logger;
                    StringBuffer stringBufferZ = a.z("Property storage name for ");
                    stringBufferZ.append(propertyStorage.type);
                    stringBufferZ.append(" is empty - setting to ");
                    stringBufferZ.append(BaseCompoundFile.ROOT_ENTRY_NAME);
                    logger2.warn(stringBufferZ.toString());
                } else if (propertyStorage.size != 0) {
                    Logger logger3 = logger;
                    StringBuffer stringBufferZ2 = a.z("Property storage type ");
                    stringBufferZ2.append(propertyStorage.type);
                    stringBufferZ2.append(" is non-empty and has no associated name");
                    logger3.warn(stringBufferZ2.toString());
                }
            }
            this.propertySets.add(propertyStorage);
            if (propertyStorage.name.equalsIgnoreCase(BaseCompoundFile.ROOT_ENTRY_NAME)) {
                this.rootEntryPropertyStorage = propertyStorage;
            }
            i2 += 128;
        }
        if (this.rootEntryPropertyStorage == null) {
            this.rootEntryPropertyStorage = (BaseCompoundFile.PropertyStorage) this.propertySets.get(0);
        }
    }

    private void readSmallBlockDepot() {
        int i2 = this.sbdStartBlock;
        this.smallBlockChain = new int[0];
        if (i2 == -1) {
            logger.warn("invalid small block depot number");
            return;
        }
        int i3 = 0;
        while (i2 != -2) {
            int[] iArr = this.smallBlockChain;
            int[] iArr2 = new int[iArr.length + 128];
            this.smallBlockChain = iArr2;
            System.arraycopy(iArr, 0, iArr2, 0, iArr.length);
            int i4 = (i2 + 1) * 512;
            for (int i5 = 0; i5 < 128; i5++) {
                int[] iArr3 = this.smallBlockChain;
                byte[] bArr = this.data;
                iArr3[i3] = IntegerHelper.getInt(bArr[i4], bArr[i4 + 1], bArr[i4 + 2], bArr[i4 + 3]);
                i4 += 4;
                i3++;
            }
            i2 = this.bigBlockChain[i2];
        }
    }

    public BaseCompoundFile.PropertyStorage findPropertyStorage(String str) {
        return findPropertyStorage(str, this.rootEntryPropertyStorage);
    }

    public int getNumberOfPropertySets() {
        return this.propertySets.size();
    }

    public BaseCompoundFile.PropertyStorage getPropertySet(int i2) {
        return getPropertyStorage(i2);
    }

    public byte[] getStream(String str) throws BiffException {
        BaseCompoundFile.PropertyStorage propertyStorageFindPropertyStorage = findPropertyStorage(str, this.rootEntryPropertyStorage);
        if (propertyStorageFindPropertyStorage == null) {
            propertyStorageFindPropertyStorage = getPropertyStorage(str);
        }
        return (propertyStorageFindPropertyStorage.size >= 4096 || str.equalsIgnoreCase(BaseCompoundFile.ROOT_ENTRY_NAME)) ? getBigBlockStream(propertyStorageFindPropertyStorage) : getSmallBlockStream(propertyStorageFindPropertyStorage);
    }

    private BaseCompoundFile.PropertyStorage findPropertyStorage(String str, BaseCompoundFile.PropertyStorage propertyStorage) {
        int i2 = propertyStorage.child;
        if (i2 == -1) {
            return null;
        }
        BaseCompoundFile.PropertyStorage propertyStorage2 = getPropertyStorage(i2);
        if (propertyStorage2.name.equalsIgnoreCase(str)) {
            return propertyStorage2;
        }
        BaseCompoundFile.PropertyStorage propertyStorage3 = propertyStorage2;
        do {
            int i3 = propertyStorage3.previous;
            if (i3 == -1) {
                BaseCompoundFile.PropertyStorage propertyStorage4 = propertyStorage2;
                do {
                    int i4 = propertyStorage4.next;
                    if (i4 == -1) {
                        return findPropertyStorage(str, propertyStorage2);
                    }
                    propertyStorage4 = getPropertyStorage(i4);
                } while (!propertyStorage4.name.equalsIgnoreCase(str));
                return propertyStorage4;
            }
            propertyStorage3 = getPropertyStorage(i3);
        } while (!propertyStorage3.name.equalsIgnoreCase(str));
        return propertyStorage3;
    }

    public byte[] getStream(int i2) throws BiffException {
        BaseCompoundFile.PropertyStorage propertyStorage = getPropertyStorage(i2);
        if (propertyStorage.size < 4096 && !propertyStorage.name.equalsIgnoreCase(BaseCompoundFile.ROOT_ENTRY_NAME)) {
            return getSmallBlockStream(propertyStorage);
        }
        return getBigBlockStream(propertyStorage);
    }

    private BaseCompoundFile.PropertyStorage getPropertyStorage(int i2) {
        return (BaseCompoundFile.PropertyStorage) this.propertySets.get(i2);
    }
}