discord-jadx/app/src/main/java/lombok/core/configuration/FileSystemSourceCache.java

package lombok.core.configuration;

import java.io.File;
import java.net.URI;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.TimeUnit;
import lombok.core.debug.ProblemReporter;
/* loaded from: com.discord-118106.apk:lombok/core/configuration/FileSystemSourceCache.SCL.lombok */
public class FileSystemSourceCache {
    private static final long FULL_CACHE_CLEAR_INTERVAL = TimeUnit.MINUTES.toMillis(30);
    private static final long RECHECK_FILESYSTEM = TimeUnit.SECONDS.toMillis(2);
    private static final long NEVER_CHECKED = -1;
    static final long MISSING = -88;
    private final ConcurrentMap<ConfigurationFile, Content> fileCache = new ConcurrentHashMap();
    private final ConcurrentMap<URI, ConfigurationFile> uriCache = new ConcurrentHashMap();
    private volatile long lastCacheClear = System.currentTimeMillis();

    /* renamed from: lombok.core.configuration.FileSystemSourceCache$1  reason: invalid class name */
    /* loaded from: com.discord-118106.apk:lombok/core/configuration/FileSystemSourceCache$1.SCL.lombok */
    class AnonymousClass1 implements ConfigurationFileToSource {
        private final /* synthetic */ ConfigurationParser val$parser;

        AnonymousClass1(ConfigurationParser configurationParser) {
            this.val$parser = configurationParser;
        }

        @Override // lombok.core.configuration.ConfigurationFileToSource
        public ConfigurationSource parsed(ConfigurationFile configurationFile) {
            return FileSystemSourceCache.access$0(FileSystemSourceCache.this, configurationFile, this.val$parser);
        }
    }

    /* loaded from: com.discord-118106.apk:lombok/core/configuration/FileSystemSourceCache$Content.SCL.lombok */
    private static class Content {
        ConfigurationSource source;
        long lastModified;
        long lastChecked;

        private Content(ConfigurationSource configurationSource, long j, long j2) {
            this.source = configurationSource;
            this.lastModified = j;
            this.lastChecked = j2;
        }

        static Content empty() {
            return new Content(null, FileSystemSourceCache.MISSING, -1L);
        }
    }

    private void cacheClear() {
        long currentTimeMillis = System.currentTimeMillis();
        if (currentTimeMillis - this.lastCacheClear > FULL_CACHE_CLEAR_INTERVAL) {
            this.lastCacheClear = currentTimeMillis;
            this.fileCache.clear();
            this.uriCache.clear();
        }
    }

    public ConfigurationFileToSource fileToSource(ConfigurationParser configurationParser) {
        return new AnonymousClass1(configurationParser);
    }

    public ConfigurationFile forUri(URI uri) {
        if (uri == null) {
            return null;
        }
        cacheClear();
        ConfigurationFile configurationFile = this.uriCache.get(uri);
        if (configurationFile == null) {
            URI normalize = uri.normalize();
            if (!normalize.isAbsolute()) {
                normalize = URI.create("file:" + normalize.toString());
            }
            try {
                File file = new File(normalize);
                if (!file.exists()) {
                    throw new IllegalArgumentException("File does not exist: " + normalize);
                }
                File parentFile = file.isDirectory() ? file : file.getParentFile();
                if (parentFile != null) {
                    configurationFile = ConfigurationFile.forDirectory(parentFile);
                }
                this.uriCache.put(uri, configurationFile);
            } catch (IllegalArgumentException unused) {
            } catch (Exception e) {
                ProblemReporter.error("Can't find absolute path of file being compiled: " + uri, e);
            }
        }
        return configurationFile;
    }

    /* JADX WARN: Unknown variable types count: 1 */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    private ConfigurationSource parseIfNeccesary(ConfigurationFile configurationFile, ConfigurationParser configurationParser) {
        long currentTimeMillis = System.currentTimeMillis();
        ?? ensureContent = ensureContent(configurationFile);
        synchronized (ensureContent) {
            if (ensureContent.lastChecked == -1 || currentTimeMillis - ensureContent.lastChecked >= RECHECK_FILESYSTEM) {
                ensureContent.lastChecked = currentTimeMillis;
                long j = ensureContent.lastModified;
                ensureContent.lastModified = configurationFile.getLastModifiedOrMissing();
                if (ensureContent.lastModified != j) {
                    ensureContent.source = ensureContent.lastModified == MISSING ? null : SingleConfigurationSource.parse(configurationFile, configurationParser);
                }
                return ensureContent.source;
            }
            return ensureContent.source;
        }
    }

    private Content ensureContent(ConfigurationFile configurationFile) {
        Content content = this.fileCache.get(configurationFile);
        if (content != null) {
            return content;
        }
        this.fileCache.putIfAbsent(configurationFile, Content.empty());
        return this.fileCache.get(configurationFile);
    }

    static /* synthetic */ ConfigurationSource access$0(FileSystemSourceCache fileSystemSourceCache, ConfigurationFile configurationFile, ConfigurationParser configurationParser) {
        return fileSystemSourceCache.parseIfNeccesary(configurationFile, configurationParser);
    }
}