package lombok.core.handlers;

import com.discord.models.domain.ModelAuditLogEntry;
import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import lombok.EqualsAndHashCode;
import lombok.ToString;
import lombok.core.AST;
import lombok.core.AnnotationValues;
import lombok.core.LombokNode;
/* loaded from: com.discord-117113.apk:lombok/core/handlers/InclusionExclusionUtils.SCL.lombok */
public class InclusionExclusionUtils {

    /* renamed from: lombok.core.handlers.InclusionExclusionUtils$1  reason: invalid class name */
    /* loaded from: com.discord-117113.apk:lombok/core/handlers/InclusionExclusionUtils$1.SCL.lombok */
    class AnonymousClass1 implements Comparator<Included<L, ToString.Include>> {
        AnonymousClass1() {
        }

        public int compare(Included<L, ToString.Include> included, Included<L, ToString.Include> included2) {
            return InclusionExclusionUtils.access$0(included.getInc() == null ? 0 : included.getInc().rank(), included2.getInc() == null ? 0 : included2.getInc().rank(), (LombokNode) included.getNode(), (LombokNode) included2.getNode());
        }
    }

    /* renamed from: lombok.core.handlers.InclusionExclusionUtils$2  reason: invalid class name */
    /* loaded from: com.discord-117113.apk:lombok/core/handlers/InclusionExclusionUtils$2.SCL.lombok */
    class AnonymousClass2 implements Comparator<Included<L, EqualsAndHashCode.Include>> {
        AnonymousClass2() {
        }

        public int compare(Included<L, EqualsAndHashCode.Include> included, Included<L, EqualsAndHashCode.Include> included2) {
            return InclusionExclusionUtils.access$0(included.hasExplicitRank() ? included.getInc().rank() : HandlerUtil.defaultEqualsAndHashcodeIncludeRank(((LombokNode) Included.access$0(included)).fieldOrMethodBaseType()), included2.hasExplicitRank() ? included2.getInc().rank() : HandlerUtil.defaultEqualsAndHashcodeIncludeRank(((LombokNode) Included.access$0(included2)).fieldOrMethodBaseType()), (LombokNode) included.getNode(), (LombokNode) included2.getNode());
        }
    }

    /* loaded from: com.discord-117113.apk:lombok/core/handlers/InclusionExclusionUtils$Included.SCL.lombok */
    public static class Included<L, I extends Annotation> {
        private final L node;
        private final I inc;
        private final boolean defaultInclude;
        private final boolean explicitRank;

        public Included(L l, I i, boolean z2, boolean z3) {
            this.node = l;
            this.inc = i;
            this.defaultInclude = z2;
            this.explicitRank = z3;
        }

        public L getNode() {
            return this.node;
        }

        public I getInc() {
            return this.inc;
        }

        public boolean isDefaultInclude() {
            return this.defaultInclude;
        }

        public boolean hasExplicitRank() {
            return this.explicitRank;
        }

        static /* synthetic */ Object access$0(Included included) {
            return included.node;
        }
    }

    private static List<Integer> createListOfNonExistentFields(List<String> list, LombokNode<?, ?, ?> lombokNode, boolean z2, boolean z3) {
        boolean[] zArr = new boolean[list.size()];
        Iterator<?> it = lombokNode.down().iterator();
        while (it.hasNext()) {
            LombokNode lombokNode2 = (LombokNode) it.next();
            if (list.isEmpty()) {
                break;
            } else if (lombokNode2.getKind() == AST.Kind.FIELD && (!z2 || (!lombokNode2.isStatic() && !lombokNode2.getName().startsWith("$")))) {
                if (!z3 || !lombokNode2.isTransient()) {
                    int indexOf = list.indexOf(lombokNode2.getName());
                    if (indexOf > -1) {
                        zArr[indexOf] = true;
                    }
                }
            }
        }
        ArrayList arrayList = new ArrayList();
        for (int i = 0; i < list.size(); i++) {
            if (!zArr[i]) {
                arrayList.add(Integer.valueOf(i));
            }
        }
        return arrayList;
    }

