package org.snmp4j.agent;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import java.util.TreeMap;
import java.util.Vector;
import org.snmp4j.agent.mo.MOColumn;
import org.snmp4j.agent.mo.MOTable;
import org.snmp4j.agent.mo.MOTableModel;
import org.snmp4j.agent.mo.MOTableRow;
import org.snmp4j.agent.mo.MOTableRowListener;
import org.snmp4j.agent.mo.lock.DefaultMOLockStrategy;
import org.snmp4j.agent.mo.lock.LockRequest;
import org.snmp4j.agent.mo.lock.MOLockStrategy;
import org.snmp4j.log.LogAdapter;
import org.snmp4j.log.LogFactory;
import org.snmp4j.smi.OID;
import org.snmp4j.smi.OctetString;
import org.snmp4j.smi.Variable;
import org.snmp4j.smi.VariableBinding;

/* JADX INFO: loaded from: classes.dex */
public class DefaultMOServer implements MOServer {
    private static final LogAdapter logger = LogFactory.getLogger(DefaultMOServer.class);
    private transient Vector<ContextListener> contextListeners;
    private Map<ManagedObject, List<MOServerLookupListener>> lookupListener;
    private UpdateStrategy updateStrategy;
    private MOLockStrategy lockStrategy = new DefaultMOLockStrategy();
    private SortedMap<MOScope, ManagedObject> registry = new TreeMap(new MOScopeComparator());
    private Set<OctetString> contexts = new LinkedHashSet(10);
    private Map<ManagedObject, Lock> lockList = new Hashtable(10);

    public static Variable getValue(MOServer mOServer, OctetString octetString, OID oid) {
        ManagedObject managedObjectLookup = mOServer.lookup(new DefaultMOQuery(new DefaultMOContextScope(octetString, oid, true, oid, true)));
        if (managedObjectLookup instanceof ManagedObjectValueAccess) {
            return ((ManagedObjectValueAccess) managedObjectLookup).getValue(oid);
        }
        return null;
    }

    public static <R extends MOTableRow, T extends MOTable<R, ? extends MOColumn, ? extends MOTableModel<R>>> void registerTableRowListener(MOServer mOServer, MOTableRowListener<R> mOTableRowListener) {
        Iterator<Map.Entry<MOScope, ManagedObject>> it = mOServer.iterator();
        while (it.hasNext()) {
            ManagedObject value = it.next().getValue();
            if (value instanceof MOTable) {
                ((MOTable) value).addMOTableRowListener(mOTableRowListener);
            }
        }
    }

    public static boolean setValue(MOServer mOServer, OctetString octetString, VariableBinding variableBinding) {
        OID oid = variableBinding.getOid();
        ManagedObject managedObjectLookup = mOServer.lookup(new DefaultMOQuery(new DefaultMOContextScope(octetString, oid, true, oid, true)));
        if (managedObjectLookup instanceof ManagedObjectValueAccess) {
            return ((ManagedObjectValueAccess) managedObjectLookup).setValue(variableBinding);
        }
        return false;
    }

    public static <R extends MOTableRow, T extends MOTable<R, ? extends MOColumn, ? extends MOTableModel<R>>> void unregisterTableRowListener(MOServer mOServer, MOTableRowListener<R> mOTableRowListener) {
        Iterator<Map.Entry<MOScope, ManagedObject>> it = mOServer.iterator();
        while (it.hasNext()) {
            ManagedObject value = it.next().getValue();
            if (value instanceof MOTable) {
                ((MOTable) value).removeMOTableRowListener(mOTableRowListener);
            }
        }
    }

    @Override // org.snmp4j.agent.MOServer
    public void addContext(OctetString octetString) {
        this.contexts.add(octetString);
    }

    @Override // org.snmp4j.agent.MOServer
    public synchronized void addContextListener(ContextListener contextListener) {
        if (this.contextListeners == null) {
            this.contextListeners = new Vector<>(2);
        }
        this.contextListeners.add(contextListener);
    }

