package org.snmp4j.util;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Vector;
import org.snmp4j.PDU;
import org.snmp4j.Session;
import org.snmp4j.Target;
import org.snmp4j.event.ResponseEvent;
import org.snmp4j.event.ResponseListener;
import org.snmp4j.log.LogAdapter;
import org.snmp4j.log.LogFactory;
import org.snmp4j.smi.Integer32;
import org.snmp4j.smi.OID;
import org.snmp4j.smi.Variable;
import org.snmp4j.smi.VariableBinding;

/* JADX INFO: loaded from: classes.dex */
public class TableUtils extends AbstractSnmpUtility {
    public static final int ROWSTATUS_ACTIVE = 1;
    public static final int ROWSTATUS_CREATEANDGO = 4;
    public static final int ROWSTATUS_CREATEANDWAIT = 5;
    public static final int ROWSTATUS_DESTROY = 6;
    public static final int ROWSTATUS_NOTINSERVICE = 2;
    public static final int ROWSTATUS_NOTREADY = 3;
    private static final LogAdapter logger = LogFactory.getLogger(TableUtils.class);
    private int maxNumColumnsPerPDU;
    private int maxNumOfRowsPerPDU;

    class DenseTableRequest extends TableRequest {
        protected DenseTableRequest(Target target, OID[] oidArr, TableListener tableListener, Object obj, OID oid, OID oid2) {
            super(target, oidArr, tableListener, obj, oid, oid2);
        }

        /* JADX WARN: Removed duplicated region for block: B:17:0x0050  */
        @Override // org.snmp4j.util.TableUtils.TableRequest, org.snmp4j.event.ResponseListener
        /*
            Code decompiled incorrectly, please refer to instructions dump.
            To view partially-correct add '--show-bad-code' argument
        */
        public synchronized void onResponse(org.snmp4j.event.ResponseEvent r19) {
            /*
                Method dump skipped, instruction units count: 268
                To view this dump add '--comments-level debug' option
            */
            throw new UnsupportedOperationException("Method not decompiled: org.snmp4j.util.TableUtils.DenseTableRequest.onResponse(org.snmp4j.event.ResponseEvent):void");
        }
    }

    class InternalTableListener implements TableListener {
        private List<TableEvent> rows = new LinkedList();
        private volatile boolean finished = false;

        InternalTableListener() {
        }

        @Override // org.snmp4j.util.TableListener
        public synchronized void finished(TableEvent tableEvent) {
            if (tableEvent.getStatus() != 0 || tableEvent.getIndex() != null) {
                this.rows.add(tableEvent);
            }
            this.finished = true;
            notify();
        }

        public List<TableEvent> getRows() {
            return this.rows;
        }

        @Override // org.snmp4j.util.TableListener
        public boolean isFinished() {
            return this.finished;
        }

        @Override // org.snmp4j.util.TableListener
        public boolean next(TableEvent tableEvent) {
            this.rows.add(tableEvent);
            return true;
        }
    }

    class Row extends Vector<VariableBinding> {
        private static final long serialVersionUID = -2297277440117636627L;
        private OID index;

        public Row(OID oid) {
            this.index = oid;
        }

        public int getNumComplete() {
            return super.size();
        }

        public OID getRowIndex() {
            return this.index;
        }

        public boolean setNumComplete(int i2) {
            int numComplete = i2 - getNumComplete();
            for (int i3 = 0; i3 < numComplete; i3++) {
                super.add(null);
            }
            return numComplete >= 0;
        }
    }

    public class TableRequest implements ResponseListener {
        OID[] columnOIDs;
        protected Vector<OID> lastReceived;
        TableListener listener;
        OID lowerBoundIndex;
        Target target;
        OID upperBoundIndex;
        Object userObject;
        private int sent = 0;
        private boolean anyMatch = false;
        private Vector<OID> lastSent = null;
        private LinkedList<Row> rowCache = new LinkedList<>();
        volatile boolean finished = false;

        public TableRequest(Target target, OID[] oidArr, TableListener tableListener, Object obj, OID oid, OID oid2) {
            this.target = target;
            this.columnOIDs = oidArr;
            this.listener = tableListener;
            this.userObject = obj;
            this.lastReceived = new Vector<>(Arrays.asList(oidArr));
            this.upperBoundIndex = oid2;
            this.lowerBoundIndex = oid;
            if (oid != null) {
                for (int i2 = 0; i2 < this.lastReceived.size(); i2++) {
                    OID oid3 = new OID(this.lastReceived.get(i2));
                    oid3.append(oid);
                    this.lastReceived.set(i2, oid3);
                }
            }
        }