    public static void checkForBogusFieldNames(LombokNode<?, ?, ?> lombokNode, AnnotationValues<?> annotationValues, List<String> list, List<String> list2) {
        if (list != null && !list.isEmpty()) {
            Iterator<Integer> it = createListOfNonExistentFields(list, lombokNode, true, false).iterator();
            while (it.hasNext()) {
                int intValue = it.next().intValue();
                if (annotationValues != null) {
                    annotationValues.setWarning("exclude", "This field does not exist, or would have been excluded anyway.", intValue);
                }
            }
        }
        if (list2 != null && !list2.isEmpty()) {
            Iterator<Integer> it2 = createListOfNonExistentFields(list2, lombokNode, false, false).iterator();
            while (it2.hasNext()) {
                int intValue2 = it2.next().intValue();
                if (annotationValues != null) {
                    annotationValues.setWarning("of", "This field does not exist.", intValue2);
                }
            }
        }
    }

    private static String innerAnnName(Class<? extends Annotation> cls) {
        String simpleName = cls.getSimpleName();
        for (Class<?> enclosingClass = cls.getEnclosingClass(); enclosingClass != null; enclosingClass = enclosingClass.getEnclosingClass()) {
            simpleName = String.valueOf(enclosingClass.getSimpleName()) + "." + simpleName;
        }
        return simpleName;
    }

    private static <A extends AST<A, L, N>, L extends LombokNode<A, L, N>, N, I extends Annotation> List<Included<L, I>> handleIncludeExcludeMarking(Class<I> cls, String str, Class<? extends Annotation> cls2, LombokNode<A, L, N> lombokNode, AnnotationValues<?> annotationValues, LombokNode<A, L, N> lombokNode2, boolean z2) {
        List<String> asStringList = (annotationValues == null || !annotationValues.isExplicit("exclude")) ? null : annotationValues.getAsStringList("exclude");
        List<String> asStringList2 = (annotationValues == null || !annotationValues.isExplicit("of")) ? null : annotationValues.getAsStringList("of");
        boolean asBoolean = annotationValues != null ? annotationValues.getAsBoolean("onlyExplicitlyIncluded") : false;
        boolean z3 = asBoolean;
        ArrayList arrayList = new ArrayList();
        ArrayList arrayList2 = new ArrayList();
        if (lombokNode == null || lombokNode.getKind() != AST.Kind.TYPE) {
            return null;
        }
        checkForBogusFieldNames(lombokNode, annotationValues, asStringList, asStringList2);
        if (!(asStringList == null || asStringList2 == null)) {
            asStringList = null;
            if (annotationValues != null) {
                annotationValues.setWarning("exclude", "exclude and of are mutually exclusive; the 'exclude' parameter will be ignored.");
            }
        }
        Iterator<L> it = lombokNode.down().iterator();
        while (it.hasNext()) {
            L next = it.next();
            boolean z4 = next.getKind() == AST.Kind.FIELD && next.hasAnnotation(cls2);
            AnnotationValues annotationValues2 = null;
            if (next.getKind() == AST.Kind.FIELD || next.getKind() == AST.Kind.METHOD) {
                annotationValues2 = next.findAnnotation(cls);
            }
            if (z4 || annotationValues2 != null) {
                z3 = true;
            }
            if (annotationValues2 != null && z4) {
                next.addError("@" + innerAnnName(cls2) + " and @" + innerAnnName(cls) + " are mutually exclusive; the @Include annotation will be ignored");
                annotationValues2 = null;
            }
            String name = next.getName();
            if (z4) {
                if (asBoolean) {
                    next.addWarning("The @Exclude annotation is not needed; 'onlyExplicitlyIncluded' is set, so this member would be excluded anyway");
                } else if (next.isStatic()) {
                    next.addWarning("The @Exclude annotation is not needed; static fields aren't included anyway");
                } else if (name.startsWith("$")) {
                    next.addWarning("The @Exclude annotation is not needed; fields that start with $ aren't included anyway");
                }
            } else if (asStringList == null || !asStringList.contains(name)) {
                if (annotationValues2 != null) {
                    Annotation instance = annotationValues2.getInstance();
                    if (next.getKind() == AST.Kind.METHOD) {
                        if (next.countMethodParameters() > 0) {
                            next.addError("Methods included with @" + innerAnnName(cls) + " must have no arguments; it will not be included");
                        } else {
                            String asString = str != null ? annotationValues2.getAsString(str) : "";
                            if (asString.isEmpty()) {
                                asString = name;
                            }
                            arrayList2.add(asString);
                        }
                    }
                    arrayList.add(new Included(next, instance, false, annotationValues2.isExplicit("rank")));
                } else if (!asBoolean) {
                    if (asStringList2 != null) {
                        if (next.getKind() == AST.Kind.FIELD && asStringList2.contains(name)) {
                            arrayList.add(new Included(next, null, false, false));
                        }
                    } else if (next.getKind() == AST.Kind.FIELD && !next.isStatic() && (!next.isTransient() || z2)) {
                        if (!name.startsWith("$") && !next.isEnumMember()) {
                            arrayList.add(new Included(next, null, true, false));
                        }
                    }
                }
            }
        }
        Iterator it2 = arrayList.iterator();
        while (it2.hasNext()) {
            Included included = (Included) it2.next();
            if (included.isDefaultInclude() && arrayList2.contains(((LombokNode) included.getNode()).getName())) {
                it2.remove();
            }
        }
        if (annotationValues == null || !annotationValues.isExplicit("exclude")) {
            asStringList = null;
        }
        if (annotationValues == null || !annotationValues.isExplicit("of")) {
            asStringList2 = null;
        }
        if (!z3 || (asStringList == null && asStringList2 == null)) {
            return arrayList;
        }
        lombokNode2.addError("The old-style 'exclude/of' parameter cannot be used together with the new-style @Include / @Exclude annotations.");
        return null;
    }