    @Override // org.snmp4j.agent.MOServer
    public synchronized void addLookupListener(MOServerLookupListener mOServerLookupListener, ManagedObject managedObject) {
        if (this.lookupListener == null) {
            this.lookupListener = Collections.synchronizedMap(new HashMap());
        }
        List<MOServerLookupListener> listSynchronizedList = this.lookupListener.get(managedObject);
        if (listSynchronizedList == null) {
            listSynchronizedList = Collections.synchronizedList(new LinkedList());
            this.lookupListener.put(managedObject, listSynchronizedList);
        }
        listSynchronizedList.add(mOServerLookupListener);
    }

    protected void checkForUpdate(UpdatableManagedObject updatableManagedObject, MOQuery mOQuery) {
        UpdateStrategy updateStrategy = this.updateStrategy;
        if (updateStrategy == null || !updateStrategy.isUpdateNeeded(this, updatableManagedObject, mOQuery)) {
            return;
        }
        if (logger.isDebugEnabled()) {
            logger.debug("Updating UpdatableManagedObject " + updatableManagedObject + " on behalf of query " + mOQuery);
        }
        updatableManagedObject.update(mOQuery);
    }

    protected void fireContextChanged(ContextEvent contextEvent) {
        Vector<ContextListener> vector = this.contextListeners;
        if (vector != null) {
            Iterator<ContextListener> it = vector.iterator();
            while (it.hasNext()) {
                it.next().contextChanged(contextEvent);
            }
        }
    }

    protected void fireLookupEvent(ManagedObject managedObject, MOQuery mOQuery) {
        List<MOServerLookupListener> list;
        Map<ManagedObject, List<MOServerLookupListener>> map = this.lookupListener;
        if (map == null || (list = map.get(managedObject)) == null) {
            return;
        }
        MOServerLookupEvent mOServerLookupEvent = new MOServerLookupEvent(this, managedObject, mOQuery);
        Iterator it = new ArrayList(list).iterator();
        while (it.hasNext()) {
            ((MOServerLookupListener) it.next()).lookupEvent(mOServerLookupEvent);
        }
    }

    protected void fireQueryEvent(ManagedObject managedObject, MOQuery mOQuery) {
        List<MOServerLookupListener> list;
        Map<ManagedObject, List<MOServerLookupListener>> map = this.lookupListener;
        if (map == null || (list = map.get(managedObject)) == null) {
            return;
        }
        MOServerLookupEvent mOServerLookupEvent = new MOServerLookupEvent(this, managedObject, mOQuery);
        Iterator it = new ArrayList(list).iterator();
        while (it.hasNext()) {
            ((MOServerLookupListener) it.next()).queryEvent(mOServerLookupEvent);
        }
    }

    @Override // org.snmp4j.agent.MOServer
    public OctetString[] getContexts() {
        Set<OctetString> set = this.contexts;
        return (OctetString[]) set.toArray(new OctetString[set.size()]);
    }

    public MOLockStrategy getLockStrategy() {
        return this.lockStrategy;
    }

    public ManagedObject getManagedObject(OID oid, OctetString octetString, boolean z) {
        ManagedObject value;
        boolean z2;
        DefaultMOQuery defaultMOQuery = new DefaultMOQuery(new DefaultMOContextScope(octetString, oid, true, oid, true));
        for (Map.Entry<MOScope, ManagedObject> entry : this.registry.tailMap(defaultMOQuery).entrySet()) {
            if (MOScopeComparator.isQueryContextMatching(defaultMOQuery, entry.getKey()) && ((((z2 = (value = entry.getValue()) instanceof RegisteredManagedObject)) && ((RegisteredManagedObject) value).getID().equals(oid)) || (!z2 && oid.equals(value.getScope().getLowerBound())))) {
                if (z) {
                    fireQueryEvent(value, defaultMOQuery);
                    boolean zLock = false;
                    if ((value instanceof UpdatableManagedObject) && (zLock = lock(this, value))) {
                        checkForUpdate((UpdatableManagedObject) value, defaultMOQuery);
                    }
                    fireLookupEvent(value, defaultMOQuery);
                    if (zLock) {
                        unlock(this, value);
                    }
                }
                return value;
            }
        }
        return null;
    }

