package jxl.biff.formula;

import common.Logger;
import java.util.Stack;
import jxl.WorkbookSettings;
import jxl.biff.IntegerHelper;

/* JADX INFO: loaded from: classes.dex */
class VariableArgFunction extends Operator implements ParsedThing {
    static /* synthetic */ Class class$jxl$biff$formula$VariableArgFunction;
    private static Logger logger;
    private int arguments;
    private Function function;
    private boolean readFromSheet = true;
    private WorkbookSettings settings;

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

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

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

    private void handleSpecialCases() {
        if (this.function == Function.SUMPRODUCT) {
            ParseItem[] operands = getOperands();
            for (int length = operands.length - 1; length >= 0; length--) {
                if (operands[length] instanceof Area) {
                    operands[length].setAlternateCode();
                }
            }
        }
    }

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

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

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

    @Override // jxl.biff.formula.ParseItem
    byte[] getBytes() {
        handleSpecialCases();
        ParseItem[] operands = getOperands();
        byte[] bArr = new byte[0];
        int i2 = 0;
        while (i2 < operands.length) {
            byte[] bytes = operands[i2].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);
            i2++;
            bArr = bArr2;
        }
        byte[] bArr3 = new byte[bArr.length + 4];
        System.arraycopy(bArr, 0, bArr3, 0, bArr.length);
        bArr3[bArr.length] = !useAlternateCode() ? Token.FUNCTIONVARARG.getCode() : Token.FUNCTIONVARARG.getCode2();
        bArr3[bArr.length + 1] = (byte) this.arguments;
        IntegerHelper.getTwoBytes(this.function.getCode(), bArr3, bArr.length + 2);
        return bArr3;
    }

    Function getFunction() {
        return this.function;
    }

    @Override // jxl.biff.formula.Operator
    public void getOperands(Stack stack) {
        int i2 = this.arguments;
        ParseItem[] parseItemArr = new ParseItem[i2];
        for (int i3 = i2 - 1; i3 >= 0; i3--) {
            parseItemArr[i3] = (ParseItem) stack.pop();
        }
        for (int i4 = 0; i4 < this.arguments; i4++) {
            add(parseItemArr[i4]);
        }
    }

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

    @Override // jxl.biff.formula.ParseItem
    public void getString(StringBuffer stringBuffer) {
        stringBuffer.append(this.function.getName(this.settings));
        stringBuffer.append('(');
        if (this.arguments > 0) {
            ParseItem[] operands = getOperands();
            if (this.readFromSheet) {
                operands[0].getString(stringBuffer);
                for (int i2 = 1; i2 < this.arguments; i2++) {
                    stringBuffer.append(',');
                    operands[i2].getString(stringBuffer);
                }
            } else {
                operands[this.arguments - 1].getString(stringBuffer);
                for (int i3 = this.arguments - 2; i3 >= 0; i3--) {
                    stringBuffer.append(',');
                    operands[i3].getString(stringBuffer);
                }
            }
        }
        stringBuffer.append(')');
    }

    @Override // jxl.biff.formula.ParseItem
    void handleImportedCellReferences() {
        for (ParseItem parseItem : getOperands()) {
            parseItem.handleImportedCellReferences();
        }
    }

    @Override // jxl.biff.formula.ParsedThing
    public int read(byte[] bArr, int i2) throws FormulaException {
        this.arguments = bArr[i2];
        int i3 = IntegerHelper.getInt(bArr[i2 + 1], bArr[i2 + 2]);
        Function function = Function.getFunction(i3);
        this.function = function;
        if (function != Function.UNKNOWN) {
            return 3;
        }
        throw new FormulaException(FormulaException.UNRECOGNIZED_FUNCTION, i3);
    }

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

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

    public VariableArgFunction(Function function, int i2, WorkbookSettings workbookSettings) {
        this.function = function;
        this.arguments = i2;
        this.settings = workbookSettings;
    }
}