package org.snmp4j.agent.mo.snmp;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.snmp4j.agent.MOAccess;
import org.snmp4j.agent.mo.MOAccessImpl;
import org.snmp4j.agent.mo.MOChangeEvent;
import org.snmp4j.agent.mo.MOChangeListener;
import org.snmp4j.agent.mo.MOColumn;
import org.snmp4j.agent.mo.MOMutableColumn;
import org.snmp4j.agent.mo.MOMutableTableRow;
import org.snmp4j.agent.mo.MOTable;
import org.snmp4j.agent.mo.MOTableModel;
import org.snmp4j.agent.mo.MOTableRow;
import org.snmp4j.agent.mo.MOTableRowEvent;
import org.snmp4j.agent.mo.MOTableRowFilter;
import org.snmp4j.agent.mo.MOTableRowListener;
import org.snmp4j.agent.mo.MOValueValidationEvent;
import org.snmp4j.agent.mo.MOValueValidationListener;
import org.snmp4j.agent.request.SubRequest;
import org.snmp4j.log.LogAdapter;
import org.snmp4j.log.LogFactory;
import org.snmp4j.smi.Integer32;
import org.snmp4j.smi.OID;

/* JADX INFO: loaded from: classes.dex */
public class RowStatus<R extends MOTableRow> extends MOMutableColumn<Integer32> implements MOChangeListener, MOTableRowListener<R> {
    public static final int active = 1;
    public static final int createAndGo = 4;
    public static final int createAndWait = 5;
    public static final int destroy = 6;
    private static final LogAdapter logger = LogFactory.getLogger(RowStatus.class);
    public static final int notExistant = 0;
    public static final int notInService = 2;
    public static final int notReady = 3;
    private int columnIndex;
    private OID oid;
    private transient List<RowStatusListener> rowStatusListeners;

    public static class ActiveRowsFilter<R extends MOTableRow> implements MOTableRowFilter<R> {
        private int rowStatusColumnIndex;

        public ActiveRowsFilter(int i2) {
            this.rowStatusColumnIndex = i2;
        }

        @Override // org.snmp4j.agent.mo.MOTableRowFilter
        public boolean passesFilter(R r) {
            Integer32 integer32 = (Integer32) r.getValue(this.rowStatusColumnIndex);
            if (integer32 != null) {
                return integer32.getValue() == 1;
            }
            RowStatus.logger.warn("RowStatus column " + this.rowStatusColumnIndex + " does not exists although it is filter criteria");
            return false;
        }
    }

    static class RowStatusValidator implements MOValueValidationListener {
        RowStatusValidator() {
        }

        @Override // org.snmp4j.agent.mo.MOValueValidationListener
        public void validate(MOValueValidationEvent mOValueValidationEvent) {
            if (!(mOValueValidationEvent.getNewValue() instanceof Integer32)) {
                mOValueValidationEvent.setValidationStatus(7);
            }
            int value = ((Integer32) mOValueValidationEvent.getNewValue()).getValue();
            if (value < 1 || value > 6 || value == 3) {
                mOValueValidationEvent.setValidationStatus(10);
            }
        }
    }

    public RowStatus(int i2) {
        super(i2, 2, MOAccessImpl.ACCESS_READ_CREATE);
        addMOValueValidationListener(new RowStatusValidator());
    }

    private int getCurrentRowStatus(MOTableRowEvent mOTableRowEvent) {
        Integer32 integer32 = (Integer32) mOTableRowEvent.getRow().getValue(this.columnIndex);
        if (integer32 != null) {
            return integer32.getValue();
        }
        return 0;
    }

    public static boolean isRowActive(MOTableRow mOTableRow, int i2) {
        Integer32 integer32 = (Integer32) mOTableRow.getValue(i2);
        return integer32 != null && integer32.getValue() == 1;
    }

    public synchronized void addRowStatusListener(RowStatusListener rowStatusListener) {
        List<RowStatusListener> list = this.rowStatusListeners;
        ArrayList arrayList = list == null ? new ArrayList(2) : new ArrayList(list);
        arrayList.add(rowStatusListener);
        this.rowStatusListeners = arrayList;
    }

