package lombok.core;

import java.io.File;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.Writer;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.ProcessingEnvironment;
import javax.annotation.processing.Processor;
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedAnnotationTypes;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.Element;
import javax.lang.model.element.TypeElement;
import javax.tools.Diagnostic;
import lombok.patcher.ClassRootFinder;
import lombok.permit.Permit;
@SupportedAnnotationTypes({"*"})
/* loaded from: com.discord-117113.apk:lombok/core/AnnotationProcessor.SCL.lombok */
public class AnnotationProcessor extends AbstractProcessor {
    private final List<ProcessorDescriptor> registered = Arrays.asList(new JavacDescriptor(), new EcjDescriptor());
    private final List<ProcessorDescriptor> active = new ArrayList();
    private final List<String> delayedWarnings = new ArrayList();

    /* loaded from: com.discord-117113.apk:lombok/core/AnnotationProcessor$EcjDescriptor.SCL.lombok */
    static class EcjDescriptor extends ProcessorDescriptor {
        EcjDescriptor() {
        }

        @Override // lombok.core.AnnotationProcessor.ProcessorDescriptor
        String getName() {
            return "ECJ";
        }

        @Override // lombok.core.AnnotationProcessor.ProcessorDescriptor
        boolean want(ProcessingEnvironment processingEnvironment, List<String> list) {
            return processingEnvironment.getClass().getName().startsWith("org.eclipse.jdt.");
        }