    @Override // org.snmp4j.agent.MOServer
    public OctetString[] getRegisteredContexts(ManagedObject managedObject) {
        HashSet hashSet = new HashSet();
        for (Map.Entry<MOScope, ManagedObject> entry : this.registry.tailMap(new DefaultMOContextScope(null, managedObject.getScope())).entrySet()) {
            MOScope key = entry.getKey();
            if (managedObject.equals(entry.getValue())) {
                if (key instanceof MOContextScope) {
                    hashSet.add(((MOContextScope) key).getContext());
                } else {
                    hashSet.add(null);
                }
            }
        }
        return (OctetString[]) hashSet.toArray(new OctetString[hashSet.size()]);
    }

    public SortedMap<MOScope, ManagedObject> getRegistry() {
        return this.registry;
    }

    public UpdateStrategy getUpdateStrategy() {
        return this.updateStrategy;
    }

    @Override // org.snmp4j.agent.MOServer
    public boolean isContextSupported(OctetString octetString) {
        if (octetString == null || octetString.length() == 0) {
            return true;
        }
        return this.contexts.contains(octetString);
    }

    @Override // org.snmp4j.agent.MOServer
    public Iterator<Map.Entry<MOScope, ManagedObject>> iterator() {
        Iterator<Map.Entry<MOScope, ManagedObject>> it;
        SortedMap<MOScope, ManagedObject> registry = getRegistry();
        synchronized (registry) {
            TreeMap treeMap = new TreeMap(new MOScopeComparator());
            treeMap.putAll(registry);
            it = treeMap.entrySet().iterator();
        }
        return it;
    }

    @Override // org.snmp4j.agent.MOServer
    public synchronized boolean lock(Object obj, ManagedObject managedObject) {
        return lock(obj, managedObject, 0L);
    }

    @Override // org.snmp4j.agent.MOServer
    public ManagedObject lookup(MOQuery mOQuery) {
        return lookup(mOQuery, false, null);
    }

    @Override // org.snmp4j.agent.MOServer
    public void register(ManagedObject managedObject, OctetString octetString) throws DuplicateRegistrationException {
        if (octetString == null || octetString.length() == 0) {
            DefaultMOContextScope defaultMOContextScope = new DefaultMOContextScope(null, managedObject.getScope());
            ManagedObject managedObjectLookup = lookup(new DefaultMOQuery(defaultMOContextScope));
            if (managedObjectLookup != null) {
                throw new DuplicateRegistrationException(defaultMOContextScope, managedObjectLookup.getScope());
            }
            this.registry.put(managedObject.getScope(), managedObject);
            if (logger.isInfoEnabled()) {
                logger.info("Registered MO [" + managedObject.getClass().getSimpleName() + "] in default context with scope " + managedObject.getScope());
                return;
            }
            return;
        }
        DefaultMOContextScope defaultMOContextScope2 = new DefaultMOContextScope(octetString, managedObject.getScope());
        ManagedObject managedObjectLookup2 = lookup(new DefaultMOQuery(defaultMOContextScope2), true, null);
        if (managedObjectLookup2 != null) {
            throw new DuplicateRegistrationException(defaultMOContextScope2, managedObjectLookup2.getScope());
        }
        this.registry.put(defaultMOContextScope2, managedObject);
        if (logger.isInfoEnabled()) {
            logger.info("Registered MO [" + managedObject.getClass().getSimpleName() + "] in context " + octetString + " with scope " + defaultMOContextScope2);
        }
    }

    @Override // org.snmp4j.agent.MOServer
    public void removeContext(OctetString octetString) {
        this.contexts.remove(octetString);
    }

    @Override // org.snmp4j.agent.MOServer
    public synchronized void removeContextListener(ContextListener contextListener) {
        if (this.contextListeners != null) {
            this.contextListeners.remove(contextListener);
        }
    }

