package lombok.core.configuration;

import com.adjust.sdk.Constants;
import com.discord.models.domain.ModelAuditLogEntry;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/* loaded from: com.discord-117113.apk:lombok/core/configuration/ConfigurationDataType.SCL.lombok */
public final class ConfigurationDataType {
    private static final Map<Class<?>, ConfigurationValueParser> SIMPLE_TYPES;
    private final boolean isList;
    private final ConfigurationValueParser parser;

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

        @Override // lombok.core.configuration.ConfigurationValueParser
        public Object parse(String str) {
            return str;
        }

        @Override // lombok.core.configuration.ConfigurationValueParser
        public String description() {
            return "string";
        }

        @Override // lombok.core.configuration.ConfigurationValueParser
        public String exampleValue() {
            return "<text>";
        }
    }

    /* renamed from: lombok.core.configuration.ConfigurationDataType$2  reason: invalid class name */
    /* loaded from: com.discord-117113.apk:lombok/core/configuration/ConfigurationDataType$2.SCL.lombok */
    class AnonymousClass2 implements ConfigurationValueParser {
        AnonymousClass2() {
        }

        @Override // lombok.core.configuration.ConfigurationValueParser
        public Object parse(String str) {
            return Integer.valueOf(Integer.parseInt(str));
        }

        @Override // lombok.core.configuration.ConfigurationValueParser
        public String description() {
            return "int";
        }

        @Override // lombok.core.configuration.ConfigurationValueParser
        public String exampleValue() {
            return "<int>";
        }
    }

    /* renamed from: lombok.core.configuration.ConfigurationDataType$3  reason: invalid class name */
    /* loaded from: com.discord-117113.apk:lombok/core/configuration/ConfigurationDataType$3.SCL.lombok */
    class AnonymousClass3 implements ConfigurationValueParser {
        AnonymousClass3() {
        }

        @Override // lombok.core.configuration.ConfigurationValueParser
        public Object parse(String str) {
            return Long.valueOf(Long.parseLong(str));
        }

        @Override // lombok.core.configuration.ConfigurationValueParser
        public String description() {
            return Constants.LONG;
        }

        @Override // lombok.core.configuration.ConfigurationValueParser
        public String exampleValue() {
            return "<long>";
        }
    }

    /* renamed from: lombok.core.configuration.ConfigurationDataType$4  reason: invalid class name */
    /* loaded from: com.discord-117113.apk:lombok/core/configuration/ConfigurationDataType$4.SCL.lombok */
    class AnonymousClass4 implements ConfigurationValueParser {
        AnonymousClass4() {
        }

        @Override // lombok.core.configuration.ConfigurationValueParser
        public Object parse(String str) {
            return Double.valueOf(Double.parseDouble(str));
        }

        @Override // lombok.core.configuration.ConfigurationValueParser
        public String description() {
            return "double";
        }

        @Override // lombok.core.configuration.ConfigurationValueParser
        public String exampleValue() {
            return "<double>";
        }
    }

    /* renamed from: lombok.core.configuration.ConfigurationDataType$5  reason: invalid class name */
    /* loaded from: com.discord-117113.apk:lombok/core/configuration/ConfigurationDataType$5.SCL.lombok */
    class AnonymousClass5 implements ConfigurationValueParser {
        AnonymousClass5() {
        }

        @Override // lombok.core.configuration.ConfigurationValueParser
        public Object parse(String str) {
            return Boolean.valueOf(Boolean.parseBoolean(str));
        }

        @Override // lombok.core.configuration.ConfigurationValueParser
        public String description() {
            return "boolean";
        }

        @Override // lombok.core.configuration.ConfigurationValueParser
        public String exampleValue() {
            return "[false | true]";
        }
    }

    /* renamed from: lombok.core.configuration.ConfigurationDataType$6  reason: invalid class name */
    /* loaded from: com.discord-117113.apk:lombok/core/configuration/ConfigurationDataType$6.SCL.lombok */
    class AnonymousClass6 implements ConfigurationValueParser {
        private final /* synthetic */ Class val$rawType;
        private final /* synthetic */ Class val$type;

        AnonymousClass6(Class cls, Class cls2) {
            this.val$rawType = cls;
            this.val$type = cls2;
        }

        @Override // lombok.core.configuration.ConfigurationValueParser
        public Object parse(String str) {
            try {
                return Enum.valueOf(this.val$rawType, str);
            } catch (Exception unused) {
                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < str.length(); i++) {
                    char charAt = str.charAt(i);
                    if (Character.isUpperCase(charAt) && i > 0) {
                        sb.append("_");
                    }
                    sb.append(Character.toUpperCase(charAt));
                }
                return Enum.valueOf(this.val$rawType, sb.toString());
            }
        }

        @Override // lombok.core.configuration.ConfigurationValueParser
        public String description() {
            return "enum (" + this.val$type.getName() + ")";
        }

        @Override // lombok.core.configuration.ConfigurationValueParser
        public String exampleValue() {
            ExampleValueString exampleValueString = (ExampleValueString) this.val$type.getAnnotation(ExampleValueString.class);
            return exampleValueString != null ? exampleValueString.value() : Arrays.toString(this.val$type.getEnumConstants()).replace(",", " |");
        }
    }

    /* renamed from: lombok.core.configuration.ConfigurationDataType$7  reason: invalid class name */
    /* loaded from: com.discord-117113.apk:lombok/core/configuration/ConfigurationDataType$7.SCL.lombok */
    class AnonymousClass7 implements ConfigurationValueParser {
        private final /* synthetic */ Method val$valueOfMethod;
        private final /* synthetic */ Method val$descriptionMethod;
        private final /* synthetic */ Method val$exampleValueMethod;

        AnonymousClass7(Method method, Method method2, Method method3) {
            this.val$valueOfMethod = method;
            this.val$descriptionMethod = method2;
            this.val$exampleValueMethod = method3;
        }

        @Override // lombok.core.configuration.ConfigurationValueParser
        public Object parse(String str) {
            return invokeStaticMethod(this.val$valueOfMethod, str);
        }

        @Override // lombok.core.configuration.ConfigurationValueParser
        public String description() {
            return (String) invokeStaticMethod(this.val$descriptionMethod, new Object[0]);
        }

        @Override // lombok.core.configuration.ConfigurationValueParser
        public String exampleValue() {
            return (String) invokeStaticMethod(this.val$exampleValueMethod, new Object[0]);
        }

        private <R> R invokeStaticMethod(Method method, Object... objArr) {
            try {
                return (R) method.invoke(null, objArr);
            } catch (IllegalAccessException e) {
                throw new IllegalStateException("The method " + method.getName() + " ", e);
            } catch (InvocationTargetException e2) {
                throw ((RuntimeException) e2.getTargetException());
            }
        }
    }

    static {
        HashMap hashMap = new HashMap();
        hashMap.put(String.class, new AnonymousClass1());
        hashMap.put(Integer.class, new AnonymousClass2());
        hashMap.put(Long.class, new AnonymousClass3());
        hashMap.put(Double.class, new AnonymousClass4());
        hashMap.put(Boolean.class, new AnonymousClass5());
        SIMPLE_TYPES = hashMap;
    }

    private static ConfigurationValueParser enumParser(Type type) {
        Class cls = (Class) type;
        return new AnonymousClass6(cls, cls);
    }

    private static ConfigurationValueParser valueTypeParser(Type type) {
        Class cls = (Class) type;
        return new AnonymousClass7(getMethod(cls, "valueOf", String.class), getMethod(cls, ModelAuditLogEntry.CHANGE_KEY_DESCRIPTION, new Class[0]), getMethod(cls, "exampleValue", new Class[0]));
    }

    public static ConfigurationDataType toDataType(Class<? extends ConfigurationKey<?>> cls) {
        if (cls.getSuperclass() != ConfigurationKey.class) {
            throw new IllegalArgumentException("No direct subclass of ConfigurationKey: " + cls.getName());
        }
        Type genericSuperclass = cls.getGenericSuperclass();
        if (!(genericSuperclass instanceof ParameterizedType)) {
            throw new IllegalArgumentException("Missing type parameter in " + genericSuperclass);
        }
        Type type = ((ParameterizedType) genericSuperclass).getActualTypeArguments()[0];
        boolean z2 = false;
        if (type instanceof ParameterizedType) {
            ParameterizedType parameterizedType = (ParameterizedType) type;
            if (parameterizedType.getRawType() == List.class) {
                z2 = true;
                type = parameterizedType.getActualTypeArguments()[0];
            }
        }
        if (SIMPLE_TYPES.containsKey(type)) {
            return new ConfigurationDataType(z2, SIMPLE_TYPES.get(type));
        }
        if (isEnum(type)) {
            return new ConfigurationDataType(z2, enumParser(type));
        }
        if (isConfigurationValueType(type)) {
            return new ConfigurationDataType(z2, valueTypeParser(type));
        }
        throw new IllegalArgumentException("Unsupported type parameter in " + genericSuperclass);
    }

    private ConfigurationDataType(boolean z2, ConfigurationValueParser configurationValueParser) {
        this.isList = z2;
        this.parser = configurationValueParser;
    }

    public boolean isList() {
        return this.isList;
    }

    ConfigurationValueParser getParser() {
        return this.parser;
    }

    public String toString() {
        return this.isList ? "list of " + this.parser.description() : this.parser.description();
    }

    private static boolean isEnum(Type type) {
        return (type instanceof Class) && ((Class) type).isEnum();
    }

    private static boolean isConfigurationValueType(Type type) {
        return (type instanceof Class) && ConfigurationValueType.class.isAssignableFrom((Class) type);
    }

    private static Method getMethod(Class<?> cls, String str, Class<?>... clsArr) {
        try {
            return cls.getMethod(str, clsArr);
        } catch (NoSuchMethodException e) {
            throw new IllegalStateException("Method " + str + " with parameters " + Arrays.toString(clsArr) + " was not found.", e);
        } catch (SecurityException e2) {
            throw new IllegalStateException("Cannot inspect methods of type " + cls, e2);
        }
    }
}