package org.snmp4j.agent.mo;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.snmp4j.agent.MOAccess;
import org.snmp4j.agent.mo.snmp.SNMPv2MIB;
import org.snmp4j.agent.mo.snmp.SNMPv2TC;
import org.snmp4j.agent.mo.snmp.SysUpTime;
import org.snmp4j.agent.mo.snmp.tc.TextualConvention;
import org.snmp4j.smi.OID;
import org.snmp4j.smi.OctetString;
import org.snmp4j.smi.Variable;

/* JADX INFO: loaded from: classes.dex */
public class DefaultMOFactory implements MOFactory, LinkedMOFactory {
    private static MOFactory instance;
    private Map<OID, Object> links;
    private Map<String, Map<String, TextualConvention>> textualConventions = new HashMap();

    protected DefaultMOFactory() {
    }

    public static void addSNMPv2TCs(MOFactory mOFactory) {
        Iterator<TextualConvention> it = new SNMPv2TC().getTextualConventions().iterator();
        while (it.hasNext()) {
            mOFactory.addTextualConvention(it.next());
        }
    }

    public static MOFactory getInstance() {
        if (instance == null) {
            DefaultMOFactory defaultMOFactory = new DefaultMOFactory();
            instance = defaultMOFactory;
            addSNMPv2TCs(defaultMOFactory);
        }
        return instance;
    }

    public static void setInstance(MOFactory mOFactory) {
        instance = mOFactory;
    }

    @Override // org.snmp4j.agent.mo.MOFactory
    public synchronized void addTextualConvention(TextualConvention textualConvention) {
        Map<String, TextualConvention> map = this.textualConventions.get(textualConvention.getModuleName());
        if (map == null) {
            map = new HashMap<>(10);
            this.textualConventions.put(textualConvention.getModuleName(), map);
        }
        map.put(textualConvention.getName(), textualConvention);
    }

    @Override // org.snmp4j.agent.mo.MOFactory
    public MOAccess createAccess(int i2) {
        return MOAccessImpl.getInstance(i2);
    }

    @Override // org.snmp4j.agent.mo.MOFactory
    public <V extends Variable> MOColumn<V> createColumn(int i2, int i3, MOAccess mOAccess) {
        return new MOMutableColumn(i2, i3, mOAccess);
    }

    @Override // org.snmp4j.agent.mo.MOFactory
    public MOTableIndex createIndex(MOTableSubIndex[] mOTableSubIndexArr, boolean z) {
        return new MOTableIndex(mOTableSubIndexArr, z);
    }

    @Override // org.snmp4j.agent.mo.MOTableRowFactory
    public MOTableRow createRow(OID oid, Variable[] variableArr) throws UnsupportedOperationException {
        return new DefaultMOMutableRow2PC(oid, variableArr);
    }

    @Override // org.snmp4j.agent.mo.MOFactory
    public <V extends Variable> MOScalar<V> createScalar(OID oid, MOAccess mOAccess, V v) {
        return new MOScalar<>(oid, mOAccess, v);
    }

