package lombok.core.configuration;

import com.zwitserloot.cmdreader.CmdReader;
import com.zwitserloot.cmdreader.Description;
import com.zwitserloot.cmdreader.Excludes;
import com.zwitserloot.cmdreader.FullName;
import com.zwitserloot.cmdreader.InvalidCommandLineException;
import com.zwitserloot.cmdreader.Mandatory;
import com.zwitserloot.cmdreader.Requires;
import com.zwitserloot.cmdreader.Sequential;
import com.zwitserloot.cmdreader.Shorthand;
import java.io.File;
import java.io.IOException;
import java.io.PrintStream;
import java.net.URI;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import lombok.ConfigurationKeys;
import lombok.core.LombokApp;
import lombok.core.configuration.ConfigurationKeysLoader;
import lombok.core.configuration.ConfigurationParser;
/* loaded from: com.discord-121111.apk:lombok/core/configuration/ConfigurationApp.SCL.lombok */
public class ConfigurationApp extends LombokApp {
    private PrintStream out = System.out;
    private PrintStream err = System.err;
    private static final URI NO_CONFIG = URI.create("");
    private static final ConfigurationProblemReporter VOID = new AnonymousClass1();

    /* renamed from: lombok.core.configuration.ConfigurationApp$1  reason: invalid class name */
    /* loaded from: com.discord-121111.apk:lombok/core/configuration/ConfigurationApp$1.SCL.lombok */
    class AnonymousClass1 implements ConfigurationProblemReporter {
        AnonymousClass1() {
        }

        @Override // lombok.core.configuration.ConfigurationProblemReporter
        public void report(String str, String str2, int i, CharSequence charSequence) {
        }
    }

    /* renamed from: lombok.core.configuration.ConfigurationApp$2  reason: invalid class name */
    /* loaded from: com.discord-121111.apk:lombok/core/configuration/ConfigurationApp$2.SCL.lombok */
    class AnonymousClass2 implements ConfigurationProblemReporter {
        private final /* synthetic */ List val$problems;

        AnonymousClass2(List list) {
            this.val$problems = list;
        }

        @Override // lombok.core.configuration.ConfigurationProblemReporter
        public void report(String str, String str2, int i, CharSequence charSequence) {
            this.val$problems.add(String.format("%s: %s (%s:%d)", str2, charSequence, str, Integer.valueOf(i)));
        }
    }

    /* renamed from: lombok.core.configuration.ConfigurationApp$3  reason: invalid class name */
    /* loaded from: com.discord-121111.apk:lombok/core/configuration/ConfigurationApp$3.SCL.lombok */
    class AnonymousClass3 implements ConfigurationParser.Collector {
        private final /* synthetic */ Deque val$round;
        private final /* synthetic */ Collection val$keys;
        private final /* synthetic */ Map val$result;

        AnonymousClass3(Deque deque, Collection collection, Map map) {
            this.val$round = deque;
            this.val$keys = collection;
            this.val$result = map;
        }

        @Override // lombok.core.configuration.ConfigurationParser.Collector
        public void addImport(ConfigurationFile configurationFile, ConfigurationFile configurationFile2, int i) {
            this.val$round.push(new Source(configurationFile, String.valueOf(configurationFile.description()) + " (imported from " + configurationFile2.description() + ":" + i + ")"));
        }

        @Override // lombok.core.configuration.ConfigurationParser.Collector
        public void clear(ConfigurationKey<?> configurationKey, ConfigurationFile configurationFile, int i) {
            trace(configurationKey, "clear " + configurationKey.getKeyName(), i);
        }

        @Override // lombok.core.configuration.ConfigurationParser.Collector
        public void set(ConfigurationKey<?> configurationKey, Object obj, ConfigurationFile configurationFile, int i) {
            trace(configurationKey, String.valueOf(configurationKey.getKeyName()) + " = " + obj, i);
        }

        @Override // lombok.core.configuration.ConfigurationParser.Collector
        public void add(ConfigurationKey<?> configurationKey, Object obj, ConfigurationFile configurationFile, int i) {
            trace(configurationKey, String.valueOf(configurationKey.getKeyName()) + " += " + obj, i);
        }

        @Override // lombok.core.configuration.ConfigurationParser.Collector
        public void remove(ConfigurationKey<?> configurationKey, Object obj, ConfigurationFile configurationFile, int i) {
            trace(configurationKey, String.valueOf(configurationKey.getKeyName()) + " -= " + obj, i);
        }

        private void trace(ConfigurationKey<?> configurationKey, String str, int i) {
            if (this.val$keys.contains(configurationKey) || configurationKey == ConfigurationKeys.STOP_BUBBLING) {
                List list = (List) this.val$result.get(configurationKey);
                if (list == null) {
                    list = new ArrayList();
                    this.val$result.put(configurationKey, list);
                }
                list.add(String.format("%4d: %s", Integer.valueOf(i), str));
            }
        }
    }

