package org.greenrobot.eventbus;

import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ExecutorService;
import java.util.logging.Level;

/* JADX INFO: compiled from: EventBus.java */
/* JADX INFO: loaded from: classes.dex */
public class c {
    static volatile c s;
    private static final d t = new d();
    private static final Map<Class<?>, List<Class<?>>> u = new HashMap();
    private final Map<Class<?>, CopyOnWriteArrayList<q>> a;
    private final Map<Object, List<Class<?>>> b;
    private final Map<Class<?>, Object> c;
    private final ThreadLocal<C0096c> d;
    private final h e;
    private final l f;

    /* JADX INFO: renamed from: g, reason: collision with root package name */
    private final org.greenrobot.eventbus.b f1097g;

    /* JADX INFO: renamed from: h, reason: collision with root package name */
    private final org.greenrobot.eventbus.a f1098h;

    /* JADX INFO: renamed from: i, reason: collision with root package name */
    private final p f1099i;

    /* JADX INFO: renamed from: j, reason: collision with root package name */
    private final ExecutorService f1100j;

    /* JADX INFO: renamed from: k, reason: collision with root package name */
    private final boolean f1101k;

    /* JADX INFO: renamed from: l, reason: collision with root package name */
    private final boolean f1102l;

    /* JADX INFO: renamed from: m, reason: collision with root package name */
    private final boolean f1103m;
    private final boolean n;
    private final boolean o;
    private final boolean p;
    private final int q;
    private final g r;

    /* JADX INFO: compiled from: EventBus.java */
    class a extends ThreadLocal<C0096c> {
        a(c cVar) {
        }

        /* JADX INFO: Access modifiers changed from: protected */
        @Override // java.lang.ThreadLocal
        /* JADX INFO: renamed from: a, reason: merged with bridge method [inline-methods] */
        public C0096c initialValue() {
            return new C0096c();
        }
    }

    /* JADX INFO: compiled from: EventBus.java */
    static /* synthetic */ class b {
        static final /* synthetic */ int[] a;

        static {
            int[] iArr = new int[ThreadMode.values().length];
            a = iArr;
            try {
                iArr[ThreadMode.POSTING.ordinal()] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                a[ThreadMode.MAIN.ordinal()] = 2;
            } catch (NoSuchFieldError unused2) {
            }
            try {
                a[ThreadMode.MAIN_ORDERED.ordinal()] = 3;
            } catch (NoSuchFieldError unused3) {
            }
            try {
                a[ThreadMode.BACKGROUND.ordinal()] = 4;
            } catch (NoSuchFieldError unused4) {
            }
            try {
                a[ThreadMode.ASYNC.ordinal()] = 5;
            } catch (NoSuchFieldError unused5) {
            }
        }
    }

    /* JADX INFO: renamed from: org.greenrobot.eventbus.c$c, reason: collision with other inner class name */
    /* JADX INFO: compiled from: EventBus.java */
    static final class C0096c {
        final List<Object> a = new ArrayList();
        boolean b;
        boolean c;
        q d;
        Object e;
        boolean f;

        C0096c() {
        }
    }

    public c() {
        this(t);
    }

    static void a(List<Class<?>> list, Class<?>[] clsArr) {
        for (Class<?> cls : clsArr) {
            if (!list.contains(cls)) {
                list.add(cls);
                a(list, cls.getInterfaces());
            }
        }
    }

    private void b(q qVar, Object obj) {
        if (obj != null) {
            p(qVar, obj, i());
        }
    }

    public static c c() {
        if (s == null) {
            synchronized (c.class) {
                if (s == null) {
                    s = new c();
                }
            }
        }
        return s;
    }

    private void f(q qVar, Object obj, Throwable th) {
        if (!(obj instanceof n)) {
            if (this.f1101k) {
                throw new e("Invoking subscriber failed", th);
            }
            if (this.f1102l) {
                this.r.b(Level.SEVERE, "Could not dispatch event: " + obj.getClass() + " to subscribing class " + qVar.a.getClass(), th);
            }
            if (this.n) {
                l(new n(this, th, obj, qVar.a));
                return;
            }
            return;
        }
        if (this.f1102l) {
            this.r.b(Level.SEVERE, "SubscriberExceptionEvent subscriber " + qVar.a.getClass() + " threw an exception", th);
            n nVar = (n) obj;
            this.r.b(Level.SEVERE, "Initial event " + nVar.b + " caused exception in " + nVar.c, nVar.a);
        }
    }

