package com.zwitserloot.cmdreader;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
/* loaded from: com.discord-118107.apk:com/zwitserloot/cmdreader/CmdReader.SCL.lombok */
public class CmdReader<T> {
    private final Class<T> settingsDescriptor;
    private final List<ParseItem> items = Collections.unmodifiableList(init());
    private final Map<Character, ParseItem> shorthands = ParseItem.makeShortHandMap(this.items);
    private final List<ParseItem> seqList = makeSeqList(this.items);
    private static final int SCREEN_WIDTH = 72;

    /* renamed from: com.zwitserloot.cmdreader.CmdReader$1State  reason: invalid class name */
    /* loaded from: com.discord-118107.apk:com/zwitserloot/cmdreader/CmdReader$1State.SCL.lombok */
    class C1State {
        List<ParseItem> used = new ArrayList();
        final /* synthetic */ Object val$obj;

        C1State(Object obj) {
            this.val$obj = obj;
        }

        void handle(ParseItem parseItem, String str) {
            parseItem.set(this.val$obj, str);
            this.used.add(parseItem);
        }

        void finish() throws InvalidCommandLineException {
            checkForGlobalMandatories();
            checkForExcludes();
            checkForRequires();
            checkForMandatoriesIf();
            checkForMandatoriesIfNot();
        }

        private void checkForGlobalMandatories() throws InvalidCommandLineException {
            for (ParseItem parseItem : CmdReader.access$000(CmdReader.this)) {
                if (parseItem.isMandatory() && !this.used.contains(parseItem)) {
                    throw new InvalidCommandLineException("You did not specify mandatory parameter " + parseItem.getFullName());
                }
            }
        }

        private void checkForExcludes() throws InvalidCommandLineException {
            for (ParseItem parseItem : CmdReader.access$000(CmdReader.this)) {
                if (this.used.contains(parseItem)) {
                    for (String str : parseItem.getExcludes()) {
                        for (ParseItem parseItem2 : CmdReader.access$000(CmdReader.this)) {
                            if (parseItem2.getFullName().equals(str) && this.used.contains(parseItem2)) {
                                throw new InvalidCommandLineException("You specified parameter " + parseItem2.getFullName() + " which cannot be used together with " + parseItem.getFullName());
                            }
                        }
                    }
                    continue;
                }
            }
        }

        private void checkForRequires() throws InvalidCommandLineException {
            for (ParseItem parseItem : CmdReader.access$000(CmdReader.this)) {
                if (this.used.contains(parseItem)) {
                    for (String str : parseItem.getRequires()) {
                        for (ParseItem parseItem2 : CmdReader.access$000(CmdReader.this)) {
                            if (parseItem2.getFullName().equals(str) && !this.used.contains(parseItem2)) {
                                throw new InvalidCommandLineException("You specified parameter " + parseItem.getFullName() + " which requires that you also supply " + parseItem2.getFullName());
                            }
                        }
                    }
                    continue;
                }
            }
        }

        private void checkForMandatoriesIf() throws InvalidCommandLineException {
            for (ParseItem parseItem : CmdReader.access$000(CmdReader.this)) {
                if (!this.used.contains(parseItem) && parseItem.getMandatoryIf().size() != 0) {
                    for (String str : parseItem.getMandatoryIf()) {
                        for (ParseItem parseItem2 : CmdReader.access$000(CmdReader.this)) {
                            if (parseItem2.getFullName().equals(str) && this.used.contains(parseItem2)) {
                                throw new InvalidCommandLineException("You did not specify parameter " + parseItem.getFullName() + " which is mandatory if you use " + parseItem2.getFullName());
                            }
                        }
                    }
                    continue;
                }
            }
        }

        private void checkForMandatoriesIfNot() throws InvalidCommandLineException {
            for (ParseItem parseItem : CmdReader.access$000(CmdReader.this)) {
                if (!this.used.contains(parseItem) && parseItem.getMandatoryIfNot().size() != 0) {
                    for (String str : parseItem.getMandatoryIfNot()) {
                        for (ParseItem parseItem2 : CmdReader.access$000(CmdReader.this)) {
                            if (!parseItem2.getFullName().equals(str) || !this.used.contains(parseItem2)) {
                            }
                        }
                    }
                    StringBuilder sb = new StringBuilder();
                    if (parseItem.getMandatoryIfNot().size() > 1) {
                        sb.append("one of ");
                    }
                    for (String str2 : parseItem.getMandatoryIfNot()) {
                        sb.append(str2).append(", ");
                    }
                    sb.setLength(sb.length() - 2);
                    throw new InvalidCommandLineException("You did not specify parameter " + parseItem.getFullName() + " which is mandatory unless you use " + ((Object) sb));
                }
            }
        }
    }

