// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Microsoft.Arcade.Common;

public static class ArgumentEscaper
{
    /// <summary>
    /// Escapes and quote arguments that need it (contain a space, a quote...).
    /// </summary>
    public static string EscapeAndConcatenateArgArrayForProcessStart(IEnumerable<string> args)
    {
        return string.Join(" ", args.Select(EscapeArg));
    }

    /// <summary>
    /// Escapes and quote arguments that need it.
    /// 
    /// This prefixes every character with the '^' character to force cmd to
    /// interpret the argument string literally. An alternative option would 
    /// be to do this only for cmd metacharacters.
    /// 
    /// See here for more info:
    /// http://blogs.msdn.com/b/twistylittlepassagesallalike/archive/2011/04/23/everyone-quotes-arguments-the-wrong-way.aspx
    /// </summary>
    public static string EscapeAndConcatenateArgArrayForCmdProcessStart(IEnumerable<string> args)
    {
        return string.Join(" ", args.Select(EscapeArgForCmd));
    }

    private static string EscapeArg(string argument)
    {
        var sb = new StringBuilder();

        // Don't quote already quoted strings
        bool quoted = IsQuoted(argument);
        var shouldQuote = !quoted && ShouldSurroundWithQuotes(argument);
        if (shouldQuote || quoted)
        {
            sb.Append("\"");
        }

        for (int i = 0; i < argument.Length; ++i)
        {
            if (quoted && (i == 0 || i == argument.Length - 1))
            {
                continue;
            }

            var backslashCount = 0;

            // Consume All Backslashes
            while (i < argument.Length && argument[i] == '\\')
            {
                backslashCount++;
                i++;
            }

            // Escape any backslashes at the end of the arg
            // This ensures the outside quote is interpreted as
            // an argument delimiter
            if (i == argument.Length)
            {
                sb.Append('\\', 2 * backslashCount);
            }

            // Escape any preceding backslashes and the quote
            else if (argument[i] == '"')
            {
                sb.Append('\\', (2 * backslashCount) + 1);
                sb.Append('"');
            }

            // Output any consumed backslashes and the character
            else
            {
                sb.Append('\\', backslashCount);
                sb.Append(argument[i]);
            }
        }

        if (shouldQuote || quoted)
        {
            sb.Append("\"");
        }

        return sb.ToString();
    }

    private static string EscapeArgForCmd(string argument)
    {
        var sb = new StringBuilder();

        var quoted = IsQuoted(argument);
        var shouldQuote = !quoted && ShouldSurroundWithQuotes(argument);

        if (shouldQuote)
        {
            sb.Append("^\"");
        }

        foreach (var character in argument)
        {
            if (character == '"')
            {
                sb.Append('^');
                sb.Append('"');
                sb.Append('^');
                sb.Append(character);
            }
            else
            {
                sb.Append("^");
                sb.Append(character);
            }
        }

        if (shouldQuote)
        {
            sb.Append("^\"");
        }

        return sb.ToString();
    }

    private static bool ShouldSurroundWithQuotes(string argument)
    {
        // Only quote if whitespace exists in the string
        return argument.Contains(' ') || argument.Contains('\t') || argument.Contains('\n') || argument.Contains('"');
    }


    private static bool IsQuoted(string argument)
    {
        return argument.Length > 1 && (argument[0] == '\"' || argument[argument.Length - 1] == '\"');
    }
}