package org.snmp4j.agent;

import java.util.Comparator;
import org.snmp4j.smi.OctetString;
import org.snmp4j.smi.Variable;

/* JADX INFO: loaded from: classes.dex */
public class MOScopeComparator implements Comparator<MOScope> {
    private static int compareContextScope(MOScope mOScope, MOContextScope mOContextScope) {
        if (mOScope == mOContextScope) {
            return 0;
        }
        int iCompareScope = compareScope(mOScope, mOContextScope);
        if (iCompareScope != 0 || !(mOScope instanceof MOContextScope)) {
            return iCompareScope;
        }
        OctetString context = ((MOContextScope) mOScope).getContext();
        OctetString context2 = mOContextScope.getContext();
        return (context == null || context2 == null) ? iCompareScope : context.compareTo((Variable) context2);
    }

    private static int compareQueryWithScope(MOScope mOScope, MOQuery mOQuery) {
        if (mOScope.getUpperBound() == null) {
            return 1;
        }
        int iCompareTo = mOScope.getUpperBound().compareTo((Variable) mOQuery.getLowerBound());
        if (iCompareTo == 0 && (!mOScope.isUpperIncluded() || !mOQuery.isLowerIncluded())) {
            return -1;
        }
        if (iCompareTo != 0 || !(mOScope instanceof MOContextScope)) {
            return iCompareTo;
        }
        OctetString context = ((MOContextScope) mOScope).getContext();
        OctetString context2 = mOQuery.getContext();
        return (context == null || context2 == null) ? iCompareTo : context.compareTo((Variable) context2);
    }

    private static int compareScope(MOScope mOScope, MOScope mOScope2) {
        if (mOScope == mOScope2 || mOScope.equals(mOScope2)) {
            return 0;
        }
        if (mOScope.getUpperBound() == null) {
            if (mOScope2.getUpperBound() != null) {
                return 1;
            }
            int iCompareTo = mOScope.getLowerBound().compareTo((Variable) mOScope2.getLowerBound());
            if (iCompareTo == 0) {
                return iCompareTo + (mOScope.isLowerIncluded() ? -1 : 0) + (mOScope2.isLowerIncluded() ? 1 : 0);
            }
            return iCompareTo;
        }
        int iCompareTo2 = mOScope.getUpperBound().compareTo((Variable) mOScope2.getUpperBound());
        if (iCompareTo2 != 0) {
            return iCompareTo2;
        }
        int i2 = iCompareTo2 + (mOScope.isUpperIncluded() ? -1 : 0) + (mOScope2.isUpperIncluded() ? 1 : 0);
        if (i2 != 0) {
            return i2;
        }
        int iCompareTo3 = mOScope.getUpperBound().compareTo((Variable) mOScope2.getLowerBound());
        if (iCompareTo3 != 0) {
            return iCompareTo3;
        }
        if (mOScope.isUpperIncluded() && mOScope2.isLowerIncluded()) {
            return iCompareTo3;
        }
        return -1;
    }

    public static boolean isQueryContextMatching(MOQuery mOQuery, MOScope mOScope) {
        OctetString context = mOQuery.getContext();
        return context == null || !(mOScope instanceof MOContextScope) || context.equals(((MOContextScope) mOScope).getContext());
    }

    @Override // java.util.Comparator
    public boolean equals(Object obj) {
        return (obj instanceof MOScopeComparator) && this == obj;
    }

    public int hashCode() {
        return super.hashCode();
    }

    @Override // java.util.Comparator
    public int compare(MOScope mOScope, MOScope mOScope2) {
        int iCompareContextScope;
        if (mOScope == mOScope2) {
            return 0;
        }
        if (mOScope2 instanceof MOQuery) {
            return compareQueryWithScope(mOScope, (MOQuery) mOScope2);
        }
        if (mOScope instanceof MOQuery) {
            iCompareContextScope = compareQueryWithScope(mOScope2, (MOQuery) mOScope);
        } else {
            if (mOScope2 instanceof MOContextScope) {
                return compareContextScope(mOScope, (MOContextScope) mOScope2);
            }
            if (!(mOScope instanceof MOContextScope)) {
                return compareScope(mOScope, mOScope2);
            }
            iCompareContextScope = compareContextScope(mOScope2, (MOContextScope) mOScope);
        }
        return -iCompareContextScope;
    }
}