    /* renamed from: lombok.core.configuration.ConfigurationApp$4  reason: invalid class name */
    /* loaded from: com.discord-121111.apk:lombok/core/configuration/ConfigurationApp$4.SCL.lombok */
    class AnonymousClass4 implements Comparator<URI> {
        AnonymousClass4() {
        }

        public int compare(URI uri, URI uri2) {
            return uri.toString().compareTo(uri2.toString());
        }
    }

    /* loaded from: com.discord-121111.apk:lombok/core/configuration/ConfigurationApp$CmdArgs.SCL.lombok */
    public static class CmdArgs {
        @Mandatory(onlyIfNot = {"help", "generate"})
        @Description("Paths to java files or directories the configuration is to be printed for.")
        @Sequential
        private List<String> paths = new ArrayList();
        @Excludes({"paths"})
        @Description("Generates a list containing all the available configuration parameters. Add --verbose to print more information.")
        @Shorthand({"g"})
        boolean generate = false;
        @Description("Displays more information.")
        @Shorthand({"v"})
        boolean verbose = false;
        @Requires({"verbose"})
        @Description("Also display files that don't mention the key.")
        @Shorthand({"n"})
        @FullName("not-mentioned")
        boolean notMentioned = false;
        @Description("Limit the result to these keys.")
        @Shorthand({"k"})
        private List<String> key = new ArrayList();
        @Description("Shows this help text.")
        @Shorthand({"h", "?"})
        boolean help = false;

        static /* synthetic */ List access$0(CmdArgs cmdArgs) {
            return cmdArgs.key;
        }

        static /* synthetic */ List access$1(CmdArgs cmdArgs) {
            return cmdArgs.paths;
        }
    }

    /* loaded from: com.discord-121111.apk:lombok/core/configuration/ConfigurationApp$Source.SCL.lombok */
    private static final class Source {
        final ConfigurationFile file;
        final String description;

        Source(ConfigurationFile configurationFile, String str) {
            this.file = configurationFile;
            this.description = str;
        }
    }

    @Override // lombok.core.LombokApp
    public String getAppName() {
        return "config";
    }

    @Override // lombok.core.LombokApp
    public String getAppDescription() {
        return "Prints the configurations for the provided paths to standard out.";
    }

    @Override // lombok.core.LombokApp
    public List<String> getAppAliases() {
        return Arrays.asList("configuration", "config", "conf", "settings");
    }

    @Override // lombok.core.LombokApp
    public int runApp(List<String> list) throws Exception {
        CmdReader of = CmdReader.of(CmdArgs.class);
        try {
            CmdArgs cmdArgs = (CmdArgs) of.make((String[]) list.toArray(new String[0]));
            if (cmdArgs.help) {
                this.out.println(of.generateCommandLineHelp("java -jar lombok.jar configuration"));
                return 0;
            }
            ConfigurationKeysLoader.LoaderLoader.loadAllConfigurationKeys();
            Collection<ConfigurationKey<?>> checkKeys = checkKeys(CmdArgs.access$0(cmdArgs));
            if (checkKeys == null) {
                return 1;
            }
            boolean z2 = cmdArgs.verbose;
            if (cmdArgs.generate) {
                return generate(checkKeys, z2, !CmdArgs.access$0(cmdArgs).isEmpty());
            }
            return display(checkKeys, z2, CmdArgs.access$1(cmdArgs), !CmdArgs.access$0(cmdArgs).isEmpty(), cmdArgs.notMentioned);
        } catch (InvalidCommandLineException e) {
            this.err.println(e.getMessage());
            this.err.println(of.generateCommandLineHelp("java -jar lombok.jar configuration"));
            return 1;
        }
    }

    public ConfigurationApp redirectOutput(PrintStream printStream, PrintStream printStream2) {
        if (printStream != null) {
            this.out = printStream;
        }
        if (printStream2 != null) {
            this.err = printStream2;
        }
        return this;
    }