    private CmdReader(Class<T> cls) {
        this.settingsDescriptor = cls;
    }

    public static <T> CmdReader<T> of(Class<T> cls) {
        return new CmdReader<>(cls);
    }

    private List<ParseItem> init() {
        Field[] declaredFields;
        ArrayList arrayList = new ArrayList();
        for (Class<T> cls = this.settingsDescriptor; cls != Object.class; cls = cls.getSuperclass()) {
            for (Field field : this.settingsDescriptor.getDeclaredFields()) {
                field.setAccessible(true);
                if (!Modifier.isStatic(field.getModifiers())) {
                    arrayList.add(new ParseItem(field));
                }
            }
        }
        ParseItem.multiSanityChecks(arrayList);
        return arrayList;
    }

    private static List<ParseItem> makeSeqList(List<ParseItem> list) {
        ArrayList arrayList = new ArrayList();
        for (ParseItem parseItem : list) {
            if (parseItem.isSeq()) {
                arrayList.add(parseItem);
            }
        }
        return arrayList;
    }

    public String generateCommandLineHelp(String str) {
        StringBuilder sb = new StringBuilder();
        int i = 0;
        int i2 = 0;
        for (ParseItem parseItem : this.items) {
            if (!parseItem.isSeq()) {
                i = Math.max(i, parseItem.getFullName().length() + (parseItem.isParameterized() ? 4 : 0));
                i2 = Math.max(i2, parseItem.getShorthand().length());
            }
        }
        if (i2 == 0) {
            i2++;
        }
        int i3 = (i2 * 3) - 1;
        generateShortSummary(str, sb);
        generateSequentialArgsHelp(sb);
        generateMandatoryArgsHelp(i, i3, sb);
        generateOptionalArgsHelp(i, i3, sb);
        return sb.toString();
    }

    private void generateShortSummary(String str, StringBuilder sb) {
        if (str != null && str.length() > 0) {
            sb.append(str).append(" ");
        }
        StringBuilder sb2 = new StringBuilder();
        for (ParseItem parseItem : this.items) {
            if (!parseItem.isSeq() && !parseItem.isMandatory()) {
                sb2.append(parseItem.getShorthand());
            }
        }
        if (sb2.length() > 0) {
            sb.append("[-").append((CharSequence) sb2).append("] ");
            sb2.setLength(0);
        }
        for (ParseItem parseItem2 : this.items) {
            if (!parseItem2.isSeq() && parseItem2.isMandatory()) {
                sb2.append(parseItem2.getShorthand());
            }
        }
        if (sb2.length() > 0) {
            sb.append("-").append((CharSequence) sb2).append(" ");
            sb2.setLength(0);
        }
        for (ParseItem parseItem3 : this.items) {
            if (!parseItem3.isSeq() && parseItem3.isMandatory() && parseItem3.getShorthand().length() == 0) {
                sb.append("--").append(parseItem3.getFullName()).append("=val ");
            }
        }
        for (ParseItem parseItem4 : this.items) {
            if (parseItem4.isSeq()) {
                if (!parseItem4.isMandatory()) {
                    sb.append('[');
                }
                sb.append(parseItem4.getFullName());
                if (!parseItem4.isMandatory()) {
                    sb.append(']');
                }
                sb.append(' ');
            }
        }
        sb.append("\n");
    }

    private void generateSequentialArgsHelp(StringBuilder sb) {
        ArrayList<ParseItem> arrayList = new ArrayList();
        for (ParseItem parseItem : this.items) {
            if (parseItem.isSeq() && parseItem.getFullDescription().length() > 0) {
                arrayList.add(parseItem);
            }
        }
        if (arrayList.size() != 0) {
            int i = 0;
            for (ParseItem parseItem2 : arrayList) {
                i = Math.max(i, parseItem2.getFullName().length());
            }
            sb.append("\n  Sequential arguments:\n");
            for (ParseItem parseItem3 : arrayList) {
                generateSequentialArgHelp(i, parseItem3, sb);
            }
        }
    }