    public static <A extends AST<A, L, N>, L extends LombokNode<A, L, N>, N> List<Included<L, ToString.Include>> handleToStringMarking(LombokNode<A, L, N> lombokNode, AnnotationValues<ToString> annotationValues, LombokNode<A, L, N> lombokNode2) {
        List<Included<L, ToString.Include>> handleIncludeExcludeMarking = handleIncludeExcludeMarking(ToString.Include.class, ModelAuditLogEntry.CHANGE_KEY_NAME, ToString.Exclude.class, lombokNode, annotationValues, lombokNode2, true);
        Collections.sort(handleIncludeExcludeMarking, new AnonymousClass1());
        return handleIncludeExcludeMarking;
    }

    public static <A extends AST<A, L, N>, L extends LombokNode<A, L, N>, N> List<Included<L, EqualsAndHashCode.Include>> handleEqualsAndHashCodeMarking(LombokNode<A, L, N> lombokNode, AnnotationValues<EqualsAndHashCode> annotationValues, LombokNode<A, L, N> lombokNode2) {
        List<Included<L, EqualsAndHashCode.Include>> handleIncludeExcludeMarking = handleIncludeExcludeMarking(EqualsAndHashCode.Include.class, "replaces", EqualsAndHashCode.Exclude.class, lombokNode, annotationValues, lombokNode2, false);
        Collections.sort(handleIncludeExcludeMarking, new AnonymousClass2());
        return handleIncludeExcludeMarking;
    }

    private static <A extends AST<A, L, N>, L extends LombokNode<A, L, N>, N> int compareRankOrPosition(int i, int i2, LombokNode<A, L, N> lombokNode, LombokNode<A, L, N> lombokNode2) {
        int startPos;
        int startPos2;
        if (i < i2) {
            return 1;
        }
        if (i <= i2 && (startPos = lombokNode.getStartPos()) >= (startPos2 = lombokNode2.getStartPos())) {
            return startPos > startPos2 ? 1 : 0;
        }
        return -1;
    }

    static /* synthetic */ int access$0(int i, int i2, LombokNode lombokNode, LombokNode lombokNode2) {
        return compareRankOrPosition(i, i2, lombokNode, lombokNode2);
    }
}