    @Override // org.snmp4j.agent.MOServer
    public synchronized boolean removeLookupListener(MOServerLookupListener mOServerLookupListener, ManagedObject managedObject) {
        List<MOServerLookupListener> list;
        if (this.lookupListener == null || (list = this.lookupListener.get(managedObject)) == null) {
            return false;
        }
        return list.remove(mOServerLookupListener);
    }

    public void setLockStrategy(MOLockStrategy mOLockStrategy) {
        this.lockStrategy = mOLockStrategy;
    }

    public void setUpdateStrategy(UpdateStrategy updateStrategy) {
        this.updateStrategy = updateStrategy;
    }

    public String toString() {
        StringBuilder sb = new StringBuilder(DefaultMOServer.class.getName());
        sb.append("[contexts=");
        sb.append(this.contexts);
        sb.append("[keys={");
        Iterator<MOScope> it = this.registry.keySet().iterator();
        while (it.hasNext()) {
            MOScope next = it.next();
            sb.append(next.getLowerBound());
            if (next.isLowerIncluded()) {
                sb.append("+");
            }
            sb.append("-");
            sb.append(next.getUpperBound());
            if (next.isUpperIncluded()) {
                sb.append("+");
            }
            if (next instanceof MOContextScope) {
                sb.append("(");
                sb.append(((MOContextScope) next).getContext());
                sb.append(")");
            }
            if (it.hasNext()) {
                sb.append(",");
            }
        }
        sb.append("}");
        sb.append(",registry=");
        sb.append(this.registry);
        sb.append(",lockList=");
        sb.append(this.lockList);
        sb.append(",lookupListener=");
        sb.append(this.lookupListener);
        sb.append("]");
        return sb.toString();
    }

