package com.zwitserloot.cmdreader;

import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.AbstractCollection;
import java.util.AbstractList;
import java.util.AbstractSequentialList;
import java.util.AbstractSet;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.Set;
/* loaded from: com.discord-118107.apk:com/zwitserloot/cmdreader/ParseItem.SCL.lombok */
class ParseItem {
    private final Field field;
    private final boolean isCollection;
    private final Class<?> type;
    private final String fullName;
    private final boolean isSeq;
    private final boolean isParameterized;
    private final boolean isMandatory;
    private final String shorthand;
    private final String description;
    private final List<String> excludes;
    private final List<String> mandatoryIf;
    private final List<String> mandatoryIfNot;
    private final List<String> requires;
    private static final List<Class<?>> ARRAY_LIST_COMPATIBLES = Collections.unmodifiableList(Arrays.asList(Collection.class, AbstractCollection.class, List.class, AbstractList.class, ArrayList.class));
    private static final List<Class<?>> HASH_SET_COMPATIBLES = Collections.unmodifiableList(Arrays.asList(Set.class, AbstractSet.class, HashSet.class));
    private static final List<Class<?>> LINKED_LIST_COMPATIBLES = Collections.unmodifiableList(Arrays.asList(AbstractSequentialList.class, Queue.class, LinkedList.class));
    private final List<Class<?>> LEGAL_CLASSES = Collections.unmodifiableList(Arrays.asList(Integer.class, Long.class, Short.class, Byte.class, Float.class, Double.class, Boolean.class, Character.class, String.class, Enum.class));
    private List<String> TRUE_VALS = Collections.unmodifiableList(Arrays.asList("1", "true", "t", "y", "yes", "on"));
    private List<String> FALSE_VALS = Collections.unmodifiableList(Arrays.asList("0", "false", "f", "n", "no", "off"));

    ParseItem(Field field) {
        Class<?> cls;
        this.field = field;
        field.setAccessible(true);
        if (Collection.class.isAssignableFrom(field.getType())) {
            this.isCollection = true;
            Type genericType = field.getGenericType();
            Type[] actualTypeArguments = genericType instanceof ParameterizedType ? ((ParameterizedType) genericType).getActualTypeArguments() : null;
            if (actualTypeArguments == null || actualTypeArguments.length != 1 || !(actualTypeArguments[0] instanceof Class)) {
                throw new IllegalArgumentException(String.format("Only primitives, Strings, Enums, and Collections of those are allowed (for type: %s)", field.getGenericType()));
            }
            cls = (Class) actualTypeArguments[0];
        } else {
            this.isCollection = false;
            cls = field.getType();
        }
        if (cls == Integer.TYPE) {
            this.type = Integer.class;
        } else if (cls == Long.TYPE) {
            this.type = Long.class;
        } else if (cls == Short.TYPE) {
            this.type = Short.class;
        } else if (cls == Byte.TYPE) {
            this.type = Byte.class;
        } else if (cls == Double.TYPE) {
            this.type = Double.class;
        } else if (cls == Float.TYPE) {
            this.type = Float.class;
        } else if (cls == Character.TYPE) {
            this.type = Character.class;
        } else if (cls == Boolean.TYPE) {
            this.type = Boolean.class;
        } else {
            this.type = cls;
        }
        if (!this.LEGAL_CLASSES.contains(this.type)) {
            throw new IllegalArgumentException("Not a valid class for command line parsing: " + field.getGenericType());
        }
        this.fullName = setupFullName(field);
        this.isSeq = field.getAnnotation(Sequential.class) != null;
        this.isParameterized = (field.getType() == Boolean.TYPE || field.getType() == Boolean.class) ? false : true;
        this.shorthand = setupShorthand(field);
        this.description = setupDescription(field);
        this.isMandatory = setupMandatory(field);
        this.mandatoryIf = setupMandatoryIf(field);
        this.mandatoryIfNot = setupMandatoryIfNot(field);
        this.requires = setupRequires(field);
        this.excludes = setupExcludes(field);
        try {
            sanityChecks();
        } catch (IllegalArgumentException e) {
            throw new IllegalArgumentException(String.format("%s (at %s)", e.getMessage(), this.fullName));
        }
    }

    private void sanityChecks() {
        if (!this.isParameterized && Boolean.class != this.type) {
            throw new IllegalArgumentException("Non-parameterized parameters must have type boolean. - it's there (true), or not (false).");
        } else if (!this.isParameterized && this.isMandatory) {
            throw new IllegalArgumentException("Non-parameterized parameters must not be mandatory - what's the point of having it?");
        } else if (this.isSeq && !"".equals(this.shorthand)) {
            throw new IllegalArgumentException("sequential parameters must not have any shorthands.");
        } else if (this.isSeq && !this.isParameterized) {
            throw new IllegalArgumentException("sequential parameters must always be parameterized.");
        }
    }

