package org.snmp4j.agent.mo;

import org.snmp4j.smi.AbstractVariable;
import org.snmp4j.smi.Gauge32;
import org.snmp4j.smi.Integer32;
import org.snmp4j.smi.IpAddress;
import org.snmp4j.smi.OID;
import org.snmp4j.smi.OctetString;
import org.snmp4j.smi.TimeTicks;
import org.snmp4j.smi.Variable;

/* JADX INFO: loaded from: classes.dex */
public class MOTableIndex implements MOTableIndexValidator {
    public static final int MAX_INDEX_OID_LENGTH = 127;
    private boolean impliedLength;
    private MOTableSubIndex[] subindexes;
    private MOTableIndexValidator validator;

    public MOTableIndex(MOTableSubIndex[] mOTableSubIndexArr) {
        this.impliedLength = false;
        if (mOTableSubIndexArr == null || mOTableSubIndexArr.length < 1) {
            throw new IllegalArgumentException("Index definition must have at least one sub-index");
        }
        this.subindexes = mOTableSubIndexArr;
    }

    private static boolean checkIndexBytes(OID oid, long j2, long j3) {
        if (j2 < 0 || j2 > 127 || j3 < 0 || j3 > 127) {
            return false;
        }
        for (int i2 = (int) j2; i2 < oid.size() && i2 < j3; i2++) {
            if (oid.getUnsigned(i2) > 255) {
                return false;
            }
        }
        return true;
    }

    private static Variable getIndexVariable(MOTableSubIndex mOTableSubIndex, OID oid, boolean z) {
        int smiSyntax = mOTableSubIndex.getSmiSyntax();
        if (smiSyntax == 2) {
            return new Integer32(oid.get(oid.size() - 1));
        }
        if (smiSyntax == 4) {
            return (z || mOTableSubIndex.getMinLength() == mOTableSubIndex.getMaxLength()) ? new OctetString(oid.toByteArray()) : new OctetString(new OID(oid.getValue(), 1, oid.size() - 1).toByteArray());
        }
        if (smiSyntax == 6) {
            return (z || mOTableSubIndex.getMinLength() == mOTableSubIndex.getMaxLength()) ? oid : new OID(oid.getValue(), 1, oid.size() - 1);
        }
        if (smiSyntax == 64) {
            return new IpAddress(oid.toString());
        }
        if (smiSyntax == 66) {
            return new Gauge32(oid.get(oid.size() - 1));
        }
        if (smiSyntax != 67) {
            return null;
        }
        return new TimeTicks(oid.get(oid.size() - 1));
    }

    private static boolean isStringSyntax(int i2) {
        return i2 == 4 || i2 == 64 || i2 == 68;
    }

    public MOTableSubIndex getIndex(int i2) {
        return this.subindexes[i2];
    }

    public OID getIndexOID(Variable[] variableArr) {
        if (variableArr.length != size()) {
            throw new IllegalArgumentException("Index value length != size()");
        }
        OID oid = new OID();
        int i2 = 0;
        while (i2 < variableArr.length) {
            if (variableArr[i2].getSyntax() != this.subindexes[i2].getSmiSyntax()) {
                throw new IllegalArgumentException("Syntax of index value #" + i2 + " = " + variableArr[i2].getSyntaxString() + " does not match index definition " + AbstractVariable.getSyntaxString(this.subindexes[i2].getSmiSyntax()));
            }
            Variable variable = variableArr[i2];
            i2++;
            oid.append(variable.toSubIndex(i2 == variableArr.length && this.impliedLength));
        }
        return oid;
    }

    public OID[] getIndexOIDs(OID oid) {
        OID[] oidArr = new OID[size()];
        int[] value = oid.getValue();
        int i2 = 0;
        int size = 0;
        while (true) {
            if (i2 < this.subindexes.length) {
                int i3 = i2 + 1;
                if (i3 == size() && isImpliedLength()) {
                    oidArr[i2] = new OID(value, size, oid.size() - size);
                    break;
                }
                if (this.subindexes[i2].getMinLength() != this.subindexes[i2].getMaxLength()) {
                    oidArr[i2] = new OID(value, size, oid.get(size) + 1);
                } else {
                    oidArr[i2] = new OID(oid.getValue(), size, this.subindexes[i2].getMaxLength());
                }
                size += oidArr[i2].size();
                i2 = i3;
            } else {
                break;
            }
        }
        return oidArr;
    }

    public Variable[] getIndexValues(OID oid) {
        OID[] indexOIDs = getIndexOIDs(oid);
        Variable[] variableArr = new Variable[indexOIDs.length];
        for (int i2 = 0; i2 < indexOIDs.length; i2++) {
            variableArr[i2] = getIndexVariable(this.subindexes[i2], indexOIDs[i2], isImpliedLength() && i2 + 1 == size());
        }
        return variableArr;
    }

    public MOTableIndexValidator getValidator() {
        return this.validator;
    }

    public boolean isImpliedLength() {
        return this.impliedLength;
    }

    @Override // org.snmp4j.agent.mo.MOTableIndexValidator
    public boolean isValidIndex(OID oid) {
        if (oid.size() > 127) {
            return false;
        }
        int i2 = 0;
        int unsigned = 0;
        while (i2 < size() && unsigned < oid.size()) {
            MOTableSubIndex index = getIndex(i2);
            i2++;
            if (i2 == size() && isImpliedLength()) {
                int smiSyntax = index.getSmiSyntax();
                return !(smiSyntax == 4 || smiSyntax == 64) || checkIndexBytes(oid, (long) unsigned, (long) oid.size());
            }
            if (index.getMinLength() != index.getMaxLength()) {
                if (oid.size() < oid.get(unsigned) + 1 || oid.get(unsigned) < index.getMinLength() || oid.get(unsigned) > index.getMaxLength()) {
                    return false;
                }
                if (isStringSyntax(index.getSmiSyntax())) {
                    long j2 = unsigned;
                    if (!checkIndexBytes(oid, j2, oid.getUnsigned(unsigned) + j2 + 1)) {
                        return false;
                    }
                }
                unsigned = (int) (((long) unsigned) + oid.getUnsigned(unsigned) + 1);
            } else {
                if (isStringSyntax(index.getSmiSyntax()) && !checkIndexBytes(oid, unsigned, index.getMaxLength() + unsigned)) {
                    return false;
                }
                unsigned += index.getMaxLength();
            }
        }
        if (oid.size() != unsigned || i2 < size()) {
            return false;
        }
        MOTableIndexValidator mOTableIndexValidator = this.validator;
        return mOTableIndexValidator == null || mOTableIndexValidator.isValidIndex(oid);
    }

    public void setValidator(MOTableIndexValidator mOTableIndexValidator) {
        this.validator = mOTableIndexValidator;
    }

    public int size() {
        return this.subindexes.length;
    }

    public MOTableIndex(MOTableSubIndex[] mOTableSubIndexArr, boolean z) {
        this(mOTableSubIndexArr);
        this.impliedLength = z;
    }

    public MOTableIndex(MOTableSubIndex[] mOTableSubIndexArr, boolean z, MOTableIndexValidator mOTableIndexValidator) {
        this(mOTableSubIndexArr, z);
        this.validator = mOTableIndexValidator;
    }
}