package org.slf4j;
import java.io.IOException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.concurrent.LinkedBlockingQueue;
import org.slf4j.event.SubstituteLoggingEvent;
import org.slf4j.helpers.NOPLoggerFactory;
import org.slf4j.helpers.SubstituteLogger;
import org.slf4j.helpers.SubstituteLoggerFactory;
import org.slf4j.helpers.Util;
import org.slf4j.impl.StaticLoggerBinder;
public final class LoggerFactory {
private static final String[] API_COMPATIBILITY_LIST = {"1.6", "1.7"};
private static String STATIC_LOGGER_BINDER_PATH = "org/slf4j/impl/StaticLoggerBinder.class";
/* renamed from: a reason: collision with root package name */
static final String f8172a = "http://www.slf4j.org/codes.html";
static final String b = "http://www.slf4j.org/codes.html#StaticLoggerBinder";
static final String c = "http://www.slf4j.org/codes.html#multiple_bindings";
static final String d = "http://www.slf4j.org/codes.html#null_LF";
static final String e = "http://www.slf4j.org/codes.html#version_mismatch";
static final String f = "http://www.slf4j.org/codes.html#substituteLogger";
static final String g = "http://www.slf4j.org/codes.html#loggerNameMismatch";
static final String h = "http://www.slf4j.org/codes.html#replay";
static final String i = "http://www.slf4j.org/codes.html#unsuccessfulInit";
static final String j = "org.slf4j.LoggerFactory could not be successfully initialized. See also http://www.slf4j.org/codes.html#unsuccessfulInit";
static final int k = 0;
static final int l = 1;
static final int m = 2;
static final int n = 3;
static final int o = 4;
static volatile int p = 0;
static SubstituteLoggerFactory q = new SubstituteLoggerFactory();
static NOPLoggerFactory r = new NOPLoggerFactory();
static final String s = "slf4j.detectLoggerNameMismatch";
static final String t = "java.vendor.url";
static boolean u = Util.safeGetBooleanSystemProperty(s);
private LoggerFactory() {
}
static Set<URL> a() {
LinkedHashSet linkedHashSet = new LinkedHashSet();
try {
ClassLoader classLoader = LoggerFactory.class.getClassLoader();
Enumeration<URL> systemResources = classLoader == null ? ClassLoader.getSystemResources(STATIC_LOGGER_BINDER_PATH) : classLoader.getResources(STATIC_LOGGER_BINDER_PATH);
while (systemResources.hasMoreElements()) {
linkedHashSet.add(systemResources.nextElement());
}
} catch (IOException e2) {
Util.report("Error getting resources from path", e2);
}
return linkedHashSet;
}
static void a(Throwable th) {
p = 2;
Util.report("Failed to instantiate SLF4J LoggerFactory", th);
}
static void b() {
p = 0;
}
private static final void bind() {
Set<URL> set = null;
try {
if (!isAndroid()) {
set = a();
reportMultipleBindingAmbiguity(set);
}
StaticLoggerBinder.getSingleton();
p = 3;
reportActualBinding(set);
fixSubstituteLoggers();
replayEvents();
q.clear();
} catch (NoClassDefFoundError e2) {
if (messageContainsOrgSlf4jImplStaticLoggerBinder(e2.getMessage())) {
p = 4;
Util.report("Failed to load class \"org.slf4j.impl.StaticLoggerBinder\".");
Util.report("Defaulting to no-operation (NOP) logger implementation");
Util.report("See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details.");
return;
}
a(e2);
throw e2;
} catch (NoSuchMethodError e3) {
String message = e3.getMessage();
if (message != null && message.contains("org.slf4j.impl.StaticLoggerBinder.getSingleton()")) {
p = 2;
Util.report("slf4j-api 1.6.x (or later) is incompatible with this binding.");
Util.report("Your binding is version 1.5.5 or earlier.");
Util.report("Upgrade your binding to version 1.6.x.");
}
throw e3;
} catch (Exception e4) {
a(e4);
throw new IllegalStateException("Unexpected initialization failure", e4);
}
}
private static void emitReplayOrSubstituionWarning(SubstituteLoggingEvent substituteLoggingEvent, int i2) {
if (substituteLoggingEvent.getLogger().isDelegateEventAware()) {
emitReplayWarning(i2);
} else if (!substituteLoggingEvent.getLogger().isDelegateNOP()) {
emitSubstitutionWarning();
}
}
private static void emitReplayWarning(int i2) {
Util.report("A number (" + i2 + ") of logging calls during the initialization phase have been intercepted and are");
Util.report("now being replayed. These are subject to the filtering rules of the underlying logging system.");
Util.report("See also http://www.slf4j.org/codes.html#replay");
}
private static void emitSubstitutionWarning() {
Util.report("The following set of substitute loggers may have been accessed");
Util.report("during the initialization phase. Logging calls during this");
Util.report("phase were not honored. However, subsequent logging calls to these");
Util.report("loggers will work as normally expected.");
Util.report("See also http://www.slf4j.org/codes.html#substituteLogger");
}
private static void fixSubstituteLoggers() {
synchronized (q) {
q.postInitialization();
for (SubstituteLogger substituteLogger : q.getLoggers()) {
substituteLogger.setDelegate(getLogger(substituteLogger.getName()));
}
}
}
public static ILoggerFactory getILoggerFactory() {
if (p == 0) {
synchronized (LoggerFactory.class) {
if (p == 0) {
p = 1;
performInitialization();
}
}
}
int i2 = p;
if (i2 == 1) {
return q;
}
if (i2 == 2) {
throw new IllegalStateException(j);
} else if (i2 == 3) {
return StaticLoggerBinder.getSingleton().getLoggerFactory();
} else {
if (i2 == 4) {
return r;
}
throw new IllegalStateException("Unreachable code");
}
}
public static Logger getLogger(Class<?> cls) {
Class<?> callingClass;
Logger logger = getLogger(cls.getName());
if (u && (callingClass = Util.getCallingClass()) != null && nonMatchingClasses(cls, callingClass)) {
Util.report(String.format("Detected logger name mismatch. Given name: \"%s\"; computed name: \"%s\".", logger.getName(), callingClass.getName()));
Util.report("See http://www.slf4j.org/codes.html#loggerNameMismatch for an explanation");
}
return logger;
}
public static Logger getLogger(String str) {
return getILoggerFactory().getLogger(str);
}
private static boolean isAmbiguousStaticLoggerBinderPathSet(Set<URL> set) {
return set.size() > 1;
}
private static boolean isAndroid() {
String safeGetSystemProperty = Util.safeGetSystemProperty(t);
if (safeGetSystemProperty == null) {
return false;
}
return safeGetSystemProperty.toLowerCase().contains("android");
}
private static boolean messageContainsOrgSlf4jImplStaticLoggerBinder(String str) {
if (str == null) {
return false;
}
return str.contains("org/slf4j/impl/StaticLoggerBinder") || str.contains("org.slf4j.impl.StaticLoggerBinder");
}
private static boolean nonMatchingClasses(Class<?> cls, Class<?> cls2) {
return !cls2.isAssignableFrom(cls);
}
private static final void performInitialization() {
bind();
if (p == 3) {
versionSanityCheck();
}
}
private static void replayEvents() {
LinkedBlockingQueue<SubstituteLoggingEvent> eventQueue = q.getEventQueue();
int size = eventQueue.size();
ArrayList<SubstituteLoggingEvent> arrayList = new ArrayList(128);
int i2 = 0;
while (eventQueue.drainTo(arrayList, 128) != 0) {
for (SubstituteLoggingEvent substituteLoggingEvent : arrayList) {
replaySingleEvent(substituteLoggingEvent);
int i3 = i2 + 1;
if (i2 == 0) {
emitReplayOrSubstituionWarning(substituteLoggingEvent, size);
}
i2 = i3;
}
arrayList.clear();
}
}
private static void replaySingleEvent(SubstituteLoggingEvent substituteLoggingEvent) {
if (substituteLoggingEvent != null) {
SubstituteLogger logger = substituteLoggingEvent.getLogger();
String name = logger.getName();
if (logger.isDelegateNull()) {
throw new IllegalStateException("Delegate logger cannot be null at this state.");
} else if (!logger.isDelegateNOP()) {
if (logger.isDelegateEventAware()) {
logger.log(substituteLoggingEvent);
} else {
Util.report(name);
}
}
}
}
private static void reportActualBinding(Set<URL> set) {
if (set != null && isAmbiguousStaticLoggerBinderPathSet(set)) {
Util.report("Actual binding is of type [" + StaticLoggerBinder.getSingleton().getLoggerFactoryClassStr() + "]");
}
}
private static void reportMultipleBindingAmbiguity(Set<URL> set) {
if (isAmbiguousStaticLoggerBinderPathSet(set)) {
Util.report("Class path contains multiple SLF4J bindings.");
Iterator<URL> it2 = set.iterator();
while (it2.hasNext()) {
Util.report("Found binding in [" + it2.next() + "]");
}
Util.report("See http://www.slf4j.org/codes.html#multiple_bindings for an explanation.");
}
}
private static final void versionSanityCheck() {
try {
String str = StaticLoggerBinder.REQUESTED_API_VERSION;
boolean z = false;
for (String str2 : API_COMPATIBILITY_LIST) {
if (str.startsWith(str2)) {
z = true;
}
}
if (!z) {
Util.report("The requested version " + str + " by your slf4j binding is not compatible with " + Arrays.asList(API_COMPATIBILITY_LIST).toString());
Util.report("See http://www.slf4j.org/codes.html#version_mismatch for further details.");
}
} catch (NoSuchFieldError unused) {
} catch (Throwable th) {
Util.report("Unexpected problem occured during version sanity check", th);
}
}
}