    static void multiSanityChecks(List<ParseItem> list) {
        int size = list.size();
        for (int i = 0; i < size; i++) {
            for (int i2 = i + 1; i2 < size; i2++) {
                if (list.get(i).fullName.equalsIgnoreCase(list.get(i2).fullName)) {
                    throw new IllegalArgumentException(String.format("Duplicate full names for fields %s and %s.", list.get(i).field.getName(), list.get(i2).field.getName()));
                }
            }
        }
        ParseItem parseItem = null;
        for (ParseItem parseItem2 : list) {
            if (parseItem2.isSeq && parseItem != null) {
                throw new IllegalArgumentException(String.format("After the sequential, collection item %s no more sequential items allowed (at %s)", parseItem.fullName, parseItem2.fullName));
            } else if (parseItem2.isSeq && parseItem2.isCollection) {
                parseItem = parseItem2;
            }
        }
        ParseItem parseItem3 = null;
        for (ParseItem parseItem4 : list) {
            if (parseItem4.isSeq) {
                if (parseItem3 == null && !parseItem4.isMandatory) {
                    parseItem3 = parseItem4;
                }
                if (parseItem4.isMandatory && parseItem3 != null) {
                    throw new IllegalArgumentException(String.format("Sequential item %s is non-mandatory, so %s which is a later sequential item must also be non-mandatory", parseItem3.fullName, parseItem4.fullName));
                }
            }
        }
    }

    static Map<Character, ParseItem> makeShortHandMap(List<ParseItem> list) {
        char[] charArray;
        HashMap hashMap = new HashMap();
        for (ParseItem parseItem : list) {
            for (char c : parseItem.shorthand.toCharArray()) {
                if (hashMap.containsKey(Character.valueOf(c))) {
                    throw new IllegalArgumentException(String.format("Both %s and %s contain the shorthand %s", ((ParseItem) hashMap.get(Character.valueOf(c))).fullName, parseItem.fullName, Character.valueOf(c)));
                }
                hashMap.put(Character.valueOf(c), parseItem);
            }
        }
        return hashMap;
    }

    String getFullName() {
        return this.fullName;
    }

    boolean isSeq() {
        return this.isSeq;
    }

    boolean isMandatory() {
        return this.isMandatory;
    }

    List<String> getMandatoryIf() {
        return this.mandatoryIf;
    }

    List<String> getMandatoryIfNot() {
        return this.mandatoryIfNot;
    }

    List<String> getRequires() {
        return this.requires;
    }

    List<String> getExcludes() {
        return this.excludes;
    }

    boolean isParameterized() {
        return this.isParameterized;
    }

    boolean isCollection() {
        return this.isCollection;
    }

    String getFullDescription() {
        return this.description;
    }

    void set(Object obj, String str) {
        Object stringToObject = stringToObject(str);
        try {
            if (this.isCollection) {
                Collection collection = (Collection) this.field.get(obj);
                if (collection == null) {
                    if (ARRAY_LIST_COMPATIBLES.contains(this.field.getType())) {
                        collection = new ArrayList();
                    } else if (LINKED_LIST_COMPATIBLES.contains(this.field.getType())) {
                        collection = new LinkedList();
                    } else if (HASH_SET_COMPATIBLES.contains(this.field.getType())) {
                        collection = new HashSet();
                    } else {
                        throw new IllegalArgumentException("Cannot construct a collection of type " + this.field.getType() + " -- try List, Set, Collection, or Queue.");
                    }
                    this.field.set(obj, collection);
                }
                collection.add(stringToObject);
            } else {
                this.field.set(obj, stringToObject);
            }
        } catch (IllegalAccessException e) {
            throw new IllegalArgumentException("Huh?");
        }
    }

    private Object stringToObject(String str) {
        if (String.class == this.type) {
            return str;
        }
        if (Integer.class == this.type) {
            return Integer.valueOf(Integer.parseInt(str));
        }
        if (Long.class == this.type) {
            return Long.valueOf(Long.parseLong(str));
        }
        if (Short.class == this.type) {
            return Short.valueOf(Short.parseShort(str));
        }
        if (Byte.class == this.type) {
            return Byte.valueOf(Byte.parseByte(str));
        }
        if (Float.class == this.type) {
            return Float.valueOf(Float.parseFloat(str));
        }
        if (Double.class == this.type) {
            return Double.valueOf(Double.parseDouble(str));
        }
        if (Boolean.class == this.type) {
            return Boolean.valueOf(str == null ? true : parseBoolean(str));
        } else if (Character.class == this.type) {
            return Character.valueOf(str.length() == 0 ? (char) 0 : str.charAt(0));
        } else if (Enum.class == this.type) {
            return Enum.valueOf(this.type, str);
        } else {
            throw new IllegalArgumentException("Huh?");
        }
    }