        private void emptyCache() {
            while (this.rowCache.size() > 0 && this.listener.next(getTableEvent())) {
            }
        }

        private TableEvent getTableEvent() {
            Row rowRemoveFirst = this.rowCache.removeFirst();
            rowRemoveFirst.setNumComplete(this.columnOIDs.length);
            VariableBinding[] variableBindingArr = new VariableBinding[rowRemoveFirst.size()];
            rowRemoveFirst.copyInto(variableBindingArr);
            return new TableEvent(this, this.userObject, rowRemoveFirst.getRowIndex(), variableBindingArr);
        }

        protected boolean checkResponse(ResponseEvent responseEvent) {
            if (responseEvent.getError() != null) {
                this.finished = true;
                emptyCache();
                this.listener.finished(new TableEvent(this, this.userObject, responseEvent.getError()));
                return false;
            }
            if (responseEvent.getResponse() == null) {
                this.finished = true;
                emptyCache();
                this.listener.finished(new TableEvent(this, this.userObject, -1));
                return false;
            }
            if (responseEvent.getResponse().getType() == -88) {
                this.finished = true;
                emptyCache();
                this.listener.finished(new TableEvent(this, this.userObject, responseEvent.getResponse()));
                return false;
            }
            if (responseEvent.getResponse().getErrorStatus() == 0) {
                return true;
            }
            this.finished = true;
            emptyCache();
            this.listener.finished(new TableEvent(this, this.userObject, responseEvent.getResponse().getErrorStatus()));
            return false;
        }

        public Row getRow(OID oid) {
            LinkedList<Row> linkedList = this.rowCache;
            ListIterator<Row> listIterator = linkedList.listIterator(linkedList.size() + 1);
            while (listIterator.hasPrevious()) {
                Row rowPrevious = listIterator.previous();
                if (oid.equals(rowPrevious.getRowIndex())) {
                    return rowPrevious;
                }
            }
            return null;
        }

        @Override // org.snmp4j.event.ResponseListener
        public void onResponse(ResponseEvent responseEvent) {
            List list;
            PDU pdu;
            TableUtils.this.session.cancel(responseEvent.getRequest(), this);
            if (this.finished) {
                return;
            }
            synchronized (this) {
                if (checkResponse(responseEvent)) {
                    List list2 = (List) responseEvent.getUserObject();
                    PDU request = responseEvent.getRequest();
                    PDU response = responseEvent.getResponse();
                    int size = request.size();
                    int size2 = response.size() / size;
                    boolean z = false;
                    OID oid = null;
                    for (int i2 = 0; i2 < size2; i2++) {
                        z = false;
                        int i3 = 0;
                        Row rowPrevious = null;
                        while (i3 < request.size()) {
                            int iIntValue = ((Integer) list2.get(i3)).intValue();
                            VariableBinding variableBinding = response.get((i2 * size) + i3);
                            if (variableBinding.isException()) {
                                list = list2;
                                pdu = request;
                            } else {
                                OID oid2 = variableBinding.getOid();
                                OID oid3 = this.columnOIDs[iIntValue];
                                if (oid2.startsWith(oid3)) {
                                    list = list2;
                                    pdu = request;
                                    OID oid4 = new OID(oid2.getValue(), oid3.size(), oid2.size() - oid3.size());
                                    if (this.upperBoundIndex == null || oid4.compareTo((Variable) this.upperBoundIndex) <= 0) {
                                        if (oid == null || oid4.compareTo((Variable) oid) < 0) {
                                            oid = oid4;
                                        }
                                        if (rowPrevious == null || !rowPrevious.getRowIndex().equals(oid4)) {
                                            ListIterator<Row> listIterator = this.rowCache.listIterator(this.rowCache.size());
                                            while (listIterator.hasPrevious()) {
                                                rowPrevious = listIterator.previous();
                                                int iCompareTo = oid4.compareTo((Variable) rowPrevious.getRowIndex());
                                                if (iCompareTo != 0) {
                                                    if (iCompareTo > 0) {
                                                        break;
                                                    }
                                                } else {
                                                    break;
                                                }
                                            }
                                            rowPrevious = null;
                                        }
                                        if (rowPrevious == null) {
                                            Row row = TableUtils.this.new Row(oid4);
                                            if (this.rowCache.size() == 0) {
                                                this.rowCache.add(row);
                                            } else if (this.rowCache.getFirst().getRowIndex().compareTo((Variable) oid4) < 0) {
                                                ListIterator<Row> listIterator2 = this.rowCache.listIterator(this.rowCache.size());
                                                while (true) {
                                                    if (!listIterator2.hasPrevious()) {
                                                        break;
                                                    }
                                                    Row rowPrevious2 = listIterator2.previous();
                                                    if (oid4.compareTo((Variable) rowPrevious2.index) >= 0) {
                                                        listIterator2.set(row);
                                                        listIterator2.add(rowPrevious2);
                                                        break;
                                                    }
                                                }
                                            } else {
                                                this.rowCache.addFirst(row);
                                            }
                                            rowPrevious = row;
                                        }
                                        if ((!rowPrevious.setNumComplete(iIntValue) || rowPrevious.size() > iIntValue) && rowPrevious.get(iIntValue) != null) {
                                            this.finished = true;
                                            this.listener.finished(new TableEvent(this, this.userObject, -2));
                                            return;
                                        }
                                        rowPrevious.setNumComplete(iIntValue);
                                        if (iIntValue < rowPrevious.getNumComplete()) {
                                            rowPrevious.set(iIntValue, variableBinding);
                                        } else {
                                            rowPrevious.add(variableBinding);
                                        }
                                        this.lastReceived.set(iIntValue, variableBinding.getOid());
                                        z = true;
                                    }
                                } else {
                                    list = list2;
                                    pdu = request;
                                    this.lastReceived.set(iIntValue, variableBinding.getOid());
                                }
                            }
                            i3++;
                            list2 = list;
                            request = pdu;
                        }
                    }
                    this.anyMatch |= z;
                    while (this.rowCache.size() > 0 && this.rowCache.getFirst().getNumComplete() == this.columnOIDs.length && (oid == null || this.rowCache.getFirst().getRowIndex().compareTo((Variable) oid) < 0)) {
                        if (!this.listener.next(getTableEvent())) {
                            this.finished = true;
                            this.listener.finished(new TableEvent(this, this.userObject));
                            return;
                        }
                    }
                    if (!sendNextChunk()) {
                        if (this.anyMatch) {
                            this.sent = 0;
                            this.anyMatch = false;
                            sendNextChunk();
                        } else {
                            emptyCache();
                            this.finished = true;
                            this.listener.finished(new TableEvent(this, this.userObject));
                        }
                    }
                }
            }
        }