        @Override // lombok.core.AnnotationProcessor.ProcessorDescriptor
        boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
            return false;
        }
    }

    /* loaded from: com.discord-117113.apk:lombok/core/AnnotationProcessor$JavacDescriptor.SCL.lombok */
    static class JavacDescriptor extends ProcessorDescriptor {
        private Processor processor;

        JavacDescriptor() {
        }

        @Override // lombok.core.AnnotationProcessor.ProcessorDescriptor
        String getName() {
            return "OpenJDK javac";
        }

        @Override // lombok.core.AnnotationProcessor.ProcessorDescriptor
        boolean want(ProcessingEnvironment processingEnvironment, List<String> list) {
            ProcessingEnvironment javacProcessingEnvironment;
            if (processingEnvironment.getClass().getName().startsWith("org.eclipse.jdt.") || (javacProcessingEnvironment = AnnotationProcessor.getJavacProcessingEnvironment(processingEnvironment, list)) == null) {
                return false;
            }
            try {
                this.processor = (Processor) Class.forName("lombok.javac.apt.LombokProcessor", false, findAndPatchClassLoader(javacProcessingEnvironment)).getConstructor(new Class[0]).newInstance(new Object[0]);
                try {
                    this.processor.init(processingEnvironment);
                    return true;
                } catch (Exception e) {
                    list.add("lombok.javac.apt.LombokProcessor could not be initialized. Lombok will not run during this compilation: " + AnnotationProcessor.access$0(e));
                    return false;
                } catch (NoClassDefFoundError e2) {
                    list.add("Can't initialize javac processor due to (most likely) a class loader problem: " + AnnotationProcessor.access$0(e2));
                    return false;
                }
            } catch (Exception e3) {
                list.add("You found a bug in lombok; lombok.javac.apt.LombokProcessor is not available. Lombok will not run during this compilation: " + AnnotationProcessor.access$0(e3));
                return false;
            } catch (NoClassDefFoundError e4) {
                list.add("Can't load javac processor due to (most likely) a class loader problem: " + AnnotationProcessor.access$0(e4));
                return false;
            }
        }

        private ClassLoader findAndPatchClassLoader(ProcessingEnvironment processingEnvironment) throws Exception {
            ClassLoader classLoader = processingEnvironment.getClass().getClassLoader();
            if (classLoader != null && classLoader.getClass().getCanonicalName().equals("org.codehaus.plexus.compiler.javac.IsolatedClassLoader") && !Augments.ClassLoader_lombokAlreadyAddedTo.getAndSet(classLoader, true).booleanValue()) {
                Permit.getMethod(classLoader.getClass(), "addURL", URL.class).invoke(classLoader, new File(ClassRootFinder.findClassRootOfClass(AnnotationProcessor.class)).toURI().toURL());
            }
            ClassLoader classLoader2 = JavacDescriptor.class.getClassLoader();
            return classLoader2 == null ? ClassLoader.getSystemClassLoader() : classLoader2;
        }

        @Override // lombok.core.AnnotationProcessor.ProcessorDescriptor
        boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
            return this.processor.process(set, roundEnvironment);
        }
    }

    /* loaded from: com.discord-117113.apk:lombok/core/AnnotationProcessor$ProcessorDescriptor.SCL.lombok */
    static abstract class ProcessorDescriptor {
        ProcessorDescriptor() {
        }

        abstract boolean want(ProcessingEnvironment processingEnvironment, List<String> list);

        abstract String getName();

        abstract boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment);
    }

    private static String trace(Throwable th) {
        StringWriter stringWriter = new StringWriter();
        th.printStackTrace(new PrintWriter((Writer) stringWriter, true));
        return stringWriter.toString();
    }

    public static ProcessingEnvironment getJavacProcessingEnvironment(ProcessingEnvironment processingEnvironment, List<String> list) {
        return tryRecursivelyObtainJavacProcessingEnvironment(processingEnvironment);
    }

    private static ProcessingEnvironment tryRecursivelyObtainJavacProcessingEnvironment(ProcessingEnvironment processingEnvironment) {
        Object tryGetDelegateField;
        if (processingEnvironment.getClass().getName().equals("com.sun.tools.javac.processing.JavacProcessingEnvironment")) {
            return processingEnvironment;
        }
        for (Class<?> cls = processingEnvironment.getClass(); cls != null; cls = cls.getSuperclass()) {
            try {
                tryGetDelegateField = tryGetDelegateField(cls, processingEnvironment);
                if (tryGetDelegateField == null) {
                    tryGetDelegateField = tryGetProcessingEnvField(cls, processingEnvironment);
                }
                if (tryGetDelegateField == null) {
                    tryGetDelegateField = tryGetProxyDelegateToField(cls, processingEnvironment);
                }
            } catch (Exception unused) {
            }
            if (tryGetDelegateField != null) {
                return tryRecursivelyObtainJavacProcessingEnvironment((ProcessingEnvironment) tryGetDelegateField);
            }
            continue;
        }
        return null;
    }

    private static Object tryGetDelegateField(Class<?> cls, Object obj) {
        try {
            return Permit.getField(cls, "delegate").get(obj);
        } catch (Exception unused) {
            return null;
        }
    }

    private static Object tryGetProcessingEnvField(Class<?> cls, Object obj) {
        try {
            return Permit.getField(cls, "processingEnv").get(obj);
        } catch (Exception unused) {
            return null;
        }
    }

    private static Object tryGetProxyDelegateToField(Class<?> cls, Object obj) {
        try {
            InvocationHandler invocationHandler = Proxy.getInvocationHandler(obj);
            return Permit.getField(invocationHandler.getClass(), "val$delegateTo").get(invocationHandler);
        } catch (Exception unused) {
            return null;
        }
    }

    public void init(ProcessingEnvironment processingEnvironment) {
        AnnotationProcessor.super.init(processingEnvironment);
        Iterator<ProcessorDescriptor> it = this.registered.iterator();
        while (it.hasNext()) {
            ProcessorDescriptor next = it.next();
            if (next.want(processingEnvironment, this.delayedWarnings)) {
                this.active.add(next);
            }
        }
        if (this.active.isEmpty() && this.delayedWarnings.isEmpty()) {
            StringBuilder sb = new StringBuilder();
            Iterator<ProcessorDescriptor> it2 = this.registered.iterator();
            while (it2.hasNext()) {
                ProcessorDescriptor next2 = it2.next();
                if (sb.length() > 0) {
                    sb.append(", ");
                }
                sb.append(next2.getName());
            }
            processingEnvironment.getMessager().printMessage(Diagnostic.Kind.WARNING, String.format("You aren't using a compiler supported by lombok, so lombok will not work and has been disabled.\nYour processor is: %s\nLombok supports: %s", processingEnvironment.getClass().getName(), sb));
        }
    }

    public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
        if (!this.delayedWarnings.isEmpty()) {
            Set rootElements = roundEnvironment.getRootElements();
            if (!rootElements.isEmpty()) {
                Element element = (Element) rootElements.iterator().next();
                Iterator<String> it = this.delayedWarnings.iterator();
                while (it.hasNext()) {
                    this.processingEnv.getMessager().printMessage(Diagnostic.Kind.WARNING, it.next(), element);
                }
                this.delayedWarnings.clear();
            }
        }
        Iterator<ProcessorDescriptor> it2 = this.active.iterator();
        while (it2.hasNext()) {
            it2.next().process(set, roundEnvironment);
        }
        boolean z2 = true;
        boolean z3 = true;
        Iterator<? extends TypeElement> it3 = set.iterator();
        while (it3.hasNext()) {
            z3 = false;
            if (!((TypeElement) it3.next()).getQualifiedName().toString().startsWith("lombok.")) {
                z2 = false;
            }
        }
        return z2 && !z3;
    }

    public SourceVersion getSupportedSourceVersion() {
        return SourceVersion.values()[SourceVersion.values().length - 1];
    }

    static /* synthetic */ String access$0(Throwable th) {
        return trace(th);
    }
}