package net.knarcraft.ffmpegconverter.utility;

import net.knarcraft.ffmpegconverter.parser.ConverterArgument;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * A class to help with command parsing
 */
public final class Parser {

    private Parser() {

    }

    /**
     * This function parses the input to understandable converter instructions
     *
     * @param input          <p>The input string to parse.</p>
     * @param validArguments <p>All arguments which are considered valid.</p>
     * @return <p>A map with all parsed arguments.</p>
     */
    static Map<String, String> parse(String input, List<ConverterArgument> validArguments) {
        return parse(tokenize(input), validArguments);
    }

    /**
     * This function parses command inputs into understandable converter instructions
     *
     * @param tokens         <p>A list of tokens containing all arguments</p>
     * @param validArguments <p>A list of arguments which are considered valid.</p>
     * @return <p>A map with all parsed arguments.</p>
     */
    private static Map<String, String> parse(List<String> tokens, List<ConverterArgument> validArguments) {
        Map<String, String> parsedArguments = new HashMap<>();

        while (!tokens.isEmpty()) {
            parseArgument(tokens, validArguments, parsedArguments);
        }
        return parsedArguments;
    }

    /**
     * Parses the first found token as an argument
     *
     * @param tokens             <p>The tokens to parse.</p>
     * @param converterArguments <p>A list of all the valid arguments in existence.</p>
     * @param parsedArguments    <p>The map to store the parsed argument to.</p>
     */
    private static void parseArgument(List<String> tokens, List<ConverterArgument> converterArguments, Map<String, String> parsedArguments) {
        String currentToken = tokens.remove(0);
        List<ConverterArgument> foundArguments;

        if (currentToken.startsWith("--")) {
            String argumentName = currentToken.substring(2);
            foundArguments = ListUtil.getMatching(converterArguments, (item) -> item.getName().equals(argumentName));
        } else if (currentToken.startsWith("-")) {
            char argumentShorthand = currentToken.substring(1).charAt(0);
            foundArguments = ListUtil.getMatching(converterArguments, (item) -> item.getShorthand() == argumentShorthand);
        } else {
            throw new IllegalArgumentException("Unexpected value when not given an argument.");
        }

        if (foundArguments.isEmpty()) {
            throw new IllegalArgumentException(String.format("Invalid argument %s encountered.", currentToken));
        }

        ConverterArgument foundArgument = foundArguments.get(0);
        storeArgumentValue(tokens, foundArgument, parsedArguments);
    }

    /**
     * Stores the value of a found argument to parsed arguments
     *
     * @param tokens          <p>The token list to parse.</p>
     * @param foundArgument   <p>The found argument to store.</p>
     * @param parsedArguments <p>The map to store parsed arguments to.</p>
     */
    private static void storeArgumentValue(List<String> tokens, ConverterArgument foundArgument, Map<String, String> parsedArguments) {
        String argumentValue;
        if (tokens.isEmpty()) {
            argumentValue = "";
        } else {
            argumentValue = tokens.get(0);
        }
        boolean valueIsArgument = argumentValue.startsWith("-");

        if (valueIsArgument) {
            if (foundArgument.isValueRequired()) {
                throw new IllegalArgumentException(String.format("Argument %s requires a value, but no value was given.", foundArgument.getName()));
            } else {
                parsedArguments.put(foundArgument.getName(), "true");
            }
        } else {
            String value;
            if (tokens.isEmpty()) {
                value = "";
            } else {
                value = tokens.remove(0);
            }
            if (!foundArgument.testArgumentValue(value)) {
                throw new IllegalArgumentException(String.format("Invalid value %s for argument %s.", value, foundArgument.getName()));
            }
            parsedArguments.put(foundArgument.getName(), value);
        }
    }

    /**
     * Tokenizes a string
     *
     * @param input <p>A string.</p>
     * @return <p>A list of tokens.</p>
     */
    public static List<String> tokenize(String input) {
        List<String> tokens = new ArrayList<>();
        boolean startedQuote = false;
        StringBuilder currentToken = new StringBuilder();
        for (int index = 0; index < input.length(); index++) {
            char character = input.charAt(index);
            switch (character) {
                case ' ':
                    if (tokenizeSpace(startedQuote, currentToken, tokens)) {
                        currentToken = new StringBuilder();
                    }
                    break;
                case '"':
                    if (startedQuote) {
                        //This quote signifies the end of the argument
                        if (isNotEmpty(currentToken)) {
                            tokens.add(currentToken.toString());
                            currentToken = new StringBuilder();
                        }
                        startedQuote = false;
                    } else {
                        //This quote signifies the start of the argument
                        startedQuote = true;
                        currentToken = new StringBuilder();
                    }
                    break;
                default:
                    tokenizeNormalCharacter(currentToken, character, input.length(), index, tokens);
                    break;
            }
        }
        return tokens;
    }

    /**
     * Adds a normal character to the token. Adds the current token to tokens if at the end of the input
     *
     * @param currentToken <p>The string builder containing the current token.</p>
     * @param character    <p>The character found in the input.</p>
     * @param inputLength  <p>The length of the given input</p>
     * @param index        <p>The index of the read character.</p>
     * @param tokens       <p>The list of processed tokens.</p>
     */
    private static void tokenizeNormalCharacter(StringBuilder currentToken, char character, int inputLength, int index,
                                                List<String> tokens) {
        currentToken.append(character);
        if (index == inputLength - 1) {
            tokens.add(currentToken.toString());
        }
    }

    /**
     * Tokenizes a space character
     *
     * @param startedQuote <p>Whether this space is inside a pair of quotes.</p>
     * @param currentToken <p>The string builder containing the current token.</p>
     * @param tokens       <p>The list of processed tokens.</p>
     * @return <p>True if the token is finished.</p>
     */
    private static boolean tokenizeSpace(boolean startedQuote, StringBuilder currentToken, List<String> tokens) {
        if (!startedQuote) {
            //If not inside "", a space marks the end of a parameter
            if (isNotEmpty(currentToken)) {
                tokens.add(currentToken.toString());
            }
            return true;
        } else {
            currentToken.append(' ');
            return false;
        }
    }

    /**
     * Checks whether a string builder is empty
     *
     * @param builder <p>The string builder to check.</p>
     * @return <p>True if the string builder is non empty.</p>
     */
    private static boolean isNotEmpty(StringBuilder builder) {
        return !builder.toString().trim().isEmpty();
    }

}