    private String setupFullName(Field field) {
        FullName fullName = (FullName) field.getAnnotation(FullName.class);
        if (fullName == null) {
            return field.getName();
        }
        if (!fullName.value().trim().equals("")) {
            return fullName.value();
        }
        throw new IllegalArgumentException("Missing name for field: " + field.getName());
    }

    private String setupShorthand(Field field) {
        Shorthand shorthand = (Shorthand) field.getAnnotation(Shorthand.class);
        if (shorthand == null) {
            return "";
        }
        String[] value = shorthand.value();
        StringBuilder sb = new StringBuilder();
        for (String str : value) {
            char[] charArray = str.toCharArray();
            if (charArray.length != 1) {
                throw new IllegalArgumentException(String.format("Shorthands must be strings of 1 character long. (%s at %s)", str, this.fullName));
            } else if (charArray[0] == '-') {
                throw new IllegalArgumentException(String.format("The dash (-) is not a legal shorthand character. (at %s)", this.fullName));
            } else if (sb.indexOf(str) > -1) {
                throw new IllegalArgumentException(String.format("Duplicate shorthand: %s (at %s)", str, this.fullName));
            } else {
                sb.append(str);
            }
        }
        return sb.toString();
    }

    private String setupDescription(Field field) {
        Enum[] enumArr;
        StringBuilder sb = new StringBuilder();
        Description description = (Description) field.getAnnotation(Description.class);
        if (description != null) {
            sb.append(description.value());
        }
        if (this.isCollection) {
            sb.append(sb.length() > 0 ? "  " : "").append("This option may be used multiple times.");
        }
        if (this.isParameterized && this.type != String.class) {
            if (sb.length() > 0) {
                sb.append("  ");
            }
            if (this.type == Float.class || this.type == Double.class) {
                sb.append("value is a floating point number.");
            }
            if (this.type == Integer.class || this.type == Long.class || this.type == Short.class || this.type == Byte.class) {
                sb.append("value is an integer.");
            }
            if (this.type == Boolean.class) {
                sb.append("value is 'true' or 'false'.");
            }
            if (this.type == Character.class) {
                sb.append("Value is a single character.");
            }
            if (this.type == Enum.class) {
                sb.append("value is one of: ");
                boolean z2 = true;
                for (Enum r0 : (Enum[]) this.type.getEnumConstants()) {
                    if (z2) {
                        z2 = false;
                    } else {
                        sb.append(", ");
                    }
                    sb.append(r0.name());
                }
                sb.append(".");
            }
        }
        return sb.toString();
    }

    private boolean setupMandatory(Field field) {
        Mandatory mandatory = (Mandatory) field.getAnnotation(Mandatory.class);
        return mandatory != null && mandatory.onlyIf().length == 0 && mandatory.onlyIfNot().length == 0;
    }

    private List<String> setupMandatoryIf(Field field) {
        Mandatory mandatory = (Mandatory) field.getAnnotation(Mandatory.class);
        return (mandatory == null || mandatory.onlyIf().length == 0) ? Collections.emptyList() : Collections.unmodifiableList(Arrays.asList(mandatory.onlyIf()));
    }

    private List<String> setupMandatoryIfNot(Field field) {
        Mandatory mandatory = (Mandatory) field.getAnnotation(Mandatory.class);
        return (mandatory == null || mandatory.onlyIfNot().length == 0) ? Collections.emptyList() : Collections.unmodifiableList(Arrays.asList(mandatory.onlyIfNot()));
    }

    private List<String> setupRequires(Field field) {
        Requires requires = (Requires) this.field.getAnnotation(Requires.class);
        return (requires == null || requires.value().length == 0) ? Collections.emptyList() : Collections.unmodifiableList(Arrays.asList(requires.value()));
    }

    private List<String> setupExcludes(Field field) {
        Excludes excludes = (Excludes) field.getAnnotation(Excludes.class);
        return (excludes == null || excludes.value().length == 0) ? Collections.emptyList() : Collections.unmodifiableList(Arrays.asList(excludes.value()));
    }

    private boolean parseBoolean(String str) {
        for (String str2 : this.TRUE_VALS) {
            if (str2.equalsIgnoreCase(str)) {
                return true;
            }
        }
        for (String str3 : this.FALSE_VALS) {
            if (str3.equalsIgnoreCase(str)) {
                return false;
            }
        }
        throw new IllegalArgumentException("Not a boolean: " + str);
    }

    String getShorthand() {
        return this.shorthand;
    }
}