/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package org.apache.commons.exec;

import java.io.File;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.StringTokenizer;

import org.apache.commons.exec.util.StringUtils;

/**
 * CommandLine objects help handling command lines specifying processes to execute. The class can be used to a command line by an application.
 */
public class CommandLine {

    /**
     * Encapsulates a command line argument.
     */
    static final class Argument {

        /**
         * Argument value.
         */
        private final String value;

        /**
         * Whether to quote arguments.
         */
        private final boolean handleQuoting;

        private Argument(final String value, final boolean handleQuoting) {
            this.value = value.trim();
            this.handleQuoting = handleQuoting;
        }

        private String getValue() {
            return value;
        }

        private boolean isHandleQuoting() {
            return handleQuoting;
        }
    }

    /**
     * Create a command line from a string.
     *
     * @param line the first element becomes the executable, the rest the arguments.
     * @return the parsed command line.
     * @throws IllegalArgumentException If line is null or all whitespace.
     */
    public static CommandLine parse(final String line) {
        return parse(line, null);
    }

    /**
     * Create a command line from a string.
     *
     * @param line            the first element becomes the executable, the rest the arguments.
     * @param substitutionMap the name/value pairs used for substitution.
     * @return the parsed command line.
     * @throws IllegalArgumentException If line is null or all whitespace.
     */
    public static CommandLine parse(final String line, final Map<String, ?> substitutionMap) {
        if (line == null) {
            throw new IllegalArgumentException("Command line cannot be null");
        }
        if (line.trim().isEmpty()) {
            throw new IllegalArgumentException("Command line cannot be empty");
        }
        final String[] tmp = translateCommandline(line);
        final CommandLine cl = new CommandLine(tmp[0]);
        cl.setSubstitutionMap(substitutionMap);
        for (int i = 1; i < tmp.length; i++) {
            cl.addArgument(tmp[i]);
        }
        return cl;
    }

    /**
     * Crack a command line.
     *
     * @param toProcess the command line to process.
     * @return the command line broken into strings. An empty or null toProcess parameter results in a zero sized array.
     */
    private static String[] translateCommandline(final String toProcess) {
        if (toProcess == null || toProcess.trim().isEmpty()) {
            // no command? no string
            return new String[0];
        }
        // parse with a simple finite state machine.
        final int normal = 0;
        final int inQuote = 1;
        final int inDoubleQuote = 2;
        int state = normal;
        final StringTokenizer tok = new StringTokenizer(toProcess, "\"\' ", true);
        final ArrayList<String> list = new ArrayList<>();
        StringBuilder current = new StringBuilder();
        boolean lastTokenHasBeenQuoted = false;
        while (tok.hasMoreTokens()) {
            final String nextTok = tok.nextToken();
            switch (state) {
            case inQuote:
                if ("\'".equals(nextTok)) {
                    lastTokenHasBeenQuoted = true;
                    state = normal;
                } else {
                    current.append(nextTok);
                }
                break;
            case inDoubleQuote:
                if ("\"".equals(nextTok)) {
                    lastTokenHasBeenQuoted = true;
                    state = normal;
                } else {
                    current.append(nextTok);
                }
                break;
            default:
                switch (nextTok) {
                case "\'":
                    state = inQuote;
                    break;
                case "\"":
                    state = inDoubleQuote;
                    break;
                case " ":
                    if (lastTokenHasBeenQuoted || current.length() != 0) {
                        list.add(current.toString());
                        current = new StringBuilder();
                    }
                    break;
                default:
                    current.append(nextTok);
                    break;
                }
                lastTokenHasBeenQuoted = false;
                break;
            }
        }
        if (lastTokenHasBeenQuoted || current.length() != 0) {
            list.add(current.toString());
        }
        if (state == inQuote || state == inDoubleQuote) {
            throw new IllegalArgumentException("Unbalanced quotes in " + toProcess);
        }
        final String[] args = new String[list.size()];
        return list.toArray(args);
    }

    /**
     * The arguments of the command.
     */
    private final List<Argument> arguments = new ArrayList<>();

    /**
     * The program to execute.
     */
    private final String executable;

    /**
     * A map of name value pairs used to expand command line arguments.
     */
    private Map<String, ?> substitutionMap; // This can contain values other than Strings.

    /**
     * Tests whether a file was used to set the executable.
     */
    private final boolean isFile;

    /**
     * Copy constructor.
     *
     * @param other the instance to copy.
     */
    public CommandLine(final CommandLine other) {
        this.executable = other.getExecutable();
        this.isFile = other.isFile();
        this.arguments.addAll(other.arguments);
        if (other.getSubstitutionMap() != null) {
            this.substitutionMap = new HashMap<>(other.getSubstitutionMap());
        }
    }

    /**
     * Constructs a command line without any arguments.
     *
     * @param executable the executable file.
     */
    public CommandLine(final File executable) {
        this.isFile = true;
        this.executable = toCleanExecutable(executable.getAbsolutePath());
    }

    /**
     * Constructs a command line without any arguments.
     *
     * @param executable the executable file.
     * @since 1.5.0
     */
    public CommandLine(final Path executable) {
        this.isFile = true;
        this.executable = toCleanExecutable(executable.toAbsolutePath().toString());
    }

    /**
     * Constructs a command line without any arguments.
     *
     * @param executable the executable.
     * @throws NullPointerException     on null input.
     * @throws IllegalArgumentException on empty input.
     */
    public CommandLine(final String executable) {
        this.isFile = false;
        this.executable = toCleanExecutable(executable);
    }

