package org.greenrobot.eventbus;

import android.os.Looper;
import android.util.Log;
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;

/* JADX INFO: compiled from: EventBus.java */
/* JADX INFO: loaded from: classes.dex */
public class c {

    /* JADX INFO: renamed from: a, reason: collision with root package name */
    public static String f3336a = "EventBus";

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    static volatile c f3337b;

    /* JADX INFO: renamed from: c, reason: collision with root package name */
    private static final d f3338c = new d();

    /* JADX INFO: renamed from: d, reason: collision with root package name */
    private static final Map<Class<?>, List<Class<?>>> f3339d = new HashMap();

    /* JADX INFO: renamed from: e, reason: collision with root package name */
    private final Map<Class<?>, CopyOnWriteArrayList<n>> f3340e;

    /* JADX INFO: renamed from: f, reason: collision with root package name */
    private final Map<Object, List<Class<?>>> f3341f;

    /* JADX INFO: renamed from: g, reason: collision with root package name */
    private final Map<Class<?>, Object> f3342g;
    private final ThreadLocal<C0099c> h;
    private final f i;
    private final org.greenrobot.eventbus.b j;
    private final org.greenrobot.eventbus.a k;
    private final m l;
    private final ExecutorService m;
    private final boolean n;
    private final boolean o;
    private final boolean p;
    private final boolean q;
    private final boolean r;
    private final boolean s;
    private final int t;

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

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

    /* JADX INFO: compiled from: EventBus.java */
    static /* synthetic */ class b {

        /* JADX INFO: renamed from: a, reason: collision with root package name */
        static final /* synthetic */ int[] f3344a;

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

    /* 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 C0099c {

        /* JADX INFO: renamed from: a, reason: collision with root package name */
        final List<Object> f3345a = new ArrayList();

        /* JADX INFO: renamed from: b, reason: collision with root package name */
        boolean f3346b;

        /* JADX INFO: renamed from: c, reason: collision with root package name */
        boolean f3347c;

        /* JADX INFO: renamed from: d, reason: collision with root package name */
        n f3348d;

        /* JADX INFO: renamed from: e, reason: collision with root package name */
        Object f3349e;

        /* JADX INFO: renamed from: f, reason: collision with root package name */
        boolean f3350f;

        C0099c() {
        }
    }

    public c() {
        this(f3338c);
    }

    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(n nVar, Object obj) {
        if (obj != null) {
            n(nVar, obj, Looper.getMainLooper() == Looper.myLooper());
        }
    }

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

    private void e(n nVar, Object obj, Throwable th) {
        if (!(obj instanceof k)) {
            if (this.n) {
                throw new e("Invoking subscriber failed", th);
            }
            if (this.o) {
                Log.e(f3336a, "Could not dispatch event: " + obj.getClass() + " to subscribing class " + nVar.f3392a.getClass(), th);
            }
            if (this.q) {
                j(new k(this, th, obj, nVar.f3392a));
                return;
            }
            return;
        }
        if (this.o) {
            Log.e(f3336a, "SubscriberExceptionEvent subscriber " + nVar.f3392a.getClass() + " threw an exception", th);
            k kVar = (k) obj;
            Log.e(f3336a, "Initial event " + kVar.f3372c + " caused exception in " + kVar.f3373d, kVar.f3371b);
        }
    }

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

    private void k(Object obj, C0099c c0099c) throws Error {
        boolean zL;
        Class<?> cls = obj.getClass();
        if (this.s) {
            List<Class<?>> listI = i(cls);
            int size = listI.size();
            zL = false;
            for (int i = 0; i < size; i++) {
                zL |= l(obj, c0099c, listI.get(i));
            }
        } else {
            zL = l(obj, c0099c, cls);
        }
        if (zL) {
            return;
        }
        if (this.p) {
            Log.d(f3336a, "No subscribers registered for event " + cls);
        }
        if (!this.r || cls == g.class || cls == k.class) {
            return;
        }
        j(new g(this, obj));
    }

    private boolean l(Object obj, C0099c c0099c, Class<?> cls) {
        CopyOnWriteArrayList<n> copyOnWriteArrayList;
        synchronized (this) {
            copyOnWriteArrayList = this.f3340e.get(cls);
        }
        if (copyOnWriteArrayList == null || copyOnWriteArrayList.isEmpty()) {
            return false;
        }
        for (n nVar : copyOnWriteArrayList) {
            c0099c.f3349e = obj;
            c0099c.f3348d = nVar;
            try {
                n(nVar, obj, c0099c.f3347c);
                if (c0099c.f3350f) {
                    return true;
                }
            } finally {
                c0099c.f3349e = null;
                c0099c.f3348d = null;
                c0099c.f3350f = false;
            }
        }
        return true;
    }