    private void generateMandatoryArgsHelp(int i, int i2, StringBuilder sb) {
        ArrayList<ParseItem> arrayList = new ArrayList();
        for (ParseItem parseItem : this.items) {
            if (parseItem.isMandatory() && !parseItem.isSeq()) {
                arrayList.add(parseItem);
            }
        }
        if (arrayList.size() != 0) {
            sb.append("\n  Mandatory arguments:\n");
            for (ParseItem parseItem2 : arrayList) {
                generateArgHelp(i, i2, parseItem2, sb);
            }
        }
    }

    private void generateOptionalArgsHelp(int i, int i2, StringBuilder sb) {
        ArrayList<ParseItem> arrayList = new ArrayList();
        for (ParseItem parseItem : this.items) {
            if (!parseItem.isMandatory() && !parseItem.isSeq()) {
                arrayList.add(parseItem);
            }
        }
        if (arrayList.size() != 0) {
            sb.append("\n  Optional arguments:\n");
            for (ParseItem parseItem2 : arrayList) {
                generateArgHelp(i, i2, parseItem2, sb);
            }
        }
    }

    private void generateArgHelp(int i, int i2, ParseItem parseItem, StringBuilder sb) {
        char[] charArray;
        sb.append("    ");
        sb.append(String.format("--%-" + i + "s ", parseItem.getFullName() + (parseItem.isParameterized() ? "=val" : "")));
        StringBuilder sb2 = new StringBuilder();
        for (char c : parseItem.getShorthand().toCharArray()) {
            if (sb2.length() > 0) {
                sb2.append(" ");
            }
            sb2.append("-").append(c);
        }
        sb.append(String.format("%-" + i2 + "s ", sb2));
        int i3 = (64 - i2) - i;
        String fullDescription = parseItem.getFullDescription();
        if (fullDescription.length() == 0 || fullDescription.length() < i3) {
            sb.append(fullDescription).append("\n");
            return;
        }
        for (String str : wordbreak(parseItem.getFullDescription(), 64)) {
            sb.append("\n        ").append(str);
        }
        sb.append("\n");
    }

    private void generateSequentialArgHelp(int i, ParseItem parseItem, StringBuilder sb) {
        sb.append("    ");
        sb.append(String.format("%-" + i + "s   ", parseItem.getFullName()));
        int i2 = 65 - i;
        String fullDescription = parseItem.getFullDescription();
        if (fullDescription.length() == 0 || fullDescription.length() < i2) {
            sb.append(fullDescription).append("\n");
            return;
        }
        for (String str : wordbreak(parseItem.getFullDescription(), 64)) {
            sb.append("\n        ").append(str);
        }
        sb.append("\n");
    }

    private static List<String> wordbreak(String str, int i) {
        StringBuilder sb = new StringBuilder();
        ArrayList arrayList = new ArrayList();
        int i2 = -1;
        char[] charArray = str.toCharArray();
        int length = charArray.length;
        for (int i3 = 0; i3 < length; i3++) {
            char c = charArray[i3];
            if (c == '\t') {
                c = ' ';
            }
            if (c == '\n') {
                arrayList.add(sb.toString());
                sb.setLength(0);
                i2 = -1;
            } else {
                if (c == ' ') {
                    i2 = sb.length();
                    sb.append(' ');
                } else {
                    sb.append(c);
                }
                if (sb.length() > i && i2 > 8) {
                    arrayList.add(sb.substring(0, i2));
                    String substring = sb.substring(i2 + 1);
                    sb.setLength(0);
                    sb.append(substring);
                    i2 = -1;
                }
            }
        }
        if (sb.length() > 0) {
            arrayList.add(sb.toString());
        }
        return arrayList;
    }

    public T make(String str) throws InvalidCommandLineException, IllegalArgumentException {
        char[] charArray;
        ArrayList arrayList = new ArrayList();
        StringBuilder sb = new StringBuilder();
        boolean z2 = false;
        boolean z3 = false;
        for (char c : str.toCharArray()) {
            if (z3) {
                z3 = false;
                if (c != '\n') {
                    sb.append(c);
                }
            }
            if (c == '\\') {
                z3 = true;
            } else if (c == '\"') {
                z2 = !z2;
            } else if (c != ' ' || z2) {
                sb.append(c);
            } else {
                String sb2 = sb.toString();
                sb.setLength(0);
                if (!sb2.equals("")) {
                    arrayList.add(sb2);
                }
            }
        }
        if (sb.length() > 0) {
            arrayList.add(sb.toString());
        }
        return make((String[]) arrayList.toArray(new String[arrayList.size()]));
    }

