using System.Collections;
using System.Collections.Generic;
using System.Management.Automation.Language;

namespace System.Management.Automation
{
    public abstract class ArgumentCompleter : IArgumentCompleter
    {
        // Readonly properties which are visible in derived classes
        protected string CommandName { get; private set; }
        protected string ParameterName { get; private set; }
        protected string WordToComplete { get; private set; }
        protected CommandAst CommandAst { get; private set; }
        protected IDictionary FakeBoundParameters { get; private set; }
        
        // User can optionally override these
        protected virtual bool ShouldComplete { get; set; } = true;
        protected virtual CompletionResultType CompletionResultType { get; set; } = CompletionResultType.Text;
        protected virtual Func<string, string> ToolTipMapping { get; set; }
        protected virtual Func<string, string> ListItemTextMapping { get; set; }
        protected virtual bool EscapeGlobbingPath { get; set; }

        // User must implement this
        protected abstract IEnumerable<string> GetPossibleCompletionValues();

        // Default CompleteArgument implementation
        // Cannot be overriden since it sets properties on base class and calls GetMatchingResults which can be overriden
        public IEnumerable<CompletionResult> CompleteArgument(
            string commandName,
            string parameterName,
            string wordToComplete,
            CommandAst commandAst,
            IDictionary fakeBoundParameters)
        {
            CommandName = commandName;
            ParameterName = parameterName;
            WordToComplete = wordToComplete;
            CommandAst = commandAst;
            FakeBoundParameters = fakeBoundParameters;
            return ShouldComplete ? GetMatchingResults(wordToComplete) : [];
        }

        // Default matching with quote handling implementation encapsulated in base class
        // Can be overriden if default behaviour needs to change
        protected virtual IEnumerable<CompletionResult> GetMatchingResults(string wordToComplete)
        {
            string quote = CompletionCompleters.HandleDoubleAndSingleQuote(ref wordToComplete);

            foreach (string value in GetPossibleCompletionValues())
            {
                if (value.StartsWith(wordToComplete, StringComparison.OrdinalIgnoreCase))
                {
                    string completionText = QuoteCompletionText(completionText: value, quote, EscapeGlobbingPath);

                    string toolTip = ToolTipMapping?.Invoke(value) ?? value;
                    string listItemText = ListItemTextMapping?.Invoke(value) ?? value;

                    yield return new CompletionResult(completionText, listItemText, CompletionResultType, toolTip);
                }
            }
        }

