package defpackage;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.concurrent.LinkedBlockingQueue;
import org.slf4j.ILoggerFactory;
import org.slf4j.impl.StaticLoggerBinder;

/* JADX INFO: renamed from: ᵙʥˀˉ, reason: contains not printable characters */
/* JADX INFO: loaded from: classes3.dex */
public abstract class AbstractC2626 {

    /* JADX INFO: renamed from: ʽˈˋ, reason: contains not printable characters */
    public static final C5172 f10218 = new C5172(7);

    /* JADX INFO: renamed from: ːˏᵟᵯ, reason: contains not printable characters */
    public static final ᵨᵡᵱ f10219 = new ᵨᵡᵱ(1);

    /* JADX INFO: renamed from: ᵨᵣ, reason: contains not printable characters */
    public static final String[] f10220;

    /* JADX INFO: renamed from: ᵲᵶᵳˈ, reason: contains not printable characters */
    public static volatile int f10221;

    /* JADX INFO: renamed from: ᵷᵺʾᵖ, reason: contains not printable characters */
    public static final boolean f10222;

    /* JADX INFO: renamed from: ᵻˈᵦʼ, reason: contains not printable characters */
    public static final String f10223;

    static {
        String property;
        try {
            property = System.getProperty("slf4j.detectLoggerNameMismatch");
        } catch (SecurityException unused) {
            property = null;
        }
        f10222 = property == null ? false : property.equalsIgnoreCase("true");
        f10220 = new String[]{"1.6", "1.7"};
        f10223 = "org/slf4j/impl/StaticLoggerBinder.class";
    }

    /* JADX INFO: renamed from: ʽˈˋ, reason: contains not printable characters */
    public static LinkedHashSet m6383() {
        LinkedHashSet linkedHashSet = new LinkedHashSet();
        try {
            ClassLoader classLoader = AbstractC2626.class.getClassLoader();
            String str = f10223;
            Enumeration<URL> systemResources = classLoader == null ? ClassLoader.getSystemResources(str) : classLoader.getResources(str);
            while (systemResources.hasMoreElements()) {
                linkedHashSet.add(systemResources.nextElement());
            }
            return linkedHashSet;
        } catch (IOException e) {
            System.err.println("Error getting resources from path");
            System.err.println("Reported exception:");
            e.printStackTrace();
            return linkedHashSet;
        }
    }

