package org.snmp4j.agent.io.prop;

import com.cvte.vman.instance.InvokeCmd;
import java.io.IOException;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.SortedMap;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.snmp4j.agent.io.Context;
import org.snmp4j.agent.io.IndexedVariables;
import org.snmp4j.agent.io.MOInfo;
import org.snmp4j.agent.io.MOInput;
import org.snmp4j.agent.io.Sequence;
import org.snmp4j.agent.mo.util.VariableProvider;
import org.snmp4j.log.LogAdapter;
import org.snmp4j.log.LogFactory;
import org.snmp4j.smi.Integer32;
import org.snmp4j.smi.IpAddress;
import org.snmp4j.smi.Null;
import org.snmp4j.smi.OID;
import org.snmp4j.smi.OctetString;
import org.snmp4j.smi.TimeTicks;
import org.snmp4j.smi.UnsignedInteger32;
import org.snmp4j.smi.Variable;
import org.snmp4j.util.OIDTextFormat;
import org.snmp4j.util.SimpleOIDTextFormat;

/* JADX INFO: loaded from: classes.dex */
public class PropertyMOInput implements MOInput {
    public static final String CONFIG_PREFIX = "snmp4j.agent.cfg.";
    public static final String CONTEXTS_ID = "contexts";
    public static final String CTX_ID = "ctx.";
    public static final String INDEX_ID = "index.";
    public static final String OID_ID = "oid.";
    private static final int STATE_ALL_CTX_DATA = 1;
    private static final int STATE_ALL_CTX_DATA_SEQ = 0;
    private static final int STATE_CTX_DATA = 4;
    private static final int STATE_CTX_DATA_SEQ = 3;
    private static final int STATE_CTX_SEQ = 2;
    public static final String VALUE_ID = "value.";
    public static final String VERSION_ID = "version.";
    private static final LogAdapter logger = LogFactory.getLogger(PropertyMOInput.class);
    private ContextInfo contexts;
    private DataInfo<?> data;
    private int importMode;
    private OIDTextFormat oidTextFormat;
    private OIDInfo oids;
    private SortedMap<String, String> properties;
    private int state;
    private VariableProvider variables;

    private class ContextInfo implements Iterator {
        OctetString curContext;
        Iterator iterator;
        int numContexts;

        ContextInfo(int i2, Iterator it) {
            this.numContexts = i2;
            this.iterator = it;
        }

        @Override // java.util.Iterator
        public boolean hasNext() {
            return this.iterator.hasNext();
        }

        @Override // java.util.Iterator
        public Object next() {
            OctetString octetString = (OctetString) this.iterator.next();
            this.curContext = octetString;
            return octetString;
        }

        @Override // java.util.Iterator
        public void remove() {
            throw new UnsupportedOperationException();
        }
    }

    private class DataInfo<T> implements Iterator {
        OctetString context;
        List<T> data = new ArrayList();
        Iterator<T> iterator;

        DataInfo(OctetString octetString) {
            this.context = octetString;
        }

        private void initIterator() {
            if (this.iterator == null) {
                this.iterator = this.data.iterator();
            }
        }

        public void add(T t) {
            this.data.add(t);
        }

        @Override // java.util.Iterator
        public boolean hasNext() {
            initIterator();
            return this.iterator.hasNext();
        }

        @Override // java.util.Iterator
        public T next() {
            initIterator();
            return this.iterator.next();
        }

        @Override // java.util.Iterator
        public void remove() {
            throw new UnsupportedOperationException();
        }

        public int size() {
            return this.data.size();
        }
    }

    private class OIDInfo implements Iterator {
        OctetString curContext;
        MOInfo curOID;
        Iterator<MOInfo> iterator;
        int numElements;

        OIDInfo(OctetString octetString, int i2, Iterator<MOInfo> it) {
            this.numElements = i2;
            this.iterator = it;
            this.curContext = octetString;
        }

        @Override // java.util.Iterator
        public boolean hasNext() {
            return this.iterator.hasNext();
        }

        @Override // java.util.Iterator
        public Object next() {
            MOInfo next = this.iterator.next();
            this.curOID = next;
            return next;
        }

        @Override // java.util.Iterator
        public void remove() {
            throw new UnsupportedOperationException();
        }
    }

    public PropertyMOInput(Properties properties) {
        this.importMode = 1;
        this.state = 0;
        this.oidTextFormat = new SimpleOIDTextFormat();
        SortedMap<String, String> sortedMapScanProperties = scanProperties(properties);
        this.properties = sortedMapScanProperties;
        this.contexts = scanContexts(sortedMapScanProperties);
    }

    private OID parseOID(String str) {
        try {
            return new OID(this.oidTextFormat.parse(str));
        } catch (ParseException e2) {
            throw new RuntimeException("OID '" + str + "' cannot be parsed", e2);
        }
    }

    private ContextInfo scanContexts(Map map) {
        StringTokenizer stringTokenizer = new StringTokenizer((String) map.get("snmp4j.agent.cfg.contexts"), ",");
        ArrayList arrayList = new ArrayList(stringTokenizer.countTokens());
        while (stringTokenizer.hasMoreTokens()) {
            arrayList.add(new Context((OctetString) createVariableFromString(stringTokenizer.nextToken(), OctetString.class)));
        }
        return new ContextInfo(arrayList.size(), arrayList.iterator());
    }