        // Quote escaping which is probably fine to start out with but can be expanded later
        private static string QuoteCompletionText(string completionText, string quote, bool escapeGlobbingPath)
        {
            if (CompletionCompleters.CompletionRequiresQuotes(completionText, escapeGlobbingPath))
            {
                string quoteInUse = string.IsNullOrEmpty(quote) ? "'" : quote;

                completionText = quoteInUse == "'"
                    ? completionText.Replace("'", "''")
                    : completionText.Replace("`", "``").Replace("$", "`$");

                if (escapeGlobbingPath)
                {
                    completionText = quoteInUse == "'"
                        ? completionText.Replace("[", "`[").Replace("]", "`]")
                        : completionText.Replace("[", "``[").Replace("]", "``]");
                }

                return quoteInUse + completionText + quoteInUse;
            }

            return quote + completionText + quote;
        }
    }
}

    public interface IArgumentCompleter
    {
        /// <summary>
        /// Implementations of this function are called by PowerShell to complete arguments.
        /// </summary>
        /// <param name="commandName">The name of the command that needs argument completion.</param>
        /// <param name="parameterName">The name of the parameter that needs argument completion.</param>
        /// <param name="wordToComplete">The (possibly empty) word being completed.</param>
        /// <param name="commandAst">The command ast in case it is needed for completion.</param>
        /// <param name="fakeBoundParameters">
        /// This parameter is similar to $PSBoundParameters, except that sometimes PowerShell cannot or
        /// will not attempt to evaluate an argument, in which case you may need to use <paramref name="commandAst"/>.
        /// </param>
        /// <returns>
        /// A collection of completion results, most like with <see cref="CompletionResult.ResultType"/> set to
        /// <see cref="CompletionResultType.ParameterValue"/>.
        /// </returns>
        IEnumerable<CompletionResult> CompleteArgument(
            string commandName,
            string parameterName,
            string wordToComplete,
            CommandAst commandAst,
            IDictionary fakeBoundParameters)
        {
            CommandName = commandName;
            ParameterName = parameterName;
            WordToComplete = wordToComplete;
            CommandAst = commandAst;
            FakeBoundParameters = fakeBoundParameters;
            return ShouldComplete ? GetMatchingResults(wordToComplete) : [];
        }

        /// <summary>
        /// Gets the name of the command that needs argument completion.
        /// </summary>
        protected static string? CommandName { get; private set; }

        /// <summary>
        /// Gets the name of the parameter that needs argument completion.
        /// </summary>
        protected static string? ParameterName { get; private set; }

        /// <summary>
        /// Gets the word being completed.
        /// </summary>
        protected static string? WordToComplete { get; private set; }

        /// <summary>
        /// Gets the command abstract syntax tree (AST).
        /// </summary>
        protected static CommandAst? CommandAst { get; private set; }

        /// <summary>
        /// Gets the fake bound parameters similar to $PSBoundParameters.
        /// </summary>
        protected static IDictionary? FakeBoundParameters { get; private set; }

        /// <summary>
        /// Gets value indicating whether to perform completion.
        /// </summary>
        protected bool ShouldComplete => true;

        /// <summary>
        /// Gets the type of the completion result.
        /// </summary>
        protected CompletionResultType CompletionResultType => CompletionResultType.Text;

        /// <summary>
        /// Gets the mapping function for tooltips.
        /// </summary>
        protected Func<string, string>? ToolTipMapping => null;

        /// <summary>
        /// Gets the mapping function for list item texts.
        /// </summary>
        protected Func<string, string>? ListItemTextMapping => null;

        /// <summary>
        /// Gets value indicating whether to escape globbing paths.
        /// </summary>
        protected bool EscapeGlobbingPath => false;

        /// <summary>
        /// Gets the possible completion values.
        /// </summary>
        protected IEnumerable<string> PossibleCompletionValues => [];

        /// <summary>
        /// Matches the possible completion values against the word to complete.
        /// </summary>
        /// <param name="wordToComplete">The word to complete, which is used as a pattern for matching possible values.</param>
        /// <returns>An <see cref="IEnumerable{CompletionResult}"/> containing the matching completion results.</returns>
        /// <remarks>This method handles different variations of completions, including considerations for quotes and escaping globbing paths.</remarks>
        protected IEnumerable<CompletionResult> GetMatchingResults(string wordToComplete)
        {
            string quote = CompletionCompleters.HandleDoubleAndSingleQuote(ref wordToComplete);

            foreach (string value in PossibleCompletionValues)
            {
                if (value.StartsWith(wordToComplete, StringComparison.OrdinalIgnoreCase))
                {
                    string completionText = QuoteCompletionText(completionText: value, quote, EscapeGlobbingPath);

                    string toolTip = ToolTipMapping?.Invoke(value) ?? value;
                    string listItemText = ListItemTextMapping?.Invoke(value) ?? value;

                    yield return new CompletionResult(completionText, listItemText, CompletionResultType, toolTip);
                }
            }
        }

        /// <summary>
        /// Quotes the completion text.
        /// </summary>
        /// <param name="completionText">The text to complete.</param>
        /// <param name="quote">The quote to use.</param>
        /// <param name="escapeGlobbingPath">True if the globbing path needs to be escaped; otherwise, false.</param>
        /// <returns>
        /// A quoted string if quoting is necessary.
        /// </returns>
        private static string QuoteCompletionText(string completionText, string quote, bool escapeGlobbingPath)
        {
            if (CompletionCompleters.CompletionRequiresQuotes(completionText, escapeGlobbingPath))
            {
                string quoteInUse = string.IsNullOrEmpty(quote) ? "'" : quote;

                completionText = quoteInUse == "'"
                    ? completionText.Replace("'", "''")
                    : completionText.Replace("`", "``").Replace("$", "`$");

                if (escapeGlobbingPath)
                {
                    completionText = quoteInUse == "'"
                        ? completionText.Replace("[", "`[").Replace("]", "`]")
                        : completionText.Replace("[", "``[").Replace("]", "``]");
                }

                return quoteInUse + completionText + quoteInUse;
            }

            return quote + completionText + quote;
        }

    }