    /* JADX INFO: renamed from: ˊᵫᵗ, reason: contains not printable characters */
    public static void m6384() {
        LinkedBlockingQueue linkedBlockingQueue = (LinkedBlockingQueue) f10218.f19476;
        int size = linkedBlockingQueue.size();
        ArrayList arrayList = new ArrayList(128);
        int i = 0;
        while (linkedBlockingQueue.drainTo(arrayList, 128) != 0) {
            int size2 = arrayList.size();
            int i2 = 0;
            while (i2 < size2) {
                Object obj = arrayList.get(i2);
                i2++;
                C1491 c1491 = (C1491) obj;
                if (c1491 != null) {
                    C4552 c4552 = c1491.f6032;
                    String str = c4552.f17295;
                    if (c4552.f17297 == null) {
                        ᵕᵩʽᵲ.ᵪᵹᵥᵻ("Delegate logger cannot be null at this state.");
                        return;
                    } else if (!(c4552.f17297 instanceof C4454)) {
                        if (!c4552.m9639()) {
                            ᵷᵸˁ.ᵔᵖᵹᵫ(str);
                        } else if (c4552.m9639()) {
                            try {
                                c4552.f17298.invoke(c4552.f17297, c1491);
                            } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException unused) {
                            }
                        }
                    }
                }
                int i3 = i + 1;
                if (i == 0) {
                    if (c1491.f6032.m9639()) {
                        ᵷᵸˁ.ᵔᵖᵹᵫ("A number (" + size + ") of logging calls during the initialization phase have been intercepted and are");
                        ᵷᵸˁ.ᵔᵖᵹᵫ("now being replayed. These are subject to the filtering rules of the underlying logging system.");
                        ᵷᵸˁ.ᵔᵖᵹᵫ("See also http://www.slf4j.org/codes.html#replay");
                    } else if (!(c1491.f6032.f17297 instanceof C4454)) {
                        ᵷᵸˁ.ᵔᵖᵹᵫ("The following set of substitute loggers may have been accessed");
                        ᵷᵸˁ.ᵔᵖᵹᵫ("during the initialization phase. Logging calls during this");
                        ᵷᵸˁ.ᵔᵖᵹᵫ("phase were not honored. However, subsequent logging calls to these");
                        ᵷᵸˁ.ᵔᵖᵹᵫ("loggers will work as normally expected.");
                        ᵷᵸˁ.ᵔᵖᵹᵫ("See also http://www.slf4j.org/codes.html#substituteLogger");
                    }
                }
                i = i3;
            }
            arrayList.clear();
        }
    }

    /* JADX INFO: renamed from: ːˏᵟᵯ, reason: contains not printable characters */
    public static void m6385() {
        C5172 c5172 = f10218;
        synchronized (c5172) {
            try {
                c5172.f19475 = true;
                ArrayList arrayList = new ArrayList(((HashMap) c5172.f19474).values());
                int size = arrayList.size();
                int i = 0;
                while (i < size) {
                    Object obj = arrayList.get(i);
                    i++;
                    C4552 c4552 = (C4552) obj;
                    c4552.f17297 = m6393(c4552.f17295);
                }
            } catch (Throwable th) {
                throw th;
            }
        }
    }

    /* JADX INFO: renamed from: ᵨᵣ, reason: contains not printable characters */
    public static InterfaceC5025 m6386(Class cls) {
        int i;
        InterfaceC5025 interfaceC5025M6393 = m6393(cls.getName());
        if (f10222) {
            C3875 c3875 = ᵷᵸˁ.ᵲᵶᵳˈ;
            Class cls2 = null;
            if (c3875 == null) {
                if (ᵷᵸˁ.ʽˈˋ) {
                    c3875 = null;
                } else {
                    try {
                        c3875 = new C3875();
                    } catch (SecurityException unused) {
                        c3875 = null;
                    }
                    ᵷᵸˁ.ᵲᵶᵳˈ = c3875;
                    ᵷᵸˁ.ʽˈˋ = true;
                }
            }
            if (c3875 != null) {
                Class[] classContext = c3875.getClassContext();
                String name = ᵷᵸˁ.class.getName();
                int i2 = 0;
                while (i2 < classContext.length && !name.equals(classContext[i2].getName())) {
                    i2++;
                }
                if (i2 >= classContext.length || (i = i2 + 2) >= classContext.length) {
                    ᵕᵩʽᵲ.ᵪᵹᵥᵻ("Failed to find org.slf4j.helpers.Util or its caller in the stack; this should not happen");
                    return null;
                }
                cls2 = classContext[i];
            }
            if (cls2 != null && !cls2.isAssignableFrom(cls)) {
                ᵷᵸˁ.ᵔᵖᵹᵫ("Detected logger name mismatch. Given name: \"" + interfaceC5025M6393.getName() + "\"; computed name: \"" + cls2.getName() + "\".");
                ᵷᵸˁ.ᵔᵖᵹᵫ("See http://www.slf4j.org/codes.html#loggerNameMismatch for an explanation");
            }
        }
        return interfaceC5025M6393;
    }

    /* JADX INFO: renamed from: ᵱᵽʡᵚ, reason: contains not printable characters */
    public static void m6387(LinkedHashSet linkedHashSet) {
        if (linkedHashSet.size() > 1) {
            ᵷᵸˁ.ᵔᵖᵹᵫ("Class path contains multiple SLF4J bindings.");
            Iterator it = linkedHashSet.iterator();
            while (it.hasNext()) {
                ᵷᵸˁ.ᵔᵖᵹᵫ("Found binding in [" + ((URL) it.next()) + "]");
            }
            ᵷᵸˁ.ᵔᵖᵹᵫ("See http://www.slf4j.org/codes.html#multiple_bindings for an explanation.");
        }
    }

    /* JADX INFO: renamed from: ᵲᵶᵳˈ, reason: contains not printable characters */
    public static final void m6388() {
        LinkedHashSet linkedHashSetM6383;
        try {
            if (m6389()) {
                linkedHashSetM6383 = null;
            } else {
                linkedHashSetM6383 = m6383();
                m6387(linkedHashSetM6383);
            }
            StaticLoggerBinder.getSingleton();
            f10221 = 3;
            m6392(linkedHashSetM6383);
            m6385();
            m6384();
            C5172 c5172 = f10218;
            ((HashMap) c5172.f19474).clear();
            ((LinkedBlockingQueue) c5172.f19476).clear();
        } catch (Exception e) {
            f10221 = 2;
            System.err.println("Failed to instantiate SLF4J LoggerFactory");
            System.err.println("Reported exception:");
            e.printStackTrace();
            C4935.m10239("Unexpected initialization failure", e);
        } catch (NoClassDefFoundError e2) {
            String message = e2.getMessage();
            if (message == null || !(message.contains("org/slf4j/impl/StaticLoggerBinder") || message.contains("org.slf4j.impl.StaticLoggerBinder"))) {
                f10221 = 2;
                System.err.println("Failed to instantiate SLF4J LoggerFactory");
                System.err.println("Reported exception:");
                e2.printStackTrace();
                throw e2;
            }
            f10221 = 4;
            ᵷᵸˁ.ᵔᵖᵹᵫ("Failed to load class \"org.slf4j.impl.StaticLoggerBinder\".");
            ᵷᵸˁ.ᵔᵖᵹᵫ("Defaulting to no-operation (NOP) logger implementation");
            ᵷᵸˁ.ᵔᵖᵹᵫ("See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details.");
        } catch (NoSuchMethodError e3) {
            String message2 = e3.getMessage();
            if (message2 != null && message2.contains("org.slf4j.impl.StaticLoggerBinder.getSingleton()")) {
                f10221 = 2;
                ᵷᵸˁ.ᵔᵖᵹᵫ("slf4j-api 1.6.x (or later) is incompatible with this binding.");
                ᵷᵸˁ.ᵔᵖᵹᵫ("Your binding is version 1.5.5 or earlier.");
                ᵷᵸˁ.ᵔᵖᵹᵫ("Upgrade your binding to version 1.6.x.");
            }
            throw e3;
        }
    }

    /* JADX INFO: renamed from: ᵵᵽ, reason: contains not printable characters */
    public static boolean m6389() {
        String property;
        try {
            property = System.getProperty("java.vendor.url");
        } catch (SecurityException unused) {
            property = null;
        }
        if (property == null) {
            return false;
        }
        return property.toLowerCase().contains("android");
    }

    /* JADX INFO: renamed from: ᵶᵥᵝ, reason: contains not printable characters */
    public static final void m6390() {
        try {
            String str = StaticLoggerBinder.REQUESTED_API_VERSION;
            boolean z = false;
            for (String str2 : f10220) {
                if (str.startsWith(str2)) {
                    z = true;
                }
            }
            if (z) {
                return;
            }
            ᵷᵸˁ.ᵔᵖᵹᵫ("The requested version " + str + " by your slf4j binding is not compatible with " + Arrays.asList(f10220).toString());
            ᵷᵸˁ.ᵔᵖᵹᵫ("See http://www.slf4j.org/codes.html#version_mismatch for further details.");
        } catch (NoSuchFieldError unused) {
        } catch (Throwable th) {
            System.err.println("Unexpected problem occured during version sanity check");
            System.err.println("Reported exception:");
            th.printStackTrace();
        }
    }

    /* JADX INFO: renamed from: ᵷᵺʾᵖ, reason: contains not printable characters */
    public static ILoggerFactory m6391() {
        if (f10221 == 0) {
            synchronized (AbstractC2626.class) {
                try {
                    if (f10221 == 0) {
                        f10221 = 1;
                        m6388();
                        if (f10221 == 3) {
                            m6390();
                        }
                    }
                } finally {
                }
            }
        }
        int i = f10221;
        if (i == 1) {
            return f10218;
        }
        if (i == 2) {
            ᵕᵩʽᵲ.ᵪᵹᵥᵻ("org.slf4j.LoggerFactory in failed state. Original exception was thrown EARLIER. See also http://www.slf4j.org/codes.html#unsuccessfulInit");
            return null;
        }
        if (i == 3) {
            return StaticLoggerBinder.getSingleton().getLoggerFactory();
        }
        if (i == 4) {
            return f10219;
        }
        ᵕᵩʽᵲ.ᵪᵹᵥᵻ("Unreachable code");
        return null;
    }

    /* JADX INFO: renamed from: ᵻʽᵯ, reason: contains not printable characters */
    public static void m6392(LinkedHashSet linkedHashSet) {
        if (linkedHashSet == null || linkedHashSet.size() <= 1) {
            return;
        }
        ᵷᵸˁ.ᵔᵖᵹᵫ("Actual binding is of type [" + StaticLoggerBinder.getSingleton().getLoggerFactoryClassStr() + "]");
    }

    /* JADX INFO: renamed from: ᵻˈᵦʼ, reason: contains not printable characters */
    public static InterfaceC5025 m6393(String str) {
        return m6391().mo1015(str);
    }
}