package jxl.biff.formula;

import com.seewo.sdk.model.SDKKeyboardCode;
import common.Logger;
import java.util.Stack;
import jxl.WorkbookSettings;
import jxl.biff.IntegerHelper;

/* JADX INFO: loaded from: classes.dex */
public class Attribute extends Operator implements ParsedThing {
    private static final int GOTO_MASK = 8;
    private static final int IF_MASK = 2;
    private static final int SUM_MASK = 16;
    public static /* synthetic */ Class class$jxl$biff$formula$Attribute;
    private static Logger logger;
    private VariableArgFunction ifConditions;
    private int options;
    private WorkbookSettings settings;
    private int word;

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

    public Attribute(WorkbookSettings workbookSettings) {
        this.settings = workbookSettings;
    }

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

    private byte[] getIf() {
        ParseItem[] operands = this.ifConditions.getOperands();
        int length = operands.length;
        byte[] bytes = operands[0].getBytes();
        int length2 = bytes.length;
        int length3 = bytes.length + 4;
        byte[] bArr = new byte[length3];
        System.arraycopy(bytes, 0, bArr, 0, bytes.length);
        Token token = Token.ATTRIBUTE;
        bArr[length2] = token.getCode();
        bArr[length2 + 1] = 2;
        int i2 = length2 + 2;
        byte[] bytes2 = operands[1].getBytes();
        int length4 = bytes2.length + length3;
        byte[] bArr2 = new byte[length4];
        System.arraycopy(bArr, 0, bArr2, 0, length3);
        System.arraycopy(bytes2, 0, bArr2, length3, bytes2.length);
        int i3 = length4 + 4;
        byte[] bArr3 = new byte[i3];
        System.arraycopy(bArr2, 0, bArr3, 0, length4);
        bArr3[length4] = token.getCode();
        bArr3[length4 + 1] = 8;
        int i4 = length4 + 2;
        if (length > 2) {
            IntegerHelper.getTwoBytes((i3 - i2) - 2, bArr3, i2);
            byte[] bytes3 = operands[length - 1].getBytes();
            int length5 = bytes3.length + i3;
            byte[] bArr4 = new byte[length5];
            System.arraycopy(bArr3, 0, bArr4, 0, i3);
            System.arraycopy(bytes3, 0, bArr4, i3, bytes3.length);
            bArr3 = new byte[length5 + 4];
            System.arraycopy(bArr4, 0, bArr3, 0, length5);
            bArr3[length5] = token.getCode();
            bArr3[length5 + 1] = 8;
            bArr3[length5 + 2] = 3;
        }
        int length6 = bArr3.length;
        int length7 = bArr3.length + 4;
        byte[] bArr5 = new byte[length7];
        System.arraycopy(bArr3, 0, bArr5, 0, bArr3.length);
        bArr5[length6] = Token.FUNCTIONVARARG.getCode();
        bArr5[length6 + 1] = (byte) length;
        bArr5[length6 + 2] = 1;
        bArr5[length6 + 3] = 0;
        int i5 = length7 - 1;
        if (length < 3) {
            IntegerHelper.getTwoBytes((i5 - i2) - 5, bArr5, i2);
        }
        IntegerHelper.getTwoBytes((i5 - i4) - 2, bArr5, i4);
        return bArr5;
    }

    @Override // jxl.biff.formula.ParseItem
    public void adjustRelativeCellReferences(int i2, int i3) {
        for (ParseItem parseItem : isIf() ? this.ifConditions.getOperands() : getOperands()) {
            parseItem.adjustRelativeCellReferences(i2, i3);
        }
    }

    @Override // jxl.biff.formula.ParseItem
    public void columnInserted(int i2, int i3, boolean z) {
        for (ParseItem parseItem : isIf() ? this.ifConditions.getOperands() : getOperands()) {
            parseItem.columnInserted(i2, i3, z);
        }
    }

    @Override // jxl.biff.formula.ParseItem
    public void columnRemoved(int i2, int i3, boolean z) {
        for (ParseItem parseItem : isIf() ? this.ifConditions.getOperands() : getOperands()) {
            parseItem.columnRemoved(i2, i3, z);
        }
    }