    private boolean i() {
        h hVar = this.e;
        if (hVar != null) {
            return hVar.b();
        }
        return true;
    }

    private static List<Class<?>> k(Class<?> cls) {
        List<Class<?>> arrayList;
        synchronized (u) {
            arrayList = u.get(cls);
            if (arrayList == null) {
                arrayList = new ArrayList<>();
                for (Class<?> superclass = cls; superclass != null; superclass = superclass.getSuperclass()) {
                    arrayList.add(superclass);
                    a(arrayList, superclass.getInterfaces());
                }
                u.put(cls, arrayList);
            }
        }
        return arrayList;
    }

    private void m(Object obj, C0096c c0096c) throws Error {
        boolean zN;
        Class<?> cls = obj.getClass();
        if (this.p) {
            List<Class<?>> listK = k(cls);
            int size = listK.size();
            zN = false;
            for (int i2 = 0; i2 < size; i2++) {
                zN |= n(obj, c0096c, listK.get(i2));
            }
        } else {
            zN = n(obj, c0096c, cls);
        }
        if (zN) {
            return;
        }
        if (this.f1103m) {
            this.r.a(Level.FINE, "No subscribers registered for event " + cls);
        }
        if (!this.o || cls == i.class || cls == n.class) {
            return;
        }
        l(new i(this, obj));
    }

    private boolean n(Object obj, C0096c c0096c, Class<?> cls) {
        CopyOnWriteArrayList<q> copyOnWriteArrayList;
        synchronized (this) {
            copyOnWriteArrayList = this.a.get(cls);
        }
        if (copyOnWriteArrayList == null || copyOnWriteArrayList.isEmpty()) {
            return false;
        }
        for (q qVar : copyOnWriteArrayList) {
            c0096c.e = obj;
            c0096c.d = qVar;
            try {
                p(qVar, obj, c0096c.c);
                if (c0096c.f) {
                    return true;
                }
            } finally {
                c0096c.e = null;
                c0096c.d = null;
                c0096c.f = false;
            }
        }
        return true;
    }

    private void p(q qVar, Object obj, boolean z) {
        int i2 = b.a[qVar.b.b.ordinal()];
        if (i2 == 1) {
            h(qVar, obj);
            return;
        }
        if (i2 == 2) {
            if (z) {
                h(qVar, obj);
                return;
            } else {
                this.f.a(qVar, obj);
                return;
            }
        }
        if (i2 == 3) {
            l lVar = this.f;
            if (lVar != null) {
                lVar.a(qVar, obj);
                return;
            } else {
                h(qVar, obj);
                return;
            }
        }
        if (i2 == 4) {
            if (z) {
                this.f1097g.a(qVar, obj);
                return;
            } else {
                h(qVar, obj);
                return;
            }
        }
        if (i2 == 5) {
            this.f1098h.a(qVar, obj);
            return;
        }
        throw new IllegalStateException("Unknown thread mode: " + qVar.b.b);
    }

    private void r(Object obj, o oVar) {
        Class<?> cls = oVar.c;
        q qVar = new q(obj, oVar);
        CopyOnWriteArrayList<q> copyOnWriteArrayList = this.a.get(cls);
        if (copyOnWriteArrayList == null) {
            copyOnWriteArrayList = new CopyOnWriteArrayList<>();
            this.a.put(cls, copyOnWriteArrayList);
        } else if (copyOnWriteArrayList.contains(qVar)) {
            throw new e("Subscriber " + obj.getClass() + " already registered to event " + cls);
        }
        int size = copyOnWriteArrayList.size();
        for (int i2 = 0; i2 <= size; i2++) {
            if (i2 == size || oVar.d > copyOnWriteArrayList.get(i2).b.d) {
                copyOnWriteArrayList.add(i2, qVar);
                break;
            }
        }
        List<Class<?>> arrayList = this.b.get(obj);
        if (arrayList == null) {
            arrayList = new ArrayList<>();
            this.b.put(obj, arrayList);
        }
        arrayList.add(cls);
        if (oVar.e) {
            if (!this.p) {
                b(qVar, this.c.get(cls));
                return;
            }
            for (Map.Entry<Class<?>, Object> entry : this.c.entrySet()) {
                if (cls.isAssignableFrom(entry.getKey())) {
                    b(qVar, entry.getValue());
                }
            }
        }
    }