    private void n(n nVar, Object obj, boolean z) {
        int i = b.f3344a[nVar.f3393b.f3375b.ordinal()];
        if (i == 1) {
            g(nVar, obj);
            return;
        }
        if (i == 2) {
            if (z) {
                g(nVar, obj);
                return;
            } else {
                this.i.a(nVar, obj);
                return;
            }
        }
        if (i == 3) {
            if (z) {
                this.j.a(nVar, obj);
                return;
            } else {
                g(nVar, obj);
                return;
            }
        }
        if (i == 4) {
            this.k.a(nVar, obj);
            return;
        }
        throw new IllegalStateException("Unknown thread mode: " + nVar.f3393b.f3375b);
    }

    private void p(Object obj, l lVar) {
        Class<?> cls = lVar.f3376c;
        n nVar = new n(obj, lVar);
        CopyOnWriteArrayList<n> copyOnWriteArrayList = this.f3340e.get(cls);
        if (copyOnWriteArrayList == null) {
            copyOnWriteArrayList = new CopyOnWriteArrayList<>();
            this.f3340e.put(cls, copyOnWriteArrayList);
        } else if (copyOnWriteArrayList.contains(nVar)) {
            throw new e("Subscriber " + obj.getClass() + " already registered to event " + cls);
        }
        int size = copyOnWriteArrayList.size();
        for (int i = 0; i <= size; i++) {
            if (i == size || lVar.f3377d > copyOnWriteArrayList.get(i).f3393b.f3377d) {
                copyOnWriteArrayList.add(i, nVar);
                break;
            }
        }
        List<Class<?>> arrayList = this.f3341f.get(obj);
        if (arrayList == null) {
            arrayList = new ArrayList<>();
            this.f3341f.put(obj, arrayList);
        }
        arrayList.add(cls);
        if (lVar.f3378e) {
            if (!this.s) {
                b(nVar, this.f3342g.get(cls));
                return;
            }
            for (Map.Entry<Class<?>, Object> entry : this.f3342g.entrySet()) {
                if (cls.isAssignableFrom(entry.getKey())) {
                    b(nVar, entry.getValue());
                }
            }
        }
    }

    private void r(Object obj, Class<?> cls) {
        CopyOnWriteArrayList<n> copyOnWriteArrayList = this.f3340e.get(cls);
        if (copyOnWriteArrayList != null) {
            int size = copyOnWriteArrayList.size();
            int i = 0;
            while (i < size) {
                n nVar = copyOnWriteArrayList.get(i);
                if (nVar.f3392a == obj) {
                    nVar.f3394c = false;
                    copyOnWriteArrayList.remove(i);
                    i--;
                    size--;
                }
                i++;
            }
        }
    }

    ExecutorService d() {
        return this.m;
    }

    void f(h hVar) {
        Object obj = hVar.f3365b;
        n nVar = hVar.f3366c;
        h.b(hVar);
        if (nVar.f3394c) {
            g(nVar, obj);
        }
    }

    void g(n nVar, Object obj) {
        try {
            nVar.f3393b.f3374a.invoke(nVar.f3392a, obj);
        } catch (IllegalAccessException e2) {
            throw new IllegalStateException("Unexpected exception", e2);
        } catch (InvocationTargetException e3) {
            e(nVar, obj, e3.getCause());
        }
    }

    public synchronized boolean h(Object obj) {
        return this.f3341f.containsKey(obj);
    }

    public void j(Object obj) {
        C0099c c0099c = this.h.get();
        List<Object> list = c0099c.f3345a;
        list.add(obj);
        if (c0099c.f3346b) {
            return;
        }
        c0099c.f3347c = Looper.getMainLooper() == Looper.myLooper();
        c0099c.f3346b = true;
        if (c0099c.f3350f) {
            throw new e("Internal error. Abort state was not reset");
        }
        while (!list.isEmpty()) {
            try {
                k(list.remove(0), c0099c);
            } finally {
                c0099c.f3346b = false;
                c0099c.f3347c = false;
            }
        }
    }

    public void m(Object obj) {
        synchronized (this.f3342g) {
            this.f3342g.put(obj.getClass(), obj);
        }
        j(obj);
    }

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

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

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

    c(d dVar) {
        this.h = new a();
        this.f3340e = new HashMap();
        this.f3341f = new HashMap();
        this.f3342g = new ConcurrentHashMap();
        this.i = new f(this, Looper.getMainLooper(), 10);
        this.j = new org.greenrobot.eventbus.b(this);
        this.k = new org.greenrobot.eventbus.a(this);
        List<org.greenrobot.eventbus.o.b> list = dVar.k;
        this.t = list != null ? list.size() : 0;
        this.l = new m(dVar.k, dVar.i, dVar.h);
        this.o = dVar.f3352b;
        this.p = dVar.f3353c;
        this.q = dVar.f3354d;
        this.r = dVar.f3355e;
        this.n = dVar.f3356f;
        this.s = dVar.f3357g;
        this.m = dVar.j;
    }
}