    public int generate(Collection<ConfigurationKey<?>> collection, boolean z2, boolean z3) {
        Iterator<ConfigurationKey<?>> it = collection.iterator();
        while (it.hasNext()) {
            ConfigurationKey<?> next = it.next();
            if (z3 || !next.isHidden()) {
                String keyName = next.getKeyName();
                ConfigurationDataType type = next.getType();
                String description = next.getDescription();
                boolean z4 = description != null && !description.isEmpty();
                if (!z2) {
                    this.out.println(keyName);
                    if (z4) {
                        this.out.print("  ");
                        this.out.println(description);
                    }
                    this.out.println();
                } else {
                    this.out.printf("##%n## Key : %s%n## Type: %s%n", keyName, type);
                    if (z4) {
                        this.out.printf("##%n## %s%n", description);
                    }
                    this.out.printf("##%n## Examples:%n#%n", new Object[0]);
                    this.out.printf("# clear %s%n", keyName);
                    String exampleValue = type.getParser().exampleValue();
                    if (type.isList()) {
                        this.out.printf("# %s += %s%n", keyName, exampleValue);
                        this.out.printf("# %s -= %s%n", keyName, exampleValue);
                    } else {
                        this.out.printf("# %s = %s%n", keyName, exampleValue);
                    }
                    this.out.printf("#%n%n", new Object[0]);
                }
            }
        }
        if (z2) {
            return 0;
        }
        this.out.println("Use --verbose for more information.");
        return 0;
    }

    public int display(Collection<ConfigurationKey<?>> collection, boolean z2, Collection<String> collection2, boolean z3, boolean z4) throws Exception {
        TreeMap<URI, Set<String>> findSharedDirectories = findSharedDirectories(collection2);
        if (findSharedDirectories == null) {
            return 1;
        }
        Set<String> remove = findSharedDirectories.remove(NO_CONFIG);
        if (remove != null) {
            if (remove.size() == 1) {
                this.out.printf("No 'lombok.config' found for '%s'.%n", remove.iterator().next());
            } else {
                this.out.println("No 'lombok.config' found for: ");
                Iterator<String> it = remove.iterator();
                while (it.hasNext()) {
                    this.out.printf("- %s%n", it.next());
                }
            }
        }
        ArrayList arrayList = new ArrayList();
        AnonymousClass2 r0 = new AnonymousClass2(arrayList);
        FileSystemSourceCache fileSystemSourceCache = new FileSystemSourceCache();
        ConfigurationParser configurationParser = new ConfigurationParser(r0);
        boolean z5 = true;
        Iterator<Map.Entry<URI, Set<String>>> it2 = findSharedDirectories.entrySet().iterator();
        while (it2.hasNext()) {
            Map.Entry<URI, Set<String>> next = it2.next();
            if (!z5) {
                this.out.printf("%n%n", new Object[0]);
            }
            Set<String> value = next.getValue();
            if (value.size() != 1) {
                this.out.printf("Configuration for:%n", new Object[0]);
                Iterator<String> it3 = value.iterator();
                while (it3.hasNext()) {
                    this.out.printf("- %s%n", it3.next());
                }
                this.out.println();
            } else if (collection2.size() != 1) {
                this.out.printf("Configuration for '%s'.%n%n", value.iterator().next());
            }
            URI key = next.getKey();
            BubblingConfigurationResolver bubblingConfigurationResolver = new BubblingConfigurationResolver(fileSystemSourceCache.forUri(key), fileSystemSourceCache.fileToSource(configurationParser));
            Map<ConfigurationKey<?>, ? extends Collection<String>> trace = trace(collection, key, z4);
            boolean z6 = false;
            Iterator<ConfigurationKey<?>> it4 = collection.iterator();
            while (it4.hasNext()) {
                ConfigurationKey<?> next2 = it4.next();
                Object resolve = bubblingConfigurationResolver.resolve(next2);
                Collection<String> collection3 = (Collection) trace.get(next2);
                if (!collection3.isEmpty() || z3) {
                    if (z6 && z2) {
                        this.out.println();
                    }
                    printValue(next2, resolve, z2, collection3);
                    z6 = true;
                }
            }
            if (!z6) {
                this.out.println("<default>");
            }
            z5 = false;
        }
        if (arrayList.isEmpty()) {
            return 0;
        }
        this.err.printf("Problems in the configuration files:%n", new Object[0]);
        Iterator it5 = arrayList.iterator();
        while (it5.hasNext()) {
            this.err.printf("- %s%n", (String) it5.next());
        }
        return 0;
    }

    private void printValue(ConfigurationKey<?> configurationKey, Object obj, boolean z2, Collection<String> collection) {
        if (z2) {
            this.out.printf("# %s%n", configurationKey.getDescription());
        }
        if (obj == null) {
            this.out.printf("clear %s%n", configurationKey.getKeyName());
        } else if (obj instanceof List) {
            List list = (List) obj;
            if (list.isEmpty()) {
                this.out.printf("clear %s%n", configurationKey.getKeyName());
            }
            Iterator it = list.iterator();
            while (it.hasNext()) {
                this.out.printf("%s += %s%n", configurationKey.getKeyName(), it.next());
            }
        } else {
            this.out.printf("%s = %s%n", configurationKey.getKeyName(), obj);
        }
        if (z2) {
            Iterator<String> it2 = collection.iterator();
            while (it2.hasNext()) {
                this.out.printf("# %s%n", it2.next());
            }
        }
    }