    /**
     * Add a single argument. Handles quoting.
     *
     * @param argument The argument to add.
     * @return The command line itself.
     * @throws IllegalArgumentException If argument contains both single and double quotes.
     */
    public CommandLine addArgument(final String argument) {
        return addArgument(argument, true);
    }

    /**
     * Add a single argument.
     *
     * @param argument      The argument to add.
     * @param handleQuoting Add the argument with/without handling quoting.
     * @return The command line itself.
     */
    public CommandLine addArgument(final String argument, final boolean handleQuoting) {
        if (argument == null) {
            return this;
        }
        // check if we can really quote the argument - if not throw an
        // IllegalArgumentException
        if (handleQuoting) {
            StringUtils.quoteArgument(argument);
        }
        arguments.add(new Argument(argument, handleQuoting));
        return this;
    }

    /**
     * Add multiple arguments. Handles parsing of quotes and whitespace. Please note that the parsing can have undesired side-effects therefore it is
     * recommended to build the command line incrementally.
     *
     * @param addArguments A string containing multiple arguments.
     * @return The command line itself.
     */
    public CommandLine addArguments(final String addArguments) {
        return addArguments(addArguments, true);
    }

    /**
     * Add multiple arguments. Handles parsing of quotes and whitespace. Please note that the parsing can have undesired side-effects therefore it is
     * recommended to build the command line incrementally.
     *
     * @param addArguments  A string containing multiple arguments.
     * @param handleQuoting Add the argument with/without handling quoting.
     * @return The command line itself.
     */
    public CommandLine addArguments(final String addArguments, final boolean handleQuoting) {
        if (addArguments != null) {
            final String[] argumentsArray = translateCommandline(addArguments);
            addArguments(argumentsArray, handleQuoting);
        }
        return this;
    }

    /**
     * Add multiple arguments. Handles parsing of quotes and whitespace.
     *
     * @param addArguments An array of arguments.
     * @return The command line itself.
     */
    public CommandLine addArguments(final String[] addArguments) {
        return addArguments(addArguments, true);
    }

    /**
     * Add multiple arguments.
     *
     * @param addArguments  An array of arguments.
     * @param handleQuoting Add the argument with/without handling quoting.
     * @return The command line itself.
     */
    public CommandLine addArguments(final String[] addArguments, final boolean handleQuoting) {
        if (addArguments != null) {
            for (final String addArgument : addArguments) {
                addArgument(addArgument, handleQuoting);
            }
        }
        return this;
    }

    /**
     * Expand variables in a command line argument.
     *
     * @param argument the argument.
     * @return the expanded string.
     */
    private String expandArgument(final String argument) {
        final StringBuffer stringBuffer = StringUtils.stringSubstitution(argument, getSubstitutionMap(), true);
        return stringBuffer.toString();
    }

    /**
     * Gets the expanded and quoted command line arguments.
     *
     * @return The quoted arguments.
     */
    public String[] getArguments() {
        Argument currArgument;
        String expandedArgument;
        final String[] result = new String[arguments.size()];
        for (int i = 0; i < result.length; i++) {
            currArgument = arguments.get(i);
            expandedArgument = expandArgument(currArgument.getValue());
            result[i] = currArgument.isHandleQuoting() ? StringUtils.quoteArgument(expandedArgument) : expandedArgument;
        }
        return result;
    }

    /**
     * Gets the executable.
     *
     * @return The executable.
     */
    public String getExecutable() {
        // Expand the executable and replace '/' and '\\' with the platform
        // specific file separator char. This is safe here since we know
        // that this is a platform specific command.
        return StringUtils.fixFileSeparatorChar(expandArgument(executable));
    }

    /**
     * Gets the substitution map.
     *
     * @return the substitution map.
     */
    public Map<String, ?> getSubstitutionMap() {
        return substitutionMap;
    }

    /**
     * Tests whether a file was used to set the executable.
     *
     * @return true whether a file was used for setting the executable.
     */
    public boolean isFile() {
        return isFile;
    }

    /**
     * Sets the substitutionMap to expand variables in the command line.
     *
     * @param substitutionMap the map
     */
    public void setSubstitutionMap(final Map<String, ?> substitutionMap) {
        this.substitutionMap = substitutionMap;
    }

    /**
     * Cleans the executable string. The argument is trimmed and '/' and '\\' are replaced with the platform specific file separator char
     *
     * @param dirtyExecutable the executable.
     * @return the platform-specific executable string.
     * @throws NullPointerException     on null input.
     * @throws IllegalArgumentException on empty input.
     */
    private String toCleanExecutable(final String dirtyExecutable) {
        Objects.requireNonNull(dirtyExecutable, "dirtyExecutable");
        if (dirtyExecutable.trim().isEmpty()) {
            throw new IllegalArgumentException("Executable cannot be empty");
        }
        return StringUtils.fixFileSeparatorChar(dirtyExecutable);
    }

    /**
     * Stringify operator returns the command line as a string.
     * Parameters are correctly quoted when containing a space or left untouched if they are already
     * quoted.
     *
     * @return the command line as single string.
     */
    @Override
    public String toString() {
        return "[" + String.join(", ", toStrings()) + "]";
    }

    /**
     * Converts the command line as an array of strings.
     *
     * @return The command line as a string array.
     */
    public String[] toStrings() {
        final String[] result = new String[arguments.size() + 1];
        result[0] = getExecutable();
        System.arraycopy(getArguments(), 0, result, 1, result.length - 1);
        return result;
    }
}