    private void scanDataIndexVariables(SortedMap sortedMap, OID oid, DataInfo<IndexedVariables> dataInfo) {
        String str = dataInfo.context != null ? CTX_ID + dataInfo.context : "";
        String str2 = (String) sortedMap.get((CONFIG_PREFIX + str) + OID_ID + oid.toDottedString());
        if (str2 == null) {
            return;
        }
        StringTokenizer stringTokenizer = new StringTokenizer(str2, ": ");
        int i2 = Integer.parseInt(stringTokenizer.nextToken());
        int i3 = Integer.parseInt(stringTokenizer.nextToken());
        String str3 = CONFIG_PREFIX + str + INDEX_ID + oid.toDottedString();
        String str4 = CONFIG_PREFIX + str + VALUE_ID + oid.toDottedString();
        for (int i4 = 0; i4 < i2; i4++) {
            OID oid2 = (OID) createVariableFromString((String) sortedMap.get(str3 + "." + i4), OID.class);
            Variable[] variableArr = new Variable[i3];
            for (int i5 = 0; i5 < i3; i5++) {
                String str5 = (String) sortedMap.get(str4 + "." + i4 + "." + i5);
                if (str5 != null) {
                    variableArr[i5] = createVariableFromString(str5, Variable.class);
                }
            }
            dataInfo.add(new IndexedVariables(oid2, variableArr));
        }
    }

    private void scanDataVariable(SortedMap sortedMap, OID oid, DataInfo<Variable> dataInfo) {
        String str;
        if (dataInfo.context != null) {
            str = CTX_ID + dataInfo.context;
        } else {
            str = "";
        }
        dataInfo.add(createVariableFromString((String) sortedMap.get((CONFIG_PREFIX + str) + OID_ID + oid.toDottedString()), Variable.class));
    }

    private OIDInfo scanOIDs(SortedMap<String, String> sortedMap, OctetString octetString) {
        String str;
        if (octetString != null) {
            str = CTX_ID + octetString.toString() + ".";
        } else {
            str = "";
        }
        String str2 = "snmp4j.agent.cfg.oid." + str;
        SortedMap<String, String> sortedMapTailMap = sortedMap.tailMap(str2);
        ArrayList arrayList = new ArrayList();
        Iterator<Map.Entry<String, String>> it = sortedMapTailMap.entrySet().iterator();
        while (it.hasNext()) {
            String key = it.next().getKey();
            if (!key.startsWith(str2)) {
                break;
            }
            arrayList.add(new MOInfo(parseOID(key.substring(str2.length())), sortedMap.get("snmp4j.agent.cfg.version." + str)));
        }
        return new OIDInfo(octetString, arrayList.size(), arrayList.iterator());
    }

    private static SortedMap<String, String> scanProperties(Properties properties) {
        TreeMap treeMap = new TreeMap();
        for (Map.Entry entry : properties.entrySet()) {
            if (entry.getKey().toString().startsWith(CONFIG_PREFIX)) {
                treeMap.put(entry.getKey().toString(), entry.getValue().toString());
            }
        }
        return treeMap;
    }

    @Override // org.snmp4j.agent.io.MOInput
    public void close() throws IOException {
    }

    public Variable createVariableFromString(String str, Class<? extends Variable> cls) {
        String strSubstring;
        char cCharAt;
        Variable variable = null;
        if (str != null) {
            if (str.length() >= 3) {
                cCharAt = str.charAt(1);
                int iIndexOf = str.indexOf(InvokeCmd.CMD_SYSTEMCTRL_GET_REFRESH_RATE);
                strSubstring = cCharAt == '$' ? str.substring(2, iIndexOf) : null;
                str = str.substring(iIndexOf + 1);
            } else {
                strSubstring = null;
                cCharAt = ' ';
            }
            if (cCharAt != ' ') {
                if (cCharAt == '$') {
                    VariableProvider variableProvider = this.variables;
                    if (variableProvider != null) {
                        variable = variableProvider.getVariable(strSubstring);
                    }
                } else if (cCharAt == 'd') {
                    variable = OctetString.fromString(str, '.', 10);
                } else if (cCharAt == 'i') {
                    variable = new Integer32(Integer.parseInt(str));
                } else if (cCharAt == 'x') {
                    variable = OctetString.fromString(str, ':', 16);
                } else if (cCharAt == 'a') {
                    variable = new IpAddress(str);
                } else if (cCharAt == 'b') {
                    variable = OctetString.fromString(str, ' ', 2);
                } else if (cCharAt == 'n') {
                    variable = new Null();
                } else if (cCharAt != 'o') {
                    switch (cCharAt) {
                        case InvokeCmd.CMD_SYSTEMCTRL_SET_CUSTOMBOOTMEDIA_TYPE /* 115 */:
                            variable = new OctetString(str);
                            break;
                        case InvokeCmd.CMD_SYSTEMCTRL_KEEP_GPU_PERFORMANCE /* 116 */:
                            variable = new TimeTicks(Long.parseLong(str));
                            break;
                        case InvokeCmd.CMD_SYSTEMCTRL_CANCEL_GPU_PERFORMANCE /* 117 */:
                            variable = new UnsignedInteger32(Long.parseLong(str));
                            break;
                        default:
                            throw new IllegalArgumentException("Variable type " + cCharAt + " not supported");
                    }
                } else {
                    try {
                        variable = parseOID(str);
                    } catch (Exception unused) {
                        Matcher matcher = Pattern.compile("(\\$#?\\{[^\\}]*\\})").matcher(str);
                        StringBuffer stringBuffer = new StringBuffer();
                        while (matcher.find()) {
                            String strGroup = matcher.group();
                            boolean z = strGroup.charAt(1) != '#';
                            String strSubstring2 = strGroup.substring(strGroup.indexOf(InvokeCmd.CMD_SYSTEMCTRL_SET_SCREENOFF_AUDIO_ENABLE) + 1, strGroup.length() - 1);
                            VariableProvider variableProvider2 = this.variables;
                            Variable oid = variableProvider2 == null ? new OID() : variableProvider2.getVariable(strSubstring2);
                            if (oid != null) {
                                matcher.appendReplacement(stringBuffer, oid.toSubIndex(z).toDottedString());
                            }
                        }
                        matcher.appendTail(stringBuffer);
                        variable = parseOID(stringBuffer.toString());
                    }
                }
                cls.isInstance(variable);
            }
        }
        return variable;
    }