    private Map<ConfigurationKey<?>, ? extends Collection<String>> trace(Collection<ConfigurationKey<?>> collection, URI uri, boolean z2) throws Exception {
        HashMap hashMap = new HashMap();
        Iterator<ConfigurationKey<?>> it = collection.iterator();
        while (it.hasNext()) {
            hashMap.put(it.next(), new ArrayList());
        }
        HashSet hashSet = new HashSet();
        boolean z3 = false;
        HashSet hashSet2 = new HashSet();
        for (ConfigurationFile forDirectory = ConfigurationFile.forDirectory(new File(uri)); forDirectory != null && !z3; forDirectory = forDirectory.parent()) {
            if (forDirectory.exists()) {
                ArrayDeque arrayDeque = new ArrayDeque();
                arrayDeque.push(new Source(forDirectory, forDirectory.description()));
                while (!arrayDeque.isEmpty()) {
                    Source pop = arrayDeque.pop();
                    if (pop != null && hashSet2.add(pop.file) && pop.file.exists()) {
                        Map<ConfigurationKey<?>, List<String>> trace = trace(pop.file, collection, arrayDeque);
                        z3 = stopBubbling(trace.get(ConfigurationKeys.STOP_BUBBLING));
                        Iterator<ConfigurationKey<?>> it2 = collection.iterator();
                        while (it2.hasNext()) {
                            ConfigurationKey<?> next = it2.next();
                            List<String> list = trace.get(next);
                            if (list == null) {
                                list = new ArrayList<>();
                                if (z2) {
                                    list.add("");
                                    list.add(String.valueOf(pop.description) + ":");
                                    list.add("     <'" + next.getKeyName() + "' not mentioned>");
                                }
                            } else {
                                hashSet.add(next);
                                list.add(0, String.valueOf(pop.description) + ":");
                                list.add(0, "");
                            }
                            ((List) hashMap.get(next)).addAll(0, list);
                        }
                    }
                }
            }
        }
        Iterator<ConfigurationKey<?>> it3 = collection.iterator();
        while (it3.hasNext()) {
            ConfigurationKey<?> next2 = it3.next();
            if (hashSet.contains(next2)) {
                List list2 = (List) hashMap.get(next2);
                list2.remove(0);
                if (z3) {
                    String str = (String) list2.get(0);
                    list2.set(0, String.valueOf(str.substring(0, str.length() - 1)) + " (stopped bubbling):");
                }
            } else {
                hashMap.put(next2, Collections.emptyList());
            }
        }
        return hashMap;
    }

    private Map<ConfigurationKey<?>, List<String>> trace(ConfigurationFile configurationFile, Collection<ConfigurationKey<?>> collection, Deque<Source> deque) throws IOException {
        HashMap hashMap = new HashMap();
        new ConfigurationParser(VOID).parse(configurationFile, new AnonymousClass3(deque, collection, hashMap));
        return hashMap;
    }

    private boolean stopBubbling(List<String> list) {
        return list != null && !list.isEmpty() && list.get(list.size() - 1).endsWith("true");
    }

    private Collection<ConfigurationKey<?>> checkKeys(List<String> list) {
        Map<String, ConfigurationKey<?>> registeredKeys = ConfigurationKey.registeredKeys();
        if (list.isEmpty()) {
            return registeredKeys.values();
        }
        ArrayList arrayList = new ArrayList();
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            String next = it.next();
            ConfigurationKey<?> configurationKey = registeredKeys.get(next);
            if (configurationKey == null) {
                this.err.printf("Unknown key '%s'%n", next);
                return null;
            }
            arrayList.remove(configurationKey);
            arrayList.add(configurationKey);
        }
        return arrayList;
    }

    private TreeMap<URI, Set<String>> findSharedDirectories(Collection<String> collection) {
        TreeMap<URI, Set<String>> treeMap = new TreeMap<>(new AnonymousClass4());
        Iterator<String> it = collection.iterator();
        while (it.hasNext()) {
            String next = it.next();
            File file = new File(next);
            if (!file.exists()) {
                this.err.printf("File not found: '%s'%n", next);
                return null;
            }
            URI findFirstLombokDirectory = findFirstLombokDirectory(file);
            Set<String> set = treeMap.get(findFirstLombokDirectory);
            if (set == null) {
                set = new TreeSet<>();
                treeMap.put(findFirstLombokDirectory, set);
            }
            set.add(next);
        }
        return treeMap;
    }

    private URI findFirstLombokDirectory(File file) {
        File file2 = new File(file.toURI().normalize());
        if (file.isFile()) {
            file2 = file2.getParentFile();
        }
        while (file2 != null) {
            if (new File(file2, "lombok.config").exists()) {
                return file2.toURI();
            }
            file2 = file2.getParentFile();
        }
        return NO_CONFIG;
    }
}