    public T make(String[] strArr) throws InvalidCommandLineException {
        char[] charArray;
        T construct = construct();
        if (strArr == null) {
            strArr = new String[0];
        }
        int i = 0;
        C1State r0 = new C1State(construct);
        int i2 = 0;
        while (i2 < strArr.length) {
            if (strArr[i2].startsWith("--")) {
                int indexOf = strArr[i2].indexOf(61);
                String substring = indexOf == -1 ? strArr[i2].substring(2) : strArr[i2].substring(2, indexOf);
                String substring2 = indexOf == -1 ? "" : strArr[i2].substring(indexOf + 1);
                if (substring2.length() != 0 || indexOf == -1) {
                    boolean z2 = false;
                    Iterator<ParseItem> it = this.items.iterator();
                    while (true) {
                        if (!it.hasNext()) {
                            break;
                        }
                        ParseItem next = it.next();
                        if (next.getFullName().equalsIgnoreCase(substring)) {
                            if (next.isParameterized() && substring2.length() == 0) {
                                if (i2 >= strArr.length - 1 || strArr[i2 + 1].startsWith("-")) {
                                    throw new InvalidCommandLineException(String.format("invalid command line argument - %s requires a parameter but there is none.", substring));
                                }
                                i2++;
                                substring2 = strArr[i2];
                            }
                            r0.handle(next, (next.isParameterized() || substring2.length() != 0) ? substring2 : null);
                            z2 = true;
                        }
                    }
                    if (!z2) {
                        throw new InvalidCommandLineException("invalid command line argument - I don't know about that option: " + strArr[i2]);
                    }
                } else {
                    throw new InvalidCommandLineException("invalid command line argument - you should write something after the '=': " + strArr[i2]);
                }
            } else if (strArr[i2].startsWith("-")) {
                for (char c : strArr[i2].substring(1).toCharArray()) {
                    ParseItem parseItem = this.shorthands.get(Character.valueOf(c));
                    if (parseItem == null) {
                        throw new InvalidCommandLineException(String.format("invalid command line argument - %s is not a known option: %s", Character.valueOf(c), strArr[i2]));
                    }
                    if (!parseItem.isParameterized()) {
                        r0.handle(parseItem, null);
                    } else if (i2 >= strArr.length - 1 || strArr[i2 + 1].startsWith("-")) {
                        throw new InvalidCommandLineException(String.format("invalid command line argument - %s requires a parameter but there is none.", Character.valueOf(c)));
                    } else {
                        i2++;
                        r0.handle(parseItem, strArr[i2]);
                    }
                }
                continue;
            } else {
                i++;
                if (this.seqList.size() >= i) {
                    r0.handle(this.seqList.get(i - 1), strArr[i2]);
                } else if (this.seqList.size() <= 0 || !this.seqList.get(this.seqList.size() - 1).isCollection()) {
                    throw new InvalidCommandLineException(String.format("invalid command line argument - you've provided too many free-standing arguments: %s", strArr[i2]));
                } else {
                    r0.handle(this.seqList.get(this.seqList.size() - 1), strArr[i2]);
                }
            }
            i2++;
        }
        r0.finish();
        return construct;
    }

    private T construct() {
        try {
            Constructor<T> declaredConstructor = this.settingsDescriptor.getDeclaredConstructor(new Class[0]);
            declaredConstructor.setAccessible(true);
            return declaredConstructor.newInstance(new Object[0]);
        } catch (IllegalAccessException e) {
            throw new IllegalArgumentException("Huh?");
        } catch (InstantiationException e2) {
            throw new IllegalArgumentException(String.format("A CmdReader class must not be an interface or abstract: %s", this.settingsDescriptor));
        } catch (NoSuchMethodException e3) {
            throw new IllegalArgumentException(String.format("A CmdReader class must have a no-args constructor: %s", this.settingsDescriptor));
        } catch (InvocationTargetException e4) {
            throw new IllegalArgumentException("Exception occurred when constructing CmdReader class " + this.settingsDescriptor, e4.getCause());
        }
    }

    public static String squash(Collection<String> collection) {
        Iterator<String> it = collection.iterator();
        StringBuilder sb = new StringBuilder();
        while (it.hasNext()) {
            sb.append(it.next());
            if (it.hasNext()) {
                sb.append(' ');
            }
        }
        return sb.toString();
    }

    static /* synthetic */ List access$000(CmdReader cmdReader) {
        return cmdReader.items;
    }
}