package com.facetec.sdk;

import java.io.IOException;
import java.lang.reflect.Field;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

/* loaded from: classes.dex */
public final class ev implements en, Cloneable {
    public static final ev d = new ev();
    private boolean b;
    private double e = -1.0d;
    private int c = 136;
    private boolean a = true;
    private List<ds> g = Collections.emptyList();
    private List<ds> h = Collections.emptyList();

    /* JADX INFO: Access modifiers changed from: private */
    /* renamed from: b, reason: merged with bridge method [inline-methods] */
    public ev clone() {
        try {
            return (ev) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new AssertionError(e);
        }
    }

    @Override // com.facetec.sdk.en
    public final <T> ek<T> e(dx dxVar, fv<T> fvVar) {
        boolean c = c(fvVar.a());
        boolean z = c || e(true);
        boolean z2 = c || e(false);
        if (z || z2) {
            return new ek<T>(this, z2, z, dxVar, fvVar) { // from class: com.facetec.sdk.ev.1
                private boolean a;
                private boolean b;
                private ek<T> c;
                private dx d;
                private fv e;
                private ev h;

                {
                    this.h = this;
                    this.a = z2;
                    this.b = z;
                    this.d = dxVar;
                    this.e = fvVar;
                }

                @Override // com.facetec.sdk.ek
                public final T a(fu fuVar) throws IOException {
                    if (this.a) {
                        fuVar.n();
                        return null;
                    }
                    return e().a(fuVar);
                }

                @Override // com.facetec.sdk.ek
                public final void b(ga gaVar, T t) throws IOException {
                    if (this.b) {
                        gaVar.h();
                    } else {
                        e().b(gaVar, t);
                    }
                }

                private ek<T> e() {
                    ek<T> ekVar = this.c;
                    if (ekVar != null) {
                        return ekVar;
                    }
                    ek<T> c2 = this.d.c(this.h, this.e);
                    this.c = c2;
                    return c2;
                }
            };
        }
        return null;
    }

    public final boolean b(Field field, boolean z) {
        el elVar;
        if ((this.c & field.getModifiers()) != 0) {
            return true;
        }
        if ((this.e != -1.0d && !b((ep) field.getAnnotation(ep.class), (es) field.getAnnotation(es.class))) || field.isSynthetic()) {
            return true;
        }
        if (this.b && ((elVar = (el) field.getAnnotation(el.class)) == null || (!z ? elVar.a() : elVar.d()))) {
            return true;
        }
        if ((!this.a && a(field.getType())) || e(field.getType())) {
            return true;
        }
        List<ds> list = z ? this.g : this.h;
        if (list.isEmpty()) {
            return false;
        }
        new dq(field);
        Iterator<ds> it = list.iterator();
        while (it.hasNext()) {
            if (it.next().b()) {
                return true;
            }
        }
        return false;
    }

    private boolean c(Class<?> cls) {
        if (this.e == -1.0d || b((ep) cls.getAnnotation(ep.class), (es) cls.getAnnotation(es.class))) {
            return (!this.a && a(cls)) || e(cls);
        }
        return true;
    }

    public final boolean d(Class<?> cls, boolean z) {
        return c(cls) || e(z);
    }

    private boolean e(boolean z) {
        Iterator<ds> it = (z ? this.g : this.h).iterator();
        while (it.hasNext()) {
            if (it.next().a()) {
                return true;
            }
        }
        return false;
    }

    private static boolean e(Class<?> cls) {
        if (Enum.class.isAssignableFrom(cls)) {
            return false;
        }
        return cls.isAnonymousClass() || cls.isLocalClass();
    }

    private static boolean a(Class<?> cls) {
        return cls.isMemberClass() && !d(cls);
    }

    private static boolean d(Class<?> cls) {
        return (cls.getModifiers() & 8) != 0;
    }

    private boolean b(ep epVar, es esVar) {
        return a(epVar) && a(esVar);
    }

    private boolean a(ep epVar) {
        return epVar == null || epVar.e() <= this.e;
    }

    private boolean a(es esVar) {
        return esVar == null || esVar.c() > this.e;
    }
}