    @Override // org.snmp4j.agent.io.MOInput
    public int getImportMode() {
        return this.importMode;
    }

    @Override // org.snmp4j.agent.io.MOInput
    public Context readContext() throws IOException {
        int i2 = this.state;
        if (i2 > 2 || this.contexts == null) {
            throw new IOException();
        }
        if (i2 < 2) {
            this.state = 2;
        }
        return (Context) this.contexts.iterator.next();
    }

    @Override // org.snmp4j.agent.io.MOInput
    public IndexedVariables readIndexedVariables() throws IOException {
        if (this.data == null) {
            DataInfo<IndexedVariables> dataInfo = new DataInfo<>(this.oids.curContext);
            this.data = dataInfo;
            scanDataIndexVariables(this.properties, this.oids.curOID.getOID(), dataInfo);
        }
        IndexedVariables indexedVariables = (IndexedVariables) this.data.next();
        if (logger.isDebugEnabled()) {
            logger.debug("Read indexed variables " + indexedVariables + " for OID " + this.oids.curOID.getOID() + " in context " + this.oids.curContext);
        }
        return indexedVariables;
    }

    @Override // org.snmp4j.agent.io.MOInput
    public MOInfo readManagedObject() throws IOException {
        MOInfo mOInfo = (MOInfo) this.oids.next();
        this.data = null;
        if (logger.isDebugEnabled()) {
            logger.debug("Read MO " + mOInfo);
        }
        return mOInfo;
    }

    @Override // org.snmp4j.agent.io.MOInput
    public Sequence readSequence() throws IOException {
        int i2 = this.state;
        if (i2 == 0) {
            this.state = i2 + 1;
            OIDInfo oIDInfoScanOIDs = scanOIDs(this.properties, null);
            this.oids = oIDInfoScanOIDs;
            return new Sequence(oIDInfoScanOIDs.numElements);
        }
        if (i2 != 1) {
            if (i2 != 2) {
                return null;
            }
        } else {
            if (this.data == null || this.oids.iterator.hasNext()) {
                DataInfo<IndexedVariables> dataInfo = new DataInfo<>(this.oids.curContext);
                this.data = dataInfo;
                scanDataIndexVariables(this.properties, this.oids.curOID.getOID(), dataInfo);
                return new Sequence(this.data.size());
            }
            this.state++;
        }
        this.state++;
        return new Sequence(this.contexts.numContexts);
    }

    @Override // org.snmp4j.agent.io.MOInput
    public Variable readVariable() throws IOException {
        if (this.data == null) {
            DataInfo<Variable> dataInfo = new DataInfo<>(this.oids.curContext);
            this.data = dataInfo;
            scanDataVariable(this.properties, this.oids.curOID.getOID(), dataInfo);
        }
        Variable variable = (Variable) this.data.next();
        if (logger.isDebugEnabled()) {
            logger.debug("Read variable " + variable + " for OID " + this.oids.curOID.getOID() + " in context " + this.oids.curContext);
        }
        return variable;
    }

    @Override // org.snmp4j.agent.io.MOInput
    public void skipContext(Context context) throws IOException {
    }

    @Override // org.snmp4j.agent.io.MOInput
    public void skipManagedObject(MOInfo mOInfo) throws IOException {
    }

    public PropertyMOInput(Properties properties, VariableProvider variableProvider) {
        this(properties);
        this.variables = variableProvider;
    }

    public PropertyMOInput(Properties properties, VariableProvider variableProvider, OIDTextFormat oIDTextFormat) {
        this(properties, variableProvider);
        this.oidTextFormat = oIDTextFormat;
    }
}