    @Override // org.snmp4j.agent.mo.MOChangeListener
    public void afterMOChange(MOChangeEvent mOChangeEvent) {
    }

    @Override // org.snmp4j.agent.mo.MOChangeListener
    public void afterPrepareMOChange(MOChangeEvent mOChangeEvent) {
    }

    protected void assignNewValue(SubRequest subRequest, MOTableRow mOTableRow, int i2, int i3) {
        if (i3 == 4) {
            ((Integer32) mOTableRow.getValue(i2)).setValue(1);
            return;
        }
        if (i3 == 5) {
            if (isReady(mOTableRow, i2)) {
                ((Integer32) mOTableRow.getValue(i2)).setValue(2);
                return;
            } else {
                ((Integer32) mOTableRow.getValue(i2)).setValue(3);
                return;
            }
        }
        if (i3 != 6) {
            return;
        }
        MOTableRow mOTableRowRemoveRow = getTable().removeRow(mOTableRow.getIndex());
        if (mOTableRowRemoveRow == null) {
            subRequest.getStatus().setErrorStatus(14);
        } else {
            subRequest.setUndoValue(mOTableRowRemoveRow);
        }
    }

    @Override // org.snmp4j.agent.mo.MOChangeListener
    public void beforeMOChange(MOChangeEvent mOChangeEvent) {
    }

    /* JADX WARN: Removed duplicated region for block: B:12:0x0036  */
    @Override // org.snmp4j.agent.mo.MOChangeListener
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    public void beforePrepareMOChange(org.snmp4j.agent.mo.MOChangeEvent r9) {
        /*
            r8 = this;
            org.snmp4j.smi.OID r0 = r9.getOID()
            org.snmp4j.smi.OID r1 = r8.oid
            boolean r0 = r0.startsWith(r1)
            if (r0 == 0) goto L65
            org.snmp4j.smi.Variable r0 = r9.getOldValue()
            boolean r0 = r0 instanceof org.snmp4j.smi.Integer32
            r1 = 0
            if (r0 == 0) goto L20
            org.snmp4j.smi.Variable r0 = r9.getOldValue()
            org.snmp4j.smi.Integer32 r0 = (org.snmp4j.smi.Integer32) r0
            int r0 = r0.getValue()
            goto L21
        L20:
            r0 = 0
        L21:
            org.snmp4j.smi.Variable r2 = r9.getNewValue()
            org.snmp4j.smi.Integer32 r2 = (org.snmp4j.smi.Integer32) r2
            int r2 = r2.getValue()
            r3 = 5
            r4 = 4
            r5 = 2
            r6 = 6
            r7 = 1
            switch(r0) {
                case 0: goto L57;
                case 1: goto L50;
                case 2: goto L49;
                case 3: goto L42;
                case 4: goto L3d;
                case 5: goto L38;
                case 6: goto L34;
                default: goto L33;
            }
        L33:
            goto L5e
        L34:
            if (r2 != r6) goto L5e
        L36:
            r1 = 1
            goto L5e
        L38:
            if (r2 == r3) goto L36
            if (r2 != r6) goto L5e
            goto L36
        L3d:
            if (r2 == r4) goto L36
            if (r2 != r6) goto L5e
            goto L36
        L42:
            if (r2 == r6) goto L36
            if (r2 == r7) goto L36
            if (r2 != r5) goto L5e
            goto L36
        L49:
            if (r2 == r5) goto L36
            if (r2 == r7) goto L36
            if (r2 != r6) goto L5e
            goto L36
        L50:
            if (r2 == r7) goto L36
            if (r2 == r5) goto L36
            if (r2 != r6) goto L5e
            goto L36
        L57:
            if (r2 == r4) goto L36
            if (r2 == r3) goto L36
            if (r2 != r6) goto L5e
            goto L36
        L5e:
            if (r1 != 0) goto L65
            r0 = 10
            r9.setDenyReason(r0)
        L65:
            return
        */
        throw new UnsupportedOperationException("Method not decompiled: org.snmp4j.agent.mo.snmp.RowStatus.beforePrepareMOChange(org.snmp4j.agent.mo.MOChangeEvent):void");
    }

    @Override // org.snmp4j.agent.mo.MOMutableColumn
    public void commit(SubRequest subRequest, MOTableRow mOTableRow, MOTableRow mOTableRow2, int i2) {
        int value = ((Integer32) mOTableRow.getValue(i2)).getValue();
        super.commit(subRequest, mOTableRow, null, i2);
        if (subRequest.hasError()) {
            return;
        }
        int value2 = ((Integer32) mOTableRow.getValue(i2)).getValue();
        assignNewValue(subRequest, mOTableRow, i2, value2);
        fireRowStatusChanged(new RowStatusEvent(this, getTable(), mOTableRow, mOTableRow2, value, value2, false, subRequest));
    }

    protected void fireRowStatusChanged(RowStatusEvent rowStatusEvent) {
        List<RowStatusListener> list = this.rowStatusListeners;
        if (list != null) {
            Iterator<RowStatusListener> it = list.iterator();
            while (it.hasNext()) {
                it.next().rowStatusChanged(rowStatusEvent);
            }
        }
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // org.snmp4j.agent.mo.MOColumn
    public void get(SubRequest subRequest, MOTableRow mOTableRow, int i2) {
        Integer32 integer32 = (Integer32) getValue(mOTableRow, i2);
        if (integer32 != null && integer32.getValue() == 3 && isReady(mOTableRow, i2)) {
            integer32.setValue(2);
        }
        super.get(subRequest, mOTableRow, i2);
    }

    protected boolean isReady(MOTableRow mOTableRow, int i2) {
        return isReady(mOTableRow, i2, null);
    }

    @Override // org.snmp4j.agent.mo.MOColumn
    public boolean isVolatile(MOTableRow mOTableRow, int i2) {
        int value;
        Integer32 integer32 = (Integer32) mOTableRow.getValue(i2);
        return (integer32 == null || (value = integer32.getValue()) == 1 || value == 2) ? false : true;
    }

    @Override // org.snmp4j.agent.mo.MOMutableColumn
    public void prepare(SubRequest subRequest, MOTableRow mOTableRow, MOTableRow mOTableRow2, int i2) {
        super.prepare(subRequest, mOTableRow, null, i2);
        if (subRequest.getStatus().getErrorStatus() == 0) {
            int value = ((Integer32) subRequest.getVariableBinding().getVariable()).getValue();
            int value2 = mOTableRow.getValue(i2) != null ? ((Integer32) mOTableRow.getValue(i2)).getValue() : 0;
            if ((value2 == 0 || value2 == 3 || value2 == 4) && ((value == 1 || value == 2 || value == 4) && !isReady(mOTableRow, i2, mOTableRow2))) {
                if (logger.isDebugEnabled()) {
                    logger.debug(toString() + ": Row '" + mOTableRow.getIndex() + " is not ready! Cannot change status to from " + value2 + " to " + value);
                }
                subRequest.getStatus().setErrorStatus(12);
            }
            RowStatusEvent rowStatusEvent = new RowStatusEvent(this, getTable(), mOTableRow, mOTableRow2, value2, value, true, subRequest);
            fireRowStatusChanged(rowStatusEvent);
            if (rowStatusEvent.getDenyReason() != 0) {
                subRequest.getStatus().setErrorStatus(rowStatusEvent.getDenyReason());
            }
        }
    }

    public synchronized void removeRowStatusListener(RowStatusListener rowStatusListener) {
        List<RowStatusListener> list = this.rowStatusListeners;
        if (list != null) {
            ArrayList arrayList = new ArrayList(list);
            arrayList.remove(rowStatusListener);
            this.rowStatusListeners = arrayList;
        }
    }

    @Override // org.snmp4j.agent.mo.MOTableRowListener
    public void rowChanged(MOTableRowEvent mOTableRowEvent) {
        int type = mOTableRowEvent.getType();
        if (type != 0) {
            if (type == 1) {
                if (mOTableRowEvent.getRow().getValue(getTable().getColumnIndex(getColumnID())) == null) {
                    mOTableRowEvent.setVetoStatus(18);
                    return;
                }
                return;
            } else if (type != 4) {
                return;
            }
        } else if (getCurrentRowStatus(mOTableRowEvent) == 1) {
            for (int i2 = 0; i2 < getTable().getColumnCount(); i2++) {
                if (mOTableRowEvent.getPreparedChanges().getValue(i2) != null) {
                    MOColumn column = getTable().getColumn(i2);
                    if ((column instanceof MOMutableColumn) && !((MOMutableColumn) column).isMutableInService()) {
                        mOTableRowEvent.setVetoStatus(12);
                        mOTableRowEvent.setVetoColumn(i2);
                    }
                }
            }
        }
        if (getCurrentRowStatus(mOTableRowEvent) == 3 && (mOTableRowEvent.getRow() instanceof MOMutableTableRow) && isReady(mOTableRowEvent.getRow(), this.columnIndex)) {
            ((MOMutableTableRow) mOTableRowEvent.getRow()).setValue(this.columnIndex, new Integer32(2));
        }
    }

    @Override // org.snmp4j.agent.mo.MOColumn
    public <R extends MOTableRow> void setTable(MOTable<R, ? extends MOColumn, ? extends MOTableModel<R>> mOTable) {
        super.setTable(mOTable);
        OID oid = new OID(mOTable.getOID());
        this.oid = oid;
        oid.append(getColumnID());
        this.columnIndex = mOTable.getColumnIndex(getColumnID());
        mOTable.addMOChangeListener(this);
        mOTable.addMOTableRowListener(this);
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // org.snmp4j.agent.mo.MOMutableColumn
    public void undo(SubRequest subRequest, MOTableRow mOTableRow, int i2) {
        super.undo(subRequest, mOTableRow, i2);
        if (subRequest.hasError()) {
            return;
        }
        int value = ((Integer32) mOTableRow.getValue(i2)).getValue();
        if (value == 4 || value == 5) {
            MOTableRow mOTableRowRemoveRow = getTable().removeRow(mOTableRow.getIndex());
            if (mOTableRowRemoveRow == null) {
                subRequest.getStatus().setErrorStatus(15);
                return;
            } else {
                fireRowStatusChanged(new RowStatusEvent(this, getTable(), mOTableRow, mOTableRowRemoveRow, 0, value));
                return;
            }
        }
        if (value != 6) {
            return;
        }
        MOTableRow mOTableRow2 = (MOTableRow) subRequest.getUndoValue();
        Integer32 integer32 = (Integer32) mOTableRow2.getValue(i2);
        if (getTable().addRow((MOTableRow) subRequest.getUndoValue())) {
            fireRowStatusChanged(new RowStatusEvent(this, getTable(), mOTableRow2, mOTableRow, integer32.getValue(), 6));
        } else {
            subRequest.getStatus().setErrorStatus(15);
        }
    }

    public void unsetTable(MOTable<R, ? extends MOColumn, ? extends MOTableModel<R>> mOTable) {
        this.columnIndex = 0;
        mOTable.removeMOChangeListener(this);
        mOTable.removeMOTableRowListener(this);
    }

    protected boolean isReady(MOTableRow mOTableRow, int i2, MOTableRow mOTableRow2) {
        MOColumn[] columns = getTable().getColumns();
        for (int i3 = 0; i3 < columns.length; i3++) {
            if (i3 != i2 && (columns[i3] instanceof MOMutableColumn) && ((MOMutableColumn) columns[i3]).isMandatory() && mOTableRow.getValue(i3) == null && (mOTableRow2 == null || mOTableRow2.getValue(i3) == null)) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Row " + mOTableRow + " is not ready because column " + i3 + " is not set properly");
                }
                return false;
            }
        }
        return true;
    }

    public RowStatus(int i2, MOAccess mOAccess) {
        super(i2, 2, mOAccess);
        addMOValueValidationListener(new RowStatusValidator());
    }
}