package org.snmp4j.agent.io;

import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.Map;
import org.snmp4j.agent.MOContextScope;
import org.snmp4j.agent.MOScope;
import org.snmp4j.agent.MOServer;
import org.snmp4j.agent.ManagedObject;
import org.snmp4j.agent.SerializableManagedObject;
import org.snmp4j.log.LogAdapter;
import org.snmp4j.log.LogFactory;
import org.snmp4j.smi.OID;
import org.snmp4j.smi.OctetString;

/* JADX INFO: loaded from: classes.dex */
public class MOServerPersistence {
    private static final LogAdapter logger = LogFactory.getLogger(MOServerPersistence.class);
    private MOServer[] servers;

    public MOServerPersistence(MOServer mOServer) {
        this(new MOServer[]{mOServer});
    }

    private HashMap<OctetString, LinkedHashMap<OID, SerializableManagedObject>> buildCache() {
        HashMap<OctetString, LinkedHashMap<OID, SerializableManagedObject>> map = new HashMap<>();
        map.clear();
        for (MOServer mOServer : this.servers) {
            for (Map.Entry<MOScope, ManagedObject> entry : mOServer) {
                MOScope key = entry.getKey();
                ManagedObject value = entry.getValue();
                if (value instanceof SerializableManagedObject) {
                    SerializableManagedObject serializableManagedObject = (SerializableManagedObject) value;
                    if (!serializableManagedObject.isVolatile()) {
                        OctetString context = key instanceof MOContextScope ? ((MOContextScope) key).getContext() : null;
                        LinkedHashMap<OID, SerializableManagedObject> linkedHashMap = map.get(context);
                        if (linkedHashMap == null) {
                            linkedHashMap = new LinkedHashMap<>();
                            map.put(context, linkedHashMap);
                        }
                        linkedHashMap.put(serializableManagedObject.getID(), serializableManagedObject);
                    }
                }
            }
        }
        return map;
    }

    private static void readData(MOInput mOInput, LinkedHashMap<OID, SerializableManagedObject> linkedHashMap) throws IOException {
        Sequence sequence = mOInput.readSequence();
        if (sequence != null) {
            for (int i2 = 0; i2 < sequence.getSize(); i2++) {
                MOInfo managedObject = mOInput.readManagedObject();
                if (logger.isDebugEnabled()) {
                    logger.debug("Looking up object " + managedObject.getOID());
                }
                SerializableManagedObject serializableManagedObject = linkedHashMap.get(managedObject.getOID());
                if (serializableManagedObject != null) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Loading data for object " + managedObject.getOID());
                    }
                    serializableManagedObject.load(mOInput);
                }
                mOInput.skipManagedObject(managedObject);
            }
        }
    }

    private static void writeData(MOOutput mOOutput, Context context, LinkedHashMap<? extends OID, SerializableManagedObject> linkedHashMap) throws IOException {
        if (logger.isDebugEnabled()) {
            if (context == null) {
                logger.debug("Writing " + linkedHashMap.size() + " context independent managed objects");
            } else {
                logger.debug("Writing " + linkedHashMap.size() + " managed objects for context '" + context.getContext() + "'");
            }
        }
        mOOutput.writeSequence(new Sequence(linkedHashMap.size()));
        for (SerializableManagedObject serializableManagedObject : linkedHashMap.values()) {
            MOInfo mOInfo = new MOInfo(serializableManagedObject.getID());
            mOOutput.writeManagedObjectBegin(mOInfo);
            serializableManagedObject.save(mOOutput);
            mOOutput.writeManagedObjectEnd(mOInfo);
        }
    }

    public synchronized void loadData(MOInput mOInput) throws IOException {
        HashMap<OctetString, LinkedHashMap<OID, SerializableManagedObject>> mapBuildCache = buildCache();
        LinkedHashMap<OID, SerializableManagedObject> linkedHashMap = mapBuildCache.get(null);
        if (linkedHashMap != null) {
            readData(mOInput, linkedHashMap);
        } else {
            Sequence sequence = mOInput.readSequence();
            for (int i2 = 0; i2 < sequence.getSize(); i2++) {
                mOInput.skipManagedObject(mOInput.readManagedObject());
            }
        }
        Sequence sequence2 = mOInput.readSequence();
        if (sequence2 != null) {
            for (int i3 = 0; i3 < sequence2.getSize(); i3++) {
                Context context = mOInput.readContext();
                boolean z = true;
                for (int i4 = 0; z && i4 < this.servers.length; i4++) {
                    if (this.servers[i4].isContextSupported(context.getContext())) {
                        z = false;
                    }
                }
                if (z) {
                    logger.warn("Context '" + context.getContext() + "' is no longer supported by agent");
                    mOInput.skipContext(context);
                } else {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Loading data for context '" + context.getContext() + "'");
                    }
                    LinkedHashMap<OID, SerializableManagedObject> linkedHashMap2 = mapBuildCache.get(context.getContext());
                    if (linkedHashMap2 == null) {
                        mOInput.skipContext(context);
                    } else {
                        readData(mOInput, linkedHashMap2);
                        mOInput.skipContext(context);
                    }
                }
            }
        }
    }

    public synchronized void saveData(MOOutput mOOutput) throws IOException {
        HashMap<OctetString, LinkedHashMap<OID, SerializableManagedObject>> mapBuildCache = buildCache();
        LinkedHashMap<OID, SerializableManagedObject> linkedHashMap = mapBuildCache.get(null);
        if (logger.isDebugEnabled()) {
            logger.debug("Trying to write MIB data for all contexts");
        }
        if (linkedHashMap != null) {
            writeData(mOOutput, null, linkedHashMap);
        } else {
            mOOutput.writeSequence(new Sequence(0));
        }
        HashSet hashSet = new HashSet();
        for (MOServer mOServer : this.servers) {
            hashSet.addAll(Arrays.asList(mOServer.getContexts()));
        }
        OctetString[] octetStringArr = (OctetString[]) hashSet.toArray(new OctetString[hashSet.size()]);
        mOOutput.writeSequence(new Sequence(octetStringArr.length));
        for (OctetString octetString : octetStringArr) {
            Context context = new Context(octetString);
            mOOutput.writeContextBegin(context);
            if (logger.isDebugEnabled()) {
                logger.debug("Trying to write MIB data for context '" + context.getContext() + "'");
            }
            LinkedHashMap<OID, SerializableManagedObject> linkedHashMap2 = mapBuildCache.get(context.getContext());
            if (linkedHashMap2 != null) {
                writeData(mOOutput, context, linkedHashMap2);
            }
            mOOutput.writeContextEnd(context);
        }
    }

    public MOServerPersistence(MOServer[] mOServerArr) {
        this.servers = mOServerArr;
    }
}