    @Override // org.snmp4j.agent.MOServer
    public synchronized boolean unlock(Object obj, ManagedObject managedObject) {
        if (managedObject != null) {
            Lock lock = this.lockList.get(managedObject);
            if (lock != null) {
                if (lock.getOwner() != obj) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Object '" + obj + "' is not owner of lock: " + lock);
                    }
                } else if (lock.remove()) {
                    this.lockList.remove(managedObject);
                    if (logger.isDebugEnabled()) {
                        logger.debug("Removed lock on " + managedObject + " by " + obj);
                    }
                    notify();
                    return true;
                }
            }
        }
        return false;
    }

    @Override // org.snmp4j.agent.MOServer
    public ManagedObject unregister(ManagedObject managedObject, OctetString octetString) {
        MOScope scope = (octetString == null || octetString.length() == 0) ? managedObject.getScope() : new DefaultMOContextScope(octetString, managedObject.getScope());
        ManagedObject managedObjectRemove = this.registry.remove(scope);
        if (managedObjectRemove == null) {
            Iterator<Map.Entry<MOScope, ManagedObject>> it = this.registry.tailMap(scope).entrySet().iterator();
            while (it.hasNext()) {
                Map.Entry<MOScope, ManagedObject> next = it.next();
                MOScope key = next.getKey();
                if (next.getValue().equals(managedObject) && ((octetString != null && (key instanceof MOContextScope) && octetString.equals(((MOContextScope) key).getContext())) || octetString == null)) {
                    managedObjectRemove = next.getValue();
                    it.remove();
                    break;
                }
            }
        }
        if (logger.isInfoEnabled()) {
            if (managedObjectRemove != null) {
                logger.info("Removed registration " + managedObjectRemove + " for " + managedObject.getScope() + " in context '" + octetString + "' successfully");
            } else {
                logger.warn("Removing registration failed for " + managedObject.getScope() + " in context '" + octetString + "'");
            }
        }
        return managedObjectRemove;
    }

    /* JADX WARN: Code restructure failed: missing block: B:39:0x00c9, code lost:
    
        r10.lockList.put(r12, new org.snmp4j.agent.DefaultMOServer.Lock(r11));
     */
    /* JADX WARN: Code restructure failed: missing block: B:40:0x00d9, code lost:
    
        if (org.snmp4j.agent.DefaultMOServer.logger.isDebugEnabled() == false) goto L42;
     */
    /* JADX WARN: Code restructure failed: missing block: B:41:0x00db, code lost:
    
        org.snmp4j.agent.DefaultMOServer.logger.debug("Acquired lock on " + r12 + " for " + r11);
     */
    /* JADX WARN: Code restructure failed: missing block: B:43:0x00fa, code lost:
    
        return true;
     */
    @Override // org.snmp4j.agent.MOServer
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    public synchronized boolean lock(java.lang.Object r11, org.snmp4j.agent.ManagedObject r12, long r13) {
        /*
            Method dump skipped, instruction units count: 256
            To view this dump add '--comments-level debug' option
        */
        throw new UnsupportedOperationException("Method not decompiled: org.snmp4j.agent.DefaultMOServer.lock(java.lang.Object, org.snmp4j.agent.ManagedObject, long):boolean");
    }

    @Override // org.snmp4j.agent.MOServer
    public ManagedObject lookup(MOQuery mOQuery, LockRequest lockRequest) {
        return lookup(mOQuery, false, lockRequest);
    }

    private ManagedObject lookup(MOQuery mOQuery, boolean z, LockRequest lockRequest) {
        SortedMap<MOScope, ManagedObject> sortedMapTailMap = this.registry.tailMap(mOQuery);
        if (lockRequest != null) {
            lockRequest.setLockRequestStatus(LockRequest.LockStatus.notRequired);
        }
        boolean z2 = false;
        for (Map.Entry<MOScope, ManagedObject> entry : sortedMapTailMap.entrySet()) {
            MOScope key = entry.getKey();
            if (MOScopeComparator.isQueryContextMatching(mOQuery, key) && (!z || ((key instanceof MOContextScope) && ((MOContextScope) key).getContext() != null))) {
                ManagedObject value = entry.getValue();
                if (mOQuery.getScope().isOverlapping(value.getScope())) {
                    fireQueryEvent(value, mOQuery);
                    if (this.lockStrategy != null && lockRequest != null && lockRequest.getLockOwner() != null && this.lockStrategy.isLockNeeded(value, mOQuery)) {
                        if (lock(lockRequest.getLockOwner(), value, lockRequest.getTimeoutMillis())) {
                            lockRequest.setLockRequestStatus(z2 ? LockRequest.LockStatus.lockedAfterTimeout : LockRequest.LockStatus.locked);
                        } else {
                            z2 = true;
                        }
                    }
                    if (value instanceof UpdatableManagedObject) {
                        checkForUpdate((UpdatableManagedObject) value, mOQuery);
                    }
                    if (mOQuery.matchesQuery(value)) {
                        fireLookupEvent(value, mOQuery);
                        return value;
                    }
                    if (lockRequest != null) {
                        unlock(lockRequest.getLockOwner(), value);
                    }
                } else {
                    continue;
                }
            }
        }
        if (!z2) {
            return null;
        }
        lockRequest.setLockRequestStatus(LockRequest.LockStatus.lockTimedOut);
        return null;
    }

    static class Lock {
        private int count;
        private long creationTime;
        private Object owner;

        private Lock() {
            this.count = 0;
            this.creationTime = System.currentTimeMillis();
            this.count = 0;
        }

        public synchronized void add() {
            this.count++;
        }

        public int getCount() {
            return this.count;
        }

        public long getCreationTime() {
            return this.creationTime;
        }

        public Object getOwner() {
            return this.owner;
        }

        public synchronized boolean remove() {
            int i2 = this.count - 1;
            this.count = i2;
            if (i2 > 0) {
                return false;
            }
            if (i2 != 0) {
                this.count = 0;
            }
            return true;
        }

        public String toString() {
            return "Lock[owner=" + this.owner + ", creationTime=" + this.creationTime + ", count=" + this.count + ']';
        }

        Lock(Object obj) {
            this();
            this.owner = obj;
            this.count = 1;
        }
    }

    public ManagedObject getManagedObject(OID oid, OctetString octetString) {
        return getManagedObject(oid, octetString, true);
    }
}