//-----------------------------------------------------------------------
// <copyright file="ShowCommandHelper.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
// <summary>
// Implements ShowCommandHelper
// </summary>
//-----------------------------------------------------------------------

namespace Microsoft.PowerShell.Commands.ShowCommandInternal
{
    using System;
    using System.Collections.Generic;
    using System.Collections.ObjectModel;
    using System.Diagnostics.CodeAnalysis;
    using System.Globalization;
    using System.Management.Automation;
    using System.Reflection;
    using System.Threading;
    using System.Windows;
    using System.Windows.Controls;
    using System.Windows.Threading;
    using Microsoft.Management.UI;
    using Microsoft.Management.UI.Internal;
    using Microsoft.Management.UI.Internal.ShowCommand;
    using Microsoft.PowerShell.Commands.ShowCommandExtension;

    /// <summary>
    /// Implements the WPF window part of the show-command cmdlet
    /// </summary>
    internal class ShowCommandHelper : IDisposable
    {
        #region fields

        internal const string CommandTypeSegment = " -CommandType Cmdlet, Function, Script, ExternalScript, Workflow";

        /// <summary>
        /// Method that will return the dialog from ShowAllModulesWindow or ShowCommandWindow.
        /// This is necessary because the PlainInvokeAndShowDialog thread starter cannot receive parameters
        /// </summary>
        private DispatcherOperationCallback methodThatReturnsDialog;

        /// <summary>
        /// Event set when the window is closed
        /// </summary>
        private AutoResetEvent windowClosed = new AutoResetEvent(false);

        /// <summary>
        /// Event set when help is needed
        /// </summary>
        private AutoResetEvent helpNeeded = new AutoResetEvent(false);

        /// <summary>
        /// Event set when it is necessary to import a module
        /// </summary>
        private AutoResetEvent importModuleNeeded = new AutoResetEvent(false);

        /// <summary>
        /// Event set when the window is loaded
        /// </summary>
        private AutoResetEvent windowLoaded = new AutoResetEvent(false);

        /// <summary>
        /// String with the command that needs help set when helpNeeded is set
        /// </summary>
        private string commandNeedingHelp;

        /// <summary>
        /// String with the command name that needs to import a module
        /// </summary>
        private string commandNeedingImportModule;

        /// <summary>
        /// String with the module name that needs to be imported
        /// </summary>
        private string parentModuleNeedingImportModule;

        /// <summary>
        /// String with the selected module at the time a module needs to be imported
        /// </summary>
        private string selectedModuleNeedingImportModule;

        /// <summary>
        /// Keeps the window for the implementation of CloseWindow
        /// </summary>
        private Window window;

        /// <summary>
        /// host window, if any
        /// </summary>
        private Window hostWindow;

        /// <summary>
        /// ViewModel when showing all modules
        /// </summary>
        private AllModulesViewModel allModulesViewModel;

        /// <summary>
        /// ViewModel when showing a single command
        /// </summary>
        private CommandViewModel commandViewModel;

        /// <summary>
        /// true when the window is closed with cancel
        /// </summary>
        private bool dialogCanceled = true;
        #endregion fields

        #region GetSerializedCommand script

        private const string ScriptGetSerializedCommand = @"
Function PSGetSerializedShowCommandInfo
{
    Function GetParameterType
    {
        param (
            [Type] $parameterType)

        $returnParameterType = new-object PSObject
        $returnParameterType | Add-Member -MemberType NoteProperty -Name ""FullName"" -Value $parameterType.FullName
        $returnParameterType | Add-Member -MemberType NoteProperty -Name ""IsEnum"" -Value $parameterType.IsEnum
        $returnParameterType | Add-Member -MemberType NoteProperty -Name ""IsArray"" -Value $parameterType.IsArray

        if ($parameterType.IsEnum)
        {
            $enumValues = [System.Enum]::GetValues($parameterType)
        }
        else
        {
            $enumValues = [string[]] @()
        }
        $returnParameterType | Add-Member -MemberType NoteProperty -Name ""EnumValues"" -Value $enumValues

        if ($parameterType.IsArray)
        {
            $hasFlagAttribute = ($parameterType.GetCustomAttributes([System.FlagsAttribute], $true).Length -gt 0)

            # Recurse into array elements.
            $elementType = GetParameterType($parameterType.GetElementType())
        }
        else
        {
            $hasFlagAttribute = $false
            $elementType = $null
        }
        $returnParameterType | Add-Member -MemberType NoteProperty -Name ""HasFlagAttribute"" -Value $hasFlagAttribute
        $returnParameterType | Add-Member -MemberType NoteProperty -Name ""ElementType"" -Value $elementType


        if (!($parameterType.IsEnum) -and !($parameterType.IsArray))
        {
            $implementsDictionary = [System.Collections.IDictionary].IsAssignableFrom($parameterType)
        }
        else
        {
            $implementsDictionary = $false
        }
        $returnParameterType | Add-Member -MemberType NoteProperty -Name ""ImplementsDictionary"" -Value $implementsDictionary

        return $returnParameterType
    }

    Function GetParameterInfo
    {
        param (
            $parameters)

        [PSObject[]] $parameterInfos = @()

        foreach ($parameter in $parameters)
        {
            $parameterInfo = new-object PSObject
            $parameterInfo | Add-Member -MemberType NoteProperty -Name ""Name"" -Value $parameter.Name
            $parameterInfo | Add-Member -MemberType NoteProperty -Name ""IsMandatory"" -Value $parameter.IsMandatory
            $parameterInfo | Add-Member -MemberType NoteProperty -Name ""ValueFromPipeline"" -Value $parameter.ValueFromPipeline
            $parameterInfo | Add-Member -MemberType NoteProperty -Name ""Position"" -Value $parameter.Position
            $parameterInfo | Add-Member -MemberType NoteProperty -Name ""ParameterType"" -Value (GetParameterType($parameter.ParameterType))

            $hasParameterSet = $false
            [string[]] $validValues = @()
            if ($PSVersionTable.PSVersion.Major -gt 2)
            {
                $validateSetAttributes = $parameter.Attributes | Where {
                    [ValidateSet].IsAssignableFrom($_.GetType())
                }
                if (($validateSetAttributes -ne $null) -and ($validateSetAttributes.Count -gt 0))
                {
                    $hasParameterSet = $true
                    $validValues = $validateSetAttributes[0].ValidValues
                }
            }
            $parameterInfo | Add-Member -MemberType NoteProperty -Name ""HasParameterSet"" -Value $hasParameterSet
            $parameterInfo | Add-Member -MemberType NoteProperty -Name ""ValidParamSetValues"" -Value $validValues

            $parameterInfos += $parameterInfo
        }

        return (,$parameterInfos)
    }

    Function GetParameterSets
    {
        param (
            [System.Management.Automation.CommandInfo] $cmdInfo
        )

        $parameterSets = $null
        try
        {
            $parameterSets = $cmdInfo.ParameterSets
        }
        catch [System.InvalidOperationException] { }
        catch [System.Management.Automation.PSNotSupportedException] { }
        catch [System.Management.Automation.PSNotImplementedException] { }

        if (($parameterSets -eq $null) -or ($parameterSets.Count -eq 0))
        {
            return (,@())
        }

        [PSObject[]] $returnParameterSets = @()

        foreach ($parameterSet in $parameterSets)
        {
            $parameterSetInfo = new-object PSObject
            $parameterSetInfo | Add-Member -MemberType NoteProperty -Name ""Name"" -Value $parameterSet.Name
            $parameterSetInfo | Add-Member -MemberType NoteProperty -Name ""IsDefault"" -Value $parameterSet.IsDefault
            $parameterSetInfo | Add-Member -MemberType NoteProperty -Name ""Parameters"" -Value (GetParameterInfo($parameterSet.Parameters))

            $returnParameterSets += $parameterSetInfo
        }

        return (,$returnParameterSets)
    }

    Function GetModuleInfo
    {
        param (
            [System.Management.Automation.CommandInfo] $cmdInfo
        )

        if ($cmdInfo.ModuleName -ne $null)
        {
            $moduleName = $cmdInfo.ModuleName
        }
        else
        {
            $moduleName = """"
        }

        $moduleInfo = new-object PSObject
        $moduleInfo | Add-Member -MemberType NoteProperty -Name ""Name"" -Value $moduleName

        return $moduleInfo
    }

    Function ConvertToShowCommandInfo
    {
        param (
            [System.Management.Automation.CommandInfo] $cmdInfo
        )

        $showCommandInfo = new-object PSObject
        $showCommandInfo | Add-Member -MemberType NoteProperty -Name ""Name"" -Value $cmdInfo.Name
        $showCommandInfo | Add-Member -MemberType NoteProperty -Name ""ModuleName"" -Value $cmdInfo.ModuleName
        $showCommandInfo | Add-Member -MemberType NoteProperty -Name ""Module"" -Value (GetModuleInfo($cmdInfo))
        $showCommandInfo | Add-Member -MemberType NoteProperty -Name ""CommandType"" -Value $cmdInfo.CommandType
        $showCommandInfo | Add-Member -MemberType NoteProperty -Name ""Definition"" -Value $cmdInfo.Definition
        $showCommandInfo | Add-Member -MemberType NoteProperty -Name ""ParameterSets"" -Value (GetParameterSets($cmdInfo))

        return $showCommandInfo
    }

    $commandList = @(""Cmdlet"", ""Function"", ""Script"", ""ExternalScript"")
    if ($PSVersionTable.PSVersion.Major -gt 2)
    {
        $commandList += ""Workflow""
    }

    foreach ($command in @(Get-Command -CommandType $commandList))
    {
        Write-Output (ConvertToShowCommandInfo($command))
    }
}";

        #endregion

        #region constructor and destructor
        /// <summary>
        /// Prevents a default instance of the ShowCommandHelper class from being created
        /// </summary>
        private ShowCommandHelper()
        {
        }

        /// <summary>
        /// Finalizes an instance of the ShowCommandHelper class
        /// </summary>
        ~ShowCommandHelper()
        {
            this.Dispose(false);
        }
        #endregion constructor and destructor

        #region properties called using reflection
        /// <summary>
        /// Gets the Screen Width
        /// </summary>
        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Called using reflection")]
        private static double ScreenWidth
        {
            get
            {
                return System.Windows.SystemParameters.PrimaryScreenWidth;
            }
        }

        /// <summary>
        /// Gets the Screen Height
        /// </summary>
        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Called using reflection")]
        private static double ScreenHeight
        {
            get
            {
                return System.Windows.SystemParameters.PrimaryScreenHeight;
            }
        }

        /// <summary>
        /// Gets the event set when the show-command window is closed
        /// </summary>
        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Called using reflection")]
        private AutoResetEvent WindowClosed
        {
            get
            {
                return this.windowClosed;
            }
        }

        /// <summary>
        /// Gets the event set when help is needed for a command
        /// </summary>
        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Called using reflection")]
        private AutoResetEvent HelpNeeded
        {
            get
            {
                return this.helpNeeded;
            }
        }

        /// <summary>
        /// Gets the event set when it is necessary to import a module
        /// </summary>
        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Called using reflection")]
        private AutoResetEvent ImportModuleNeeded
        {
            get
            {
                return this.importModuleNeeded;
            }
        }

        /// <summary>
        /// Gets the event set when the window is loaded
        /// </summary>
        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Called using reflection")]
        private AutoResetEvent WindowLoaded
        {
            get
            {
                return this.windowLoaded;
            }
        }

        /// <summary>
        /// Gets the command needing help when HelpNeeded is set
        /// </summary>
        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Called using reflection")]
        private string CommandNeedingHelp
        {
            get
            {
                return this.commandNeedingHelp;
            }
        }

        /// <summary>
        /// Gets the module we want to import
        /// </summary>
        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Called using reflection")]
        private string ParentModuleNeedingImportModule
        {
            get
            {
                return this.parentModuleNeedingImportModule;
            }
        }

        /// <summary>
        /// Gets a value indicating whether there is a host window
        /// </summary>
        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Called using reflection")]
        private bool HasHostWindow
        {
            get
            {
                return this.hostWindow != null;
            }
        }
        #endregion properties called using reflection

        #region public Dispose
        /// <summary>
        /// Dispose method in IDisposable
        /// </summary>
        public void Dispose()
        {
            this.Dispose(true);
            GC.SuppressFinalize(this);
        }
        #endregion public Dispose

        #region internal static methods called using reflection from show-command and directly from ISE
        /// <summary>
        /// Sets the text in the clipboard
        /// </summary>
        /// <param name="text">text to set the clipboard to</param>
        internal static void SetClipboardText(string text)
        {
            try
            {
                Clipboard.SetText(text);
            }
            catch (System.Runtime.InteropServices.COMException)
            {
                // This is the recommended way to set clipboard text
                System.Threading.Thread.Sleep(0);
                try
                {
                    Clipboard.SetText(text);
                }
                catch (System.Runtime.InteropServices.COMException)
                {
                }
            }
        }

        /// <summary>
        /// Gets the command to be run to get commands and imported modules
        /// </summary>
        /// <param name="isRemoteRunspace">Boolean flag determining whether Show-Command is queried in the local or remote runspace scenario </param>
        /// <param name="isFirstChance">Boolean flag to indicate that it is the second attempt to query Show-Command data </param>
        /// <returns>the command to be run to get commands and imported modules</returns>
        internal static string GetShowAllModulesCommand(bool isRemoteRunspace = false, bool isFirstChance = true)
        {
            string scriptBase;

            if (isRemoteRunspace)
            {
                if (isFirstChance)
                {
                    // Return command to run.
                    scriptBase = "@(Get-Command " + ShowCommandHelper.CommandTypeSegment + @" -ShowCommandInfo)";
                }
                else
                {
                    // Return script to run.
                    scriptBase = GetSerializedCommandScript();
                }
            }
            else
            {
                scriptBase = "@(Get-Command " + ShowCommandHelper.CommandTypeSegment + ")";
            }


            scriptBase += ShowCommandHelper.GetGetModuleSuffix();
            return scriptBase;
        }

        /// <summary>
        /// Retrieves the script for Get-SerializedCommand from local machine
        /// </summary>
        /// <returns>String representation of the script for Get-SerializedCommand</returns>
        private static string GetSerializedCommandScript()
        {
            return string.Format(CultureInfo.InvariantCulture, "@({0};{1};{2})",
                ScriptGetSerializedCommand,
                @"PSGetSerializedShowCommandInfo",
                @"Remove-Item -Path 'function:\PSGetSerializedShowCommandInfo' -Force");
        }


        /// <summary>
        /// Gets the command to be run to in order to import a module and refresh the command data
        /// </summary>
        /// <param name="module">module we want to import</param>
        /// <param name="isRemoteRunspace">Boolean flag determining whether Show-Command is queried in the local or remote runspace scenario </param>
        /// <param name="isFirstChance">Boolean flag to indicate that it is the second attempt to query Show-Command data </param>
        /// <returns>the command to be run to in order to import a module and refresh the command data</returns>
        internal static string GetImportModuleCommand(string module, bool isRemoteRunspace = false, bool isFirstChance = true)
        {
            string scriptBase = "Import-Module " + ShowCommandHelper.SingleQuote(module);

            if (isRemoteRunspace)
            {
                if (isFirstChance)
                {
                    scriptBase += ";@(Get-Command " + ShowCommandHelper.CommandTypeSegment + @" -ShowCommandInfo )";
                }
                else
                {
                    scriptBase += GetSerializedCommandScript();
                }
            }
            else
            {
                scriptBase += ";@(Get-Command " + ShowCommandHelper.CommandTypeSegment + ")";
            }

            scriptBase += ShowCommandHelper.GetGetModuleSuffix();
            return scriptBase;
        }

        /// <summary>
        /// gets the command to be run in order to show help for a command
        /// </summary>
        /// <param name="command">command we want to get help from</param>
        /// <returns>the command to be run in order to show help for a command</returns>
        internal static string GetHelpCommand(string command)
        {
            return "Get-Help " + ShowCommandHelper.SingleQuote(command);
        }

        /// <summary>
        /// Constructs a dictionary of imported modules based on the module names
        /// </summary>
        /// <param name="moduleObjects">the imported modules</param>
        /// <returns>a dictionary of imported modules based on the module names</returns>
        internal static Dictionary<string, ShowCommandModuleInfo> GetImportedModulesDictionary(object[] moduleObjects)
        {
            Dictionary<string, ShowCommandModuleInfo> returnValue = new Dictionary<string, ShowCommandModuleInfo>(StringComparer.OrdinalIgnoreCase);
            foreach (PSObject rawModule in moduleObjects)
            {
                ShowCommandModuleInfo wrappedModule = null;
                PSModuleInfo module = rawModule.BaseObject as PSModuleInfo;
                if (module != null)
                {
                    wrappedModule = new ShowCommandModuleInfo(module);
                }
                else
                {
                    wrappedModule = new ShowCommandModuleInfo(rawModule);
                }

                // It is probably an issue somewhere else that a module would show up twice in the list, but we want to avoid
                // throwing an exception regarding that in returnValue.Add
                if(!returnValue.ContainsKey(wrappedModule.Name))
                {
                    returnValue.Add(wrappedModule.Name, wrappedModule);
                }
            }

            return returnValue;
        }

        /// <summary>
        /// Constructs a list of commands out of <paramref name="commandObjects"/>
        /// </summary>
        /// <param name="commandObjects">the results of a get-command command</param>
        /// <returns>a list of commands out of <paramref name="commandObjects"/></returns>
        internal static List<ShowCommandCommandInfo> GetCommandList(object[] commandObjects)
        {
            List<ShowCommandCommandInfo> returnValue = new List<ShowCommandCommandInfo>();
            foreach (PSObject rawCommand in commandObjects)
            {
                CommandInfo command = rawCommand.BaseObject as CommandInfo;
                if(command != null)
                {
                    returnValue.Add(new ShowCommandCommandInfo(command));
                }
                else
                {
                    PSObject obj = rawCommand as PSObject;
                    if(obj != null)
                    {
                        returnValue.Add(new ShowCommandCommandInfo(obj));
                    }
                }
            }

            return returnValue;
        }

        /// <summary>
        /// Constructs an array of objects out of <paramref name="commandObjects"/>
        /// </summary>
        /// <param name="commandObjects">The result of a get-command command</param>
        /// <returns>An array of objects out of <paramref name="commandObjects"/></returns>
        internal static object[] ObjectArrayFromObjectCollection(object commandObjects)
        {
            object[] objectArray = commandObjects as object[];
            if(objectArray == null)
            {
                objectArray = ((System.Collections.ArrayList)commandObjects).ToArray();
            }

            return objectArray;
        }

        /// <summary>
        /// Called after a module in <paramref name="oldViewModel"/> is imported to refresh the view model.
        /// Gets a new AllModulesViewModel populated with <paramref name="importedModules"/> and <paramref name="commands"/>.
        /// The <paramref name="oldViewModel"/> is used to cleanup event listening in the old view model and to copy NoCommonParameters.
        /// The new ViewModel will have the command selected according to <paramref name="selectedModuleNeedingImportModule"/>,
        /// <paramref name="parentModuleNeedingImportModule"/> and <paramref name="commandNeedingImportModule"/>.
        /// </summary>
        /// <param name="oldViewModel">the viewModel before the module was imported</param>
        /// <param name="importedModules">the list of imported modules</param>
        /// <param name="commands">the list of commands</param>
        /// <param name="selectedModuleNeedingImportModule">the name of the module that was selected in <paramref name="oldViewModel"/></param>
        /// <param name="parentModuleNeedingImportModule">the name of the module that was imported</param>
        /// <param name="commandNeedingImportModule">the name of the command that was selected in <paramref name="oldViewModel"/></param>
        /// <returns>The new ViewModel based on <paramref name="importedModules"/> and <paramref name="commands"/>.</returns>
        internal static AllModulesViewModel GetNewAllModulesViewModel(AllModulesViewModel oldViewModel, Dictionary<string, ShowCommandModuleInfo> importedModules, IEnumerable<ShowCommandCommandInfo> commands, string selectedModuleNeedingImportModule, string parentModuleNeedingImportModule, string commandNeedingImportModule)
        {
            string oldFilter = null;

            if (oldViewModel.SelectedModule != null)
            {
                // this will allow the old view model to stop listening for events before we
                // replace it with a new view model
                oldViewModel.SelectedModule.SelectedCommand = null;
                oldViewModel.SelectedModule = null;
                oldFilter = oldViewModel.CommandNameFilter;
            }

            AllModulesViewModel returnValue = new AllModulesViewModel(importedModules, commands, oldViewModel.NoCommonParameter);
            if (!String.IsNullOrEmpty(oldFilter))
            {
                returnValue.CommandNameFilter = oldFilter;
            }

            if (selectedModuleNeedingImportModule == null || parentModuleNeedingImportModule == null)
            {
                return returnValue;
            }

            ModuleViewModel moduleToSelect = returnValue.Modules.Find(
                new Predicate<ModuleViewModel>(delegate(ModuleViewModel module)
                {
                    return module.Name.Equals(selectedModuleNeedingImportModule, StringComparison.OrdinalIgnoreCase) ? true : false;
                }));

            if (moduleToSelect == null)
            {
                return returnValue;
            }

            returnValue.SelectedModule = moduleToSelect;

            CommandViewModel commandToSelect = moduleToSelect.Commands.Find(
                new Predicate<CommandViewModel>(delegate(CommandViewModel command)
                {
                    return command.ModuleName.Equals(parentModuleNeedingImportModule, StringComparison.OrdinalIgnoreCase) &&
                        command.Name.Equals(commandNeedingImportModule, StringComparison.OrdinalIgnoreCase) ? true : false;
                }));

            if (commandToSelect == null)
            {
                return returnValue;
            }

            moduleToSelect.SelectedCommand = commandToSelect;
            return returnValue;
        }

        /// <summary>
        /// Gets an error message to be displayed when failed to import a module
        /// </summary>
        /// <param name="command">command belonging to the module to import</param>
        /// <param name="module">module to import</param>
        /// <param name="error">error importing the module</param>
        /// <returns>an error message to be displayed when failed to import a module</returns>
        internal static string GetImportModuleFailedMessage(string command, string module, string error)
        {
            return String.Format(
                CultureInfo.CurrentUICulture,
                ShowCommandResources.ImportModuleFailedFormat,
                command,
                module,
                error);
        }

        /// <summary>
        /// Single quotes <paramref name="str"/>
        /// </summary>
        /// <param name="str">string to quote</param>
        /// <returns><paramref name="str"/> single quoted</returns>
        internal static string SingleQuote(string str)
        {
            if (str == null)
            {
                str = String.Empty;
            }

            return "\'" + System.Management.Automation.Language.CodeGeneration.EscapeSingleQuotedStringContent(str) + "\'";
        }
        #endregion internal static methods called using reflection from show-command and directly from ISE

        #region internal static methods used internally in this assembly
        /// <summary>
        /// Gets the host window, if it is present or null if it is not
        /// </summary>
        /// <param name="cmdlet">cmdlet calling this method</param>
        /// <returns>the host window, if it is present or null if it is not</returns>
        internal static Window GetHostWindow(PSCmdlet cmdlet)
        {
            PSPropertyInfo windowProperty = cmdlet.Host.PrivateData.Properties["Window"];
            if (windowProperty == null)
            {
                return null;
            }

            try
            {
                return windowProperty.Value as Window;
            }
            catch (ExtendedTypeSystemException)
            {
                return null;
            }
        }
        #endregion internal static methods used internally in this assembly

        #region static private methods used only on this file

        /// <summary>
        /// Gets a property value using reflection
        /// </summary>
        /// <param name="type">type containing the property</param>
        /// <param name="obj">object containing the property (null for a static property)</param>
        /// <param name="propertyName">name of property to get</param>
        /// <param name="bindingFlags">flags passed to reflection</param>
        /// <returns>
        /// property value or null if it was not able to retrieve it. This method is not suitable to return a property value that might be null.
        /// </returns>
        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Called from a method called using reflection")]
        private static object GetPropertyValue(Type type, object obj, string propertyName, BindingFlags bindingFlags)
        {
            PropertyInfo property = type.GetProperty(propertyName, bindingFlags);
            if (property == null)
            {
                return null;
            }

            try
            {
                return property.GetValue(obj, new object[] { });
            }
            catch (ArgumentException)
            {
                return null;
            }
            catch (TargetException)
            {
                return null;
            }
            catch (TargetParameterCountException)
            {
                return null;
            }
            catch (MethodAccessException)
            {
                return null;
            }
            catch (TargetInvocationException)
            {
                return null;
            }
        }

        /// <summary>
        /// Sets a property value using reflection
        /// </summary>
        /// <param name="type">type containing the property</param>
        /// <param name="obj">object containing the property (null for a static property)</param>
        /// <param name="propertyName">name of property to set</param>
        /// <param name="value">value to set the property with</param>
        /// <param name="bindingFlags">flags passed to reflection</param>
        /// <returns>true if it was able to set</returns>
        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Called from a method called using reflection")]
        private static bool SetPropertyValue(Type type, object obj, string propertyName, object value, BindingFlags bindingFlags)
        {
            PropertyInfo property = type.GetProperty(propertyName, bindingFlags);
            if (property == null)
            {
                return false;
            }

            try
            {
                property.SetValue(obj, value, new object[] { });
            }
            catch (ArgumentException)
            {
                return false;
            }
            catch (TargetException)
            {
                return false;
            }
            catch (TargetParameterCountException)
            {
                return false;
            }
            catch (MethodAccessException)
            {
                return false;
            }
            catch (TargetInvocationException)
            {
                return false;
            }

            return true;
        }

        /// <summary>
        /// Gets the suffix that adds imported modules to a command
        /// </summary>
        /// <returns>the suffix that adds imported modules to a command</returns>
        private static string GetGetModuleSuffix()
        {
            return ",@(get-module)";
        }

        #endregion static private methods used only on this file

        #region private methods called using reflection from show-command
        /// <summary>
        /// Gets the command to be run when calling show-command for a particular command
        /// </summary>
        /// <param name="commandName">the particular command we are running show-command on</param>
        /// <param name="includeAliasAndModules">true if we want to include aliases and retrieve modules</param>
        /// <returns>the command to be run when calling show-command for a particular command</returns>
        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Called using reflection")]
        private static string GetShowCommandCommand(string commandName, bool includeAliasAndModules)
        {
            string quotedCommandName = ShowCommandHelper.SingleQuote(commandName);
            return "@(get-command " + quotedCommandName + " " + ShowCommandHelper.CommandTypeSegment +
                (includeAliasAndModules ? ",Alias" : String.Empty) + ")" +
                (includeAliasAndModules ? ShowCommandHelper.GetGetModuleSuffix() : String.Empty);
        }

        /// <summary>
        /// Gets a CommandViewModel of a CommandInfo
        /// </summary>
        /// <param name="command">command we want to get a CommandViewModel of</param>
        /// <param name="noCommonParameter">true if we do not want common parameters</param>
        /// <param name="importedModules">the loaded modules</param>
        /// <param name="moduleQualify">True to qualify command with module name in GetScript</param>
        /// <returns>a CommandViewModel of a CommandInfo</returns>
        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Called using reflection")]
        private static object GetCommandViewModel(ShowCommandCommandInfo command, bool noCommonParameter, Dictionary<string, ShowCommandModuleInfo> importedModules, bool moduleQualify)
        {
            CommandViewModel returnValue = CommandViewModel.GetCommandViewModel(new ModuleViewModel(command.ModuleName, importedModules), command, noCommonParameter);
            returnValue.ModuleQualifyCommandName = moduleQualify;
            return returnValue;
        }

        /// <summary>
        /// Dispatches a message to the window for it to activate
        /// </summary>
        /// <param name="window">window to be activated</param>
        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Called from ActivateWindow() which is called using reflection")]
        private static void ActivateWindow(Window window)
        {
            window.Dispatcher.Invoke(
                new SendOrPostCallback(
                    delegate(object ignored)
                    {
                        window.Activate();
                    }),
                    String.Empty);
        }

        /// <summary>
        /// Sets a property in ISE that will allow the command to be run
        /// </summary>
        /// <param name="command">command to be run</param>
        /// <returns>true if it was possible to set  the pending ISE command</returns>
        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Called using reflection")]
        private bool SetPendingISECommand(string command)
        {
            Diagnostics.Assert(this.hostWindow != null, "The caller checks that");

            Type internalHostType = this.hostWindow.GetType().Assembly.GetType("Microsoft.Windows.PowerShell.Gui.Internal.PSGInternalHost");
            if (internalHostType == null)
            {
                return false;
            }

            object current = GetPropertyValue(internalHostType, null, "Current", BindingFlags.Public | BindingFlags.Static);
            if (current == null)
            {
                return false;
            }

            object powerShellTabs = GetPropertyValue(current.GetType(), current, "PowerShellTabs", BindingFlags.Public | BindingFlags.Instance);
            if (powerShellTabs == null)
            {
                return false;
            }

            object selectedPowerShellTab = GetPropertyValue(powerShellTabs.GetType(), powerShellTabs, "SelectedPowerShellTab", BindingFlags.Public | BindingFlags.Instance);
            if (selectedPowerShellTab == null)
            {
                return false;
            }

            return SetPropertyValue(selectedPowerShellTab.GetType(), selectedPowerShellTab, "PendingCommand", command, BindingFlags.NonPublic | BindingFlags.Instance);
        }

        /// <summary>
        /// Shows the window listing cmdlets
        /// </summary>
        /// <param name="cmdlet">cmdlet calling this method</param>
        /// <param name="importedModules">All loaded modules</param>
        /// <param name="commands">commands to be listed</param>
        /// <param name="noCommonParameter">true if we should not show common parameters</param>
        /// <param name="windowWidth">window width</param>
        /// <param name="windowHeight">window height</param>
        /// <param name="passThrough">true if the GUI should mention ok instead of run</param>
        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Called using reflection")]
        private void ShowAllModulesWindow(PSCmdlet cmdlet, Dictionary<string, ShowCommandModuleInfo> importedModules, IEnumerable<ShowCommandCommandInfo> commands, bool noCommonParameter, double windowWidth, double windowHeight, bool passThrough)
        {
            this.methodThatReturnsDialog = new DispatcherOperationCallback(delegate(object ignored)
            {
                Diagnostics.Assert(commands.GetEnumerator().MoveNext(), "there is always at least one command");

                ShowAllModulesWindow allModulesWindow = new ShowAllModulesWindow();
                this.allModulesViewModel = new AllModulesViewModel(importedModules, commands, noCommonParameter);

                this.SetupButtonEvents(allModulesWindow.Run, allModulesWindow.Copy, allModulesWindow.Cancel, passThrough);
                this.SetupWindow(allModulesWindow);
                this.SetupViewModel();
                CommonHelper.SetStartingPositionAndSize(
                    allModulesWindow,
                    ShowCommandSettings.Default.ShowCommandsTop,
                    ShowCommandSettings.Default.ShowCommandsLeft,
                    windowWidth != 0.0 && windowWidth > allModulesWindow.MinWidth ? windowWidth : ShowCommandSettings.Default.ShowCommandsWidth,
                    windowHeight != 0.0 && windowHeight > allModulesWindow.MinHeight ? windowHeight : ShowCommandSettings.Default.ShowCommandsHeight,
                    allModulesWindow.Width,
                    allModulesWindow.Height,
                    ShowCommandSettings.Default.ShowCommandsWindowMaximized);

                return allModulesWindow;
            });

            this.CallShowDialog(cmdlet);
        }

        /// <summary>
        /// Calls ShowsDialog on methodThatReturnsDialog either in a separate thread or dispatched
        /// to the hostWindow thread if there is a hostWindow
        /// </summary>
        /// <param name="cmdlet">cmdlet used to retrieve the host window</param>
        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Called from a method called using reflection")]
        private void CallShowDialog(PSCmdlet cmdlet)
        {
            this.hostWindow = ShowCommandHelper.GetHostWindow(cmdlet);
            if (this.hostWindow == null)
            {
                Thread guiThread = new Thread(new ThreadStart(this.PlainInvokeAndShowDialog));
                guiThread.SetApartmentState(ApartmentState.STA);
                guiThread.Start();
                return;
            }

            this.hostWindow.Dispatcher.Invoke(
                new SendOrPostCallback(
                    delegate(object ignored)
                    {
                        Window childWindow = (Window)this.methodThatReturnsDialog.Invoke(null);
                        childWindow.Owner = this.hostWindow;
                        childWindow.Show();
                    }),
                    String.Empty);
        }

        /// <summary>
        /// Called from CallMethodThatShowsDialog as the thread start when there is no host window
        /// </summary>
        private void PlainInvokeAndShowDialog()
        {
            ((Window)this.methodThatReturnsDialog.Invoke(null)).ShowDialog();
        }

        /// <summary>
        /// Shows the window for the cmdlet
        /// </summary>
        /// <param name="cmdlet">cmdlet calling this method</param>
        /// <param name="commandViewModelObj">command to show in the window</param>
        /// <param name="windowWidth">window width</param>
        /// <param name="windowHeight">window height</param>
        /// <param name="passThrough">true if the GUI should mention ok instead of run</param>
        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Called using reflection")]
        private void ShowCommandWindow(PSCmdlet cmdlet, object commandViewModelObj, double windowWidth, double windowHeight, bool passThrough)
        {
            this.methodThatReturnsDialog = new DispatcherOperationCallback(delegate(object ignored)
            {
                Diagnostics.Assert(commandViewModelObj != null, "verified by caller");
                this.commandViewModel = (CommandViewModel)commandViewModelObj;
                ShowCommandWindow showCommandWindow = new ShowCommandWindow();

                this.commandViewModel.HelpNeeded += new EventHandler<HelpNeededEventArgs>(this.CommandNeedsHelp);
                showCommandWindow.DataContext = this.commandViewModel;

                this.SetupButtonEvents(showCommandWindow.Run, showCommandWindow.Copy, showCommandWindow.Cancel, passThrough);
                this.SetupWindow(showCommandWindow);

                CommonHelper.SetStartingPositionAndSize(
                    showCommandWindow,
                    ShowCommandSettings.Default.ShowOneCommandTop,
                    ShowCommandSettings.Default.ShowOneCommandLeft,
                    windowWidth != 0.0 && windowWidth > showCommandWindow.MinWidth ? windowWidth : ShowCommandSettings.Default.ShowOneCommandWidth,
                    windowHeight != 0.0 && windowHeight > showCommandWindow.MinHeight ? windowHeight : ShowCommandSettings.Default.ShowOneCommandHeight,
                    showCommandWindow.Width,
                    showCommandWindow.Height,
                    ShowCommandSettings.Default.ShowOneCommandWindowMaximized);

                return showCommandWindow;
            });

            this.CallShowDialog(cmdlet);
        }

        /// <summary>
        /// Called when the module importation is done
        /// </summary>
        /// <param name="importedModules">all modules currently imported</param>
        /// <param name="commands">commands to be displayed</param>
        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Called using reflection")]
        private void ImportModuleDone(Dictionary<string, ShowCommandModuleInfo> importedModules, IEnumerable<ShowCommandCommandInfo> commands)
        {
            this.allModulesViewModel.WaitMessageDisplayed = false;
            if (this.window != null)
            {
                this.window.Dispatcher.Invoke(
                    new SendOrPostCallback(
                        delegate(object ignored)
                        {
                            this.allModulesViewModel = ShowCommandHelper.GetNewAllModulesViewModel(
                                this.allModulesViewModel,
                                importedModules,
                                commands,
                                this.selectedModuleNeedingImportModule,
                                this.parentModuleNeedingImportModule,
                                this.commandNeedingImportModule);
                            this.SetupViewModel();
                        }),
                        String.Empty);
            }
        }

        /// <summary>
        /// Called when the module importation has failed
        /// </summary>
        /// <param name="reason">reason why the module importation failed</param>
        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Called using reflection")]
        private void ImportModuleFailed(Exception reason)
        {
            this.allModulesViewModel.WaitMessageDisplayed = false;
            if (this.window != null)
            {
                this.window.Dispatcher.Invoke(
                    new SendOrPostCallback(
                        delegate(object ignored)
                        {
                            string message = ShowCommandHelper.GetImportModuleFailedMessage(
                                this.commandNeedingImportModule,
                                this.parentModuleNeedingImportModule,
                                reason.Message);
                            MessageBox.Show(this.window, message, ShowCommandResources.ShowCommandError, MessageBoxButton.OK, MessageBoxImage.Error);
                        }),
                        String.Empty);
            }
        }

        /// <summary>
        /// Called when the results or get-help are ready in order to display the help window for a command
        /// </summary>
        /// <param name="getHelpResults">results of a get-help call</param>
        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Called using reflection")]
        private void DisplayHelp(Collection<PSObject> getHelpResults)
        {
            if (this.window != null && getHelpResults != null && getHelpResults.Count > 0)
            {
                this.window.Dispatcher.Invoke(
                    new SendOrPostCallback(
                        delegate(object ignored)
                        {
                            HelpWindow help = new HelpWindow(getHelpResults[0]);
                            help.Owner = this.window;
                            help.Show();
                        }),
                        String.Empty);
            }
        }

        /// <summary>
        /// Activates this.window
        /// </summary>
        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Called using reflection")]
        private void ActivateWindow()
        {
            if (this.window != null)
            {
                ShowCommandHelper.ActivateWindow(this.window);
            }
        }

        /// <summary>
        /// returns the script to execute if dialog has not been canceled
        /// </summary>
        /// <returns>the script to execute if dialog has not been canceled</returns>
        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Called using reflection")]
        private string GetScript()
        {
            if (this.dialogCanceled)
            {
                return null;
            }

            return this.InternalGetScript();
        }
        #endregion private methods called using reflection from show-command

        #region instance private methods used only on this file
        /// <summary>
        /// Sets up window settings common between the two flavors of show-command
        /// </summary>
        /// <param name="commandWindow">the window being displayed</param>
        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Called from ShowAllModulesWindow and ShowCommandWindow which are called with reflection")]
        private void SetupWindow(Window commandWindow)
        {
            this.window = commandWindow;
            this.window.Closed += new EventHandler(this.Window_Closed);
            this.window.Loaded += new RoutedEventHandler(this.Window_Loaded);
        }

        /// <summary>
        /// Handles the SelectedCommandInSelectedModuleNeedsImportModule event
        /// </summary>
        /// <param name="sender">event sender</param>
        /// <param name="e">event arguments</param>
        private void CommandNeedsImportModule(object sender, ImportModuleEventArgs e)
        {
            this.commandNeedingImportModule = e.CommandName;
            this.parentModuleNeedingImportModule = e.ParentModuleName;
            this.selectedModuleNeedingImportModule = e.SelectedModuleName;
            this.allModulesViewModel.WaitMessageDisplayed = true;
            this.ImportModuleNeeded.Set();
        }

        /// <summary>
        /// Handles the SelectedCommandInSelectedModuleNeedsHelp event
        /// </summary>
        /// <param name="sender">event sender</param>
        /// <param name="e">event arguments</param>
        private void CommandNeedsHelp(object sender, HelpNeededEventArgs e)
        {
            this.commandNeedingHelp = e.CommandName;
            this.HelpNeeded.Set();
        }

        /// <summary>
        /// Called when the window is closed to set this.dialogCanceled
        /// </summary>
        /// <param name="sender">event sender</param>
        /// <param name="e">event arguments</param>
        private void Window_Closed(object sender, EventArgs e)
        {
            if (this.hostWindow != null)
            {
                this.hostWindow.Focus();
            }

            this.window = null;
            this.windowClosed.Set();
        }

        /// <summary>
        /// Called when the window is loaded to set this.Window_Loaded
        /// </summary>
        /// <param name="sender">event sender</param>
        /// <param name="e">event arguments</param>
        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            this.window.Loaded -= new RoutedEventHandler(this.Window_Loaded);
            this.windowLoaded.Set();
        }

        /// <summary>
        /// Sets up event listening on the buttons
        /// </summary>
        /// <param name="run">button to run command</param>
        /// <param name="copy">button to copy command code</param>
        /// <param name="cancel">button to close window</param>
        /// <param name="passThrough">true to change the text of Run to OK</param>
        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Called from methods called using reflection")]
        private void SetupButtonEvents(Button run, Button copy, Button cancel, bool passThrough)
        {
            if (passThrough)
            {
                run.Content = ShowCommandResources.ActionButtons_Button_Ok;
            }

            run.Click += new RoutedEventHandler(this.Buttons_RunClick);
            copy.Click += new RoutedEventHandler(this.Buttons_CopyClick);
            cancel.Click += new RoutedEventHandler(this.Buttons_CancelClick);
        }

        /// <summary>
        /// Sets up event listening for a new viewModel
        /// </summary>
        private void SetupViewModel()
        {
            this.allModulesViewModel.SelectedCommandInSelectedModuleNeedsHelp += new EventHandler<HelpNeededEventArgs>(this.CommandNeedsHelp);
            this.allModulesViewModel.SelectedCommandInSelectedModuleNeedsImportModule += new EventHandler<ImportModuleEventArgs>(this.CommandNeedsImportModule);
            this.window.DataContext = this.allModulesViewModel;
        }

        /// <summary>
        /// Copies the script into the clipboard
        /// </summary>
        /// <param name="sender">event sender</param>
        /// <param name="e">event arguments</param>
        private void Buttons_CopyClick(object sender, RoutedEventArgs e)
        {
            string script = this.InternalGetScript();
            if (script == null)
            {
                return;
            }

            this.window.Dispatcher.Invoke(new ThreadStart(delegate { ShowCommandHelper.SetClipboardText(script); }));
        }

        /// <summary>
        /// Sets a successful dialog result and then closes the window
        /// </summary>
        /// <param name="sender">event sender</param>
        /// <param name="e">event arguments</param>
        private void Buttons_RunClick(object sender, RoutedEventArgs e)
        {
            this.dialogCanceled = false;
            this.CloseWindow();
        }

        /// <summary>
        /// Closes the window
        /// </summary>
        /// <param name="sender">event sender</param>
        /// <param name="e">event arguments</param>
        private void Buttons_CancelClick(object sender, RoutedEventArgs e)
        {
            this.CloseWindow();
        }

        /// <summary>
        /// closes the window
        /// </summary>
        private void CloseWindow()
        {
            if (this.window == null)
            {
                return;
            }

            this.window.Dispatcher.Invoke(new ThreadStart(delegate
            {
                // This can happen if ISE is closed while show-command is up
                if (this.window != null)
                {
                    this.window.Close();
                }
            }));
        }

        /// <summary>
        /// Showing a MessageBox when user type a invalidate command name.
        /// </summary>
        /// <param name="errorString">error message</param>
        private void ShowErrorString(string errorString)
        {
            if (errorString != null && errorString.Trim().Length > 0)
            {
                MessageBox.Show(
                    String.Format(
                        CultureInfo.CurrentUICulture,
                        ShowCommandResources.EndProcessingErrorMessage,
                        errorString),
                     "Show-Command",
                     MessageBoxButton.OK,
                     MessageBoxImage.Error);
            }
        }

        /// <summary>
        /// returns the script to execute
        /// </summary>
        /// <returns>the script to execute</returns>
        private string InternalGetScript()
        {
            if (this.allModulesViewModel != null)
            {
                return this.allModulesViewModel.GetScript();
            }

            if (this.commandViewModel == null)
            {
                return null;
            }

            return this.commandViewModel.GetScript();
        }

        /// <summary>
        /// Implements IDisposable logic
        /// </summary>
        /// <param name="isDisposing">true if being called from Dispose</param>
        private void Dispose(bool isDisposing)
        {
            if (isDisposing)
            {
                this.windowClosed.Dispose();
                this.helpNeeded.Dispose();
                this.windowLoaded.Dispose();
                this.importModuleNeeded.Dispose();
            }
        }
        #endregion instance private methods used only on this file
    }
}