    private void t(Object obj, Class<?> cls) {
        CopyOnWriteArrayList<q> copyOnWriteArrayList = this.a.get(cls);
        if (copyOnWriteArrayList != null) {
            int size = copyOnWriteArrayList.size();
            int i2 = 0;
            while (i2 < size) {
                q qVar = copyOnWriteArrayList.get(i2);
                if (qVar.a == obj) {
                    qVar.c = false;
                    copyOnWriteArrayList.remove(i2);
                    i2--;
                    size--;
                }
                i2++;
            }
        }
    }

    ExecutorService d() {
        return this.f1100j;
    }

    public g e() {
        return this.r;
    }

    void g(j jVar) {
        Object obj = jVar.a;
        q qVar = jVar.b;
        j.b(jVar);
        if (qVar.c) {
            h(qVar, obj);
        }
    }

    void h(q qVar, Object obj) {
        try {
            qVar.b.a.invoke(qVar.a, obj);
        } catch (IllegalAccessException e) {
            throw new IllegalStateException("Unexpected exception", e);
        } catch (InvocationTargetException e2) {
            f(qVar, obj, e2.getCause());
        }
    }

    public synchronized boolean j(Object obj) {
        return this.b.containsKey(obj);
    }

    public void l(Object obj) {
        C0096c c0096c = this.d.get();
        List<Object> list = c0096c.a;
        list.add(obj);
        if (c0096c.b) {
            return;
        }
        c0096c.c = i();
        c0096c.b = true;
        if (c0096c.f) {
            throw new e("Internal error. Abort state was not reset");
        }
        while (true) {
            try {
                if (list.isEmpty()) {
                    return;
                } else {
                    m(list.remove(0), c0096c);
                }
            } finally {
                c0096c.b = false;
                c0096c.c = false;
            }
        }
    }

    public void o(Object obj) {
        synchronized (this.c) {
            this.c.put(obj.getClass(), obj);
        }
        l(obj);
    }

    public void q(Object obj) {
        List<o> listA = this.f1099i.a(obj.getClass());
        synchronized (this) {
            Iterator<o> it = listA.iterator();
            while (it.hasNext()) {
                r(obj, it.next());
            }
        }
    }

    public synchronized void s(Object obj) {
        List<Class<?>> list = this.b.get(obj);
        if (list != null) {
            Iterator<Class<?>> it = list.iterator();
            while (it.hasNext()) {
                t(obj, it.next());
            }
            this.b.remove(obj);
        } else {
            this.r.a(Level.WARNING, "Subscriber to unregister was not registered before: " + obj.getClass());
        }
    }

    public String toString() {
        return "EventBus[indexCount=" + this.q + ", eventInheritance=" + this.p + "]";
    }

    c(d dVar) {
        this.d = new a(this);
        this.r = dVar.b();
        this.a = new HashMap();
        this.b = new HashMap();
        this.c = new ConcurrentHashMap();
        h hVarC = dVar.c();
        this.e = hVarC;
        this.f = hVarC != null ? hVarC.a(this) : null;
        this.f1097g = new org.greenrobot.eventbus.b(this);
        this.f1098h = new org.greenrobot.eventbus.a(this);
        List<org.greenrobot.eventbus.r.b> list = dVar.f1108j;
        this.q = list != null ? list.size() : 0;
        this.f1099i = new p(dVar.f1108j, dVar.f1106h, dVar.f1105g);
        this.f1102l = dVar.a;
        this.f1103m = dVar.b;
        this.n = dVar.c;
        this.o = dVar.d;
        this.f1101k = dVar.e;
        this.p = dVar.f;
        this.f1100j = dVar.f1107i;
    }
}