    public MOTableSubIndex createSubIndex(int i2) {
        return new MOTableSubIndex(i2);
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // org.snmp4j.agent.mo.MOFactory
    public <R extends MOTableRow, M extends MOTableModel<R>> MOTable<R, MOColumn, M> createTable(OID oid, MOTableIndex mOTableIndex, MOColumn[] mOColumnArr) {
        return createTable(oid, mOTableIndex, mOColumnArr, createTableModel(oid, mOTableIndex, mOColumnArr));
    }

    @Override // org.snmp4j.agent.mo.MOFactory
    public <R extends MOTableRow, M extends MOTableModel<? extends R>> M createTableModel(OID oid, MOTableIndex mOTableIndex, MOColumn[] mOColumnArr) {
        return new DefaultMOMutableTableModel();
    }

    @Override // org.snmp4j.agent.mo.MOFactory
    public <BaseRow extends MOTableRow, DependentRow extends MOTableRow> MOTableRelation<BaseRow, DependentRow> createTableRelation(MOTable<BaseRow, ? extends MOColumn, ? extends MOTableModel<BaseRow>> mOTable, MOTable<DependentRow, ? extends MOColumn, ? extends MOTableModel<DependentRow>> mOTable2) {
        return new MOTableRelation<>(mOTable, mOTable2);
    }

    @Override // org.snmp4j.agent.mo.MOTableRowFactory
    public void freeRow(MOTableRow mOTableRow) {
    }

    @Override // org.snmp4j.agent.mo.LinkedMOFactory
    public Object getLink(OID oid) {
        Object obj = null;
        if (this.links != null) {
            OID oid2 = new OID(oid);
            while (oid2.size() > 0 && (obj = this.links.get(oid2)) == null) {
                oid2.trim(1);
            }
        }
        return obj;
    }

    @Override // org.snmp4j.agent.mo.MOFactory
    public SysUpTime getSysUpTime(OctetString octetString) {
        return SNMPv2MIB.getSysUpTime(octetString);
    }

    @Override // org.snmp4j.agent.mo.MOFactory
    public synchronized <V extends Variable> TextualConvention<V> getTextualConvention(String str, String str2) {
        Map<String, TextualConvention> map = this.textualConventions.get(str);
        if (map == null) {
            return null;
        }
        return map.get(str2);
    }

    protected Map<? extends String, ? extends Map<String, TextualConvention>> getTextualConventions() {
        return this.textualConventions;
    }

    protected synchronized void initLinkMap() {
        if (this.links == null) {
            this.links = new HashMap();
        }
    }

    @Override // org.snmp4j.agent.mo.MOFactory
    public synchronized void removeTextualConvention(TextualConvention textualConvention) {
        Map<String, TextualConvention> map = this.textualConventions.get(textualConvention.getModuleName());
        if (map != null) {
            map.remove(textualConvention.getName());
            if (map.isEmpty()) {
                this.textualConventions.remove(textualConvention.getModuleName());
            }
        }
    }

    @Override // org.snmp4j.agent.mo.LinkedMOFactory
    public void setLink(OID oid, Object obj) {
        if (this.links == null) {
            initLinkMap();
        }
        this.links.put(oid, obj);
    }

    @Override // org.snmp4j.agent.mo.MOFactory
    public <V extends Variable> MOColumn<V> createColumn(int i2, int i3, MOAccess mOAccess, V v, boolean z) {
        return new MOMutableColumn(i2, i3, mOAccess, v, z);
    }

    @Override // org.snmp4j.agent.mo.MOFactory
    public MOTableIndex createIndex(MOTableSubIndex[] mOTableSubIndexArr, boolean z, MOTableIndexValidator mOTableIndexValidator) {
        return new MOTableIndex(mOTableSubIndexArr, z, mOTableIndexValidator);
    }

    @Override // org.snmp4j.agent.mo.MOFactory
    public <V extends Variable> MOScalar<V> createScalar(OID oid, MOAccess mOAccess, V v, String str, String str2) {
        TextualConvention<V> textualConvention = getTextualConvention(str, str2);
        return textualConvention != null ? textualConvention.createScalar(oid, mOAccess, v) : createScalar(oid, mOAccess, v);
    }

    @Override // org.snmp4j.agent.mo.MOFactory
    public MOTableSubIndex createSubIndex(OID oid, int i2) {
        return new MOTableSubIndex(oid, i2);
    }

    @Override // org.snmp4j.agent.mo.MOFactory
    public <R extends MOTableRow, M extends MOTableModel<R>> MOTable<R, MOColumn, M> createTable(OID oid, MOTableIndex mOTableIndex, MOColumn[] mOColumnArr, M m) {
        return new DefaultMOTable(oid, mOTableIndex, mOColumnArr, m);
    }

    @Override // org.snmp4j.agent.mo.MOFactory
    public <V extends Variable> MOColumn<V> createColumn(int i2, int i3, MOAccess mOAccess, String str, String str2) {
        TextualConvention<V> textualConvention = getTextualConvention(str, str2);
        if (textualConvention != null) {
            return textualConvention.createColumn(i2, i3, mOAccess, null, true);
        }
        return createColumn(i2, i3, mOAccess);
    }

    public MOTableSubIndex createSubIndex(int i2, int i3, int i4) {
        return new MOTableSubIndex(i2, i3, i4);
    }

    @Override // org.snmp4j.agent.mo.MOFactory
    public MOTableSubIndex createSubIndex(OID oid, int i2, int i3, int i4) {
        return new MOTableSubIndex(oid, i2, i3, i4);
    }

    @Override // org.snmp4j.agent.mo.MOFactory
    public <V extends Variable> MOColumn<V> createColumn(int i2, int i3, MOAccess mOAccess, V v, boolean z, String str, String str2) {
        TextualConvention<V> textualConvention = getTextualConvention(str, str2);
        if (textualConvention != null) {
            return textualConvention.createColumn(i2, i3, mOAccess, v, z);
        }
        return createColumn(i2, i3, mOAccess, v, z);
    }
}