    @Override // jxl.biff.formula.ParseItem
    public byte[] getBytes() {
        byte[] bArr = new byte[0];
        if (!isSum()) {
            return isIf() ? getIf() : bArr;
        }
        ParseItem[] operands = getOperands();
        int length = operands.length - 1;
        while (length >= 0) {
            byte[] bytes = operands[length].getBytes();
            byte[] bArr2 = new byte[bArr.length + bytes.length];
            System.arraycopy(bArr, 0, bArr2, 0, bArr.length);
            System.arraycopy(bytes, 0, bArr2, bArr.length, bytes.length);
            length--;
            bArr = bArr2;
        }
        byte[] bArr3 = new byte[bArr.length + 4];
        System.arraycopy(bArr, 0, bArr3, 0, bArr.length);
        bArr3[bArr.length] = Token.ATTRIBUTE.getCode();
        bArr3[bArr.length + 1] = SDKKeyboardCode.FUNCTION_KEY_BOARD_M;
        return bArr3;
    }

    @Override // jxl.biff.formula.Operator
    public void getOperands(Stack stack) {
        int i2 = this.options;
        if ((i2 & 16) != 0) {
            add((ParseItem) stack.pop());
        } else if ((i2 & 2) != 0) {
            add((ParseItem) stack.pop());
        }
    }

    @Override // jxl.biff.formula.Operator
    public int getPrecedence() {
        return 3;
    }

    @Override // jxl.biff.formula.ParseItem
    public void getString(StringBuffer stringBuffer) {
        int i2 = this.options;
        if ((i2 & 16) != 0) {
            ParseItem[] operands = getOperands();
            stringBuffer.append(Function.SUM.getName(this.settings));
            stringBuffer.append('(');
            operands[0].getString(stringBuffer);
            stringBuffer.append(')');
            return;
        }
        if ((i2 & 2) != 0) {
            stringBuffer.append(Function.IF.getName(this.settings));
            stringBuffer.append('(');
            ParseItem[] operands2 = this.ifConditions.getOperands();
            for (int i3 = 0; i3 < operands2.length - 1; i3++) {
                operands2[i3].getString(stringBuffer);
                stringBuffer.append(',');
            }
            operands2[operands2.length - 1].getString(stringBuffer);
            stringBuffer.append(')');
        }
    }

    @Override // jxl.biff.formula.ParseItem
    public void handleImportedCellReferences() {
        for (ParseItem parseItem : isIf() ? this.ifConditions.getOperands() : getOperands()) {
            parseItem.handleImportedCellReferences();
        }
    }

    public boolean isFunction() {
        return (this.options & 18) != 0;
    }

    public boolean isGoto() {
        return (this.options & 8) != 0;
    }

    public boolean isIf() {
        return (this.options & 2) != 0;
    }

    public boolean isSum() {
        return (this.options & 16) != 0;
    }

    @Override // jxl.biff.formula.ParsedThing
    public int read(byte[] bArr, int i2) {
        this.options = bArr[i2];
        this.word = IntegerHelper.getInt(bArr[i2 + 1], bArr[i2 + 2]);
        return 3;
    }

    @Override // jxl.biff.formula.ParseItem
    public void rowInserted(int i2, int i3, boolean z) {
        for (ParseItem parseItem : isIf() ? this.ifConditions.getOperands() : getOperands()) {
            parseItem.rowInserted(i2, i3, z);
        }
    }

    @Override // jxl.biff.formula.ParseItem
    public void rowRemoved(int i2, int i3, boolean z) {
        for (ParseItem parseItem : isIf() ? this.ifConditions.getOperands() : getOperands()) {
            parseItem.rowRemoved(i2, i3, z);
        }
    }

    public void setIfConditions(VariableArgFunction variableArgFunction) {
        this.ifConditions = variableArgFunction;
        this.options |= 2;
    }

    public Attribute(StringFunction stringFunction, WorkbookSettings workbookSettings) {
        this.settings = workbookSettings;
        if (stringFunction.getFunction(workbookSettings) == Function.SUM) {
            this.options |= 16;
        } else if (stringFunction.getFunction(this.settings) == Function.IF) {
            this.options |= 2;
        }
    }
}