        public boolean sendNextChunk() {
            if (this.sent >= this.lastReceived.size()) {
                return false;
            }
            PDU pduCreatePDU = TableUtils.this.pduFactory.createPDU(this.target);
            if (this.target.getVersion() == 0) {
                pduCreatePDU.setType(-95);
            } else if (pduCreatePDU.getType() != -95) {
                pduCreatePDU.setType(-91);
            }
            int iMin = Math.min(this.lastReceived.size() - this.sent, TableUtils.this.maxNumColumnsPerPDU);
            if (pduCreatePDU.getType() == -91) {
                if (TableUtils.this.maxNumOfRowsPerPDU > 0) {
                    pduCreatePDU.setMaxRepetitions(TableUtils.this.maxNumOfRowsPerPDU);
                    pduCreatePDU.setNonRepeaters(0);
                } else {
                    pduCreatePDU.setNonRepeaters(iMin);
                    pduCreatePDU.setMaxRepetitions(0);
                }
            }
            this.lastSent = new Vector<>(iMin + 1);
            ArrayList arrayList = new ArrayList(iMin);
            int i2 = this.sent;
            int i3 = 0;
            while (true) {
                if (i2 < this.sent + iMin) {
                    OID oid = this.lastReceived.get(i2);
                    if (oid.startsWith(this.columnOIDs[i2])) {
                        pduCreatePDU.add(new VariableBinding(oid));
                        if (pduCreatePDU.getBERLength() > this.target.getMaxSizeRequestPDU()) {
                            pduCreatePDU.trim();
                            break;
                        }
                        this.lastSent.add(this.lastReceived.get(i2));
                        i3++;
                        arrayList.add(Integer.valueOf(i2));
                    } else {
                        i3++;
                    }
                    i2++;
                }
            }
            try {
                this.sent += i3;
                if (pduCreatePDU.size() == 0) {
                    return false;
                }
                sendRequest(pduCreatePDU, this.target, arrayList);
                return true;
            } catch (Exception e2) {
                TableUtils.logger.error(e2);
                if (TableUtils.logger.isDebugEnabled()) {
                    e2.printStackTrace();
                }
                this.listener.finished(new TableEvent(this, this.userObject, e2));
                return false;
            }
        }

        protected void sendRequest(PDU pdu, Target target, List<Integer> list) throws IOException {
            TableUtils.this.session.send(pdu, target, list, this);
        }
    }

    public TableUtils(Session session, PDUFactory pDUFactory) {
        super(session, pDUFactory);
        this.maxNumOfRowsPerPDU = 10;
        this.maxNumColumnsPerPDU = 10;
    }

    public ResponseEvent createRow(Target target, OID oid, OID oid2, VariableBinding[] variableBindingArr) {
        PDU pduCreatePDU = this.pduFactory.createPDU(target);
        OID oid3 = new OID(oid);
        oid3.append(oid2);
        VariableBinding variableBinding = new VariableBinding(oid3);
        if (variableBindingArr != null) {
            variableBinding.setVariable(new Integer32(4));
        } else {
            variableBinding.setVariable(new Integer32(5));
        }
        pduCreatePDU.add(variableBinding);
        if (variableBindingArr != null) {
            for (VariableBinding variableBinding2 : variableBindingArr) {
                OID oid4 = new OID(variableBinding2.getOid());
                oid4.append(oid2);
                variableBinding2.setOid(oid4);
            }
            pduCreatePDU.addAll(variableBindingArr);
        }
        pduCreatePDU.setType(-93);
        try {
            return this.session.send(pduCreatePDU, target);
        } catch (IOException e2) {
            logger.error(e2);
            return null;
        }
    }

    protected TableRequest createTableRequest(Target target, OID[] oidArr, TableListener tableListener, Object obj, OID oid, OID oid2) {
        return new TableRequest(target, oidArr, tableListener, obj, oid, oid2);
    }

    public ResponseEvent destroyRow(Target target, OID oid, OID oid2) {
        PDU pduCreatePDU = this.pduFactory.createPDU(target);
        OID oid3 = new OID(oid);
        oid3.append(oid2);
        VariableBinding variableBinding = new VariableBinding(oid3);
        variableBinding.setVariable(new Integer32(6));
        pduCreatePDU.add(variableBinding);
        pduCreatePDU.setType(-93);
        try {
            return this.session.send(pduCreatePDU, target);
        } catch (IOException e2) {
            logger.error(e2);
            return null;
        }
    }

    public void getDenseTable(Target target, OID[] oidArr, TableListener tableListener, Object obj, OID oid, OID oid2) {
        if (oidArr == null || oidArr.length == 0) {
            throw new IllegalArgumentException("No column OIDs specified");
        }
        new TableRequest(target, oidArr, tableListener, obj, oid, oid2).sendNextChunk();
    }

    public int getMaxNumColumnsPerPDU() {
        return this.maxNumColumnsPerPDU;
    }

    public int getMaxNumRowsPerPDU() {
        return this.maxNumOfRowsPerPDU;
    }

    public List<TableEvent> getTable(Target target, OID[] oidArr, OID oid, OID oid2) {
        if (oidArr == null || oidArr.length == 0) {
            throw new IllegalArgumentException("No column OIDs specified");
        }
        InternalTableListener internalTableListener = new InternalTableListener();
        TableRequest tableRequestCreateTableRequest = createTableRequest(target, oidArr, internalTableListener, null, oid, oid2);
        synchronized (internalTableListener) {
            if (tableRequestCreateTableRequest.sendNextChunk()) {
                while (!internalTableListener.isFinished()) {
                    try {
                        internalTableListener.wait();
                    } catch (InterruptedException unused) {
                        Thread.currentThread().interrupt();
                    }
                }
            }
        }
        return internalTableListener.getRows();
    }

    public void setMaxNumColumnsPerPDU(int i2) {
        if (i2 < 1) {
            throw new IllegalArgumentException("The number of columns per PDU must be > 0");
        }
        this.maxNumColumnsPerPDU = i2;
    }

    public void setMaxNumRowsPerPDU(int i2) {
        if (i2 < 1) {
            throw new IllegalArgumentException("The number of rows per PDU must be > 0");
        }
        this.maxNumOfRowsPerPDU = i2;
    }

    public void getTable(Target target, OID[] oidArr, TableListener tableListener, Object obj, OID oid, OID oid2) {
        if (oidArr != null && oidArr.length != 0) {
            new TableRequest(target, oidArr, tableListener, obj, oid, oid2).sendNextChunk();
            return;
        }
        throw new IllegalArgumentException("No column OIDs specified");
    }
}