//******************************************************************************************************
//  Command.cs - Gbtc
//
//  Copyright © 2010, Grid Protection Alliance.  All Rights Reserved.
//
//  Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See
//  the NOTICE file distributed with this work for additional information regarding copyright ownership.
//  The GPA licenses this file to you under the MIT License (MIT), the "License"; you may
//  not use this file except in compliance with the License. You may obtain a copy of the License at:
//
//      http://www.opensource.org/licenses/MIT
//
//  Unless agreed to in writing, the subject software distributed under the License is distributed on an
//  "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the
//  License for the specific language governing permissions and limitations.
//
//  Code Modification History:
//  ----------------------------------------------------------------------------------------------------
//  08/27/2014 - J. Ritchie Carroll
//       Generated original version of source code.
//
//******************************************************************************************************

using System;
using System.Diagnostics;
using System.Text;
using System.Threading;

namespace GSF.Console
{
    /// <summary>
    /// Defines methods related to command line operations
    /// </summary>
    public static class Command
    {
        // Defines a command process.
        private sealed class CommandProcess : IDisposable
        {
            #region [ Members ]

            // Fields
            private readonly Process m_process;
            private readonly StringBuilder m_standardOutput;
            private readonly StringBuilder m_standardError;
            private int m_exitCode;
            private bool m_disposed;

            #endregion

            #region [ Constructors ]

            /// <summary>
            /// Creates a new <see cref="CommandProcess"/> instance.
            /// </summary>
            /// <param name="fileName">File name to execute.</param>
            /// <param name="arguments">Command line parameters, if any. Set to empty string for none.</param>
            public CommandProcess(string fileName, string arguments)
            {
                m_standardOutput = new StringBuilder();
                m_standardError = new StringBuilder();
                m_exitCode = -1;

                m_process = new Process
                {
                    StartInfo =
                    {
                        FileName = fileName,
                        Arguments = arguments,
                        UseShellExecute = false,
                        RedirectStandardOutput = true,
                        RedirectStandardError = true
                    }
                };

                m_process.OutputDataReceived += m_process_OutputDataReceived;
                m_process.ErrorDataReceived += m_process_ErrorDataReceived;
            }

            /// <summary>
            /// Releases the unmanaged resources before the <see cref="CommandProcess"/> object is reclaimed by <see cref="GC"/>.
            /// </summary>
            ~CommandProcess()
            {
                Dispose(false);
            }

            #endregion

            #region [ Properties ]

            /// <summary>
            /// Gets any standard output from process after execution.
            /// </summary>
            public string StandardOutput
            {
                get
                {
                    return m_standardOutput.ToString();
                }
            }

            /// <summary>
            /// Gets any standard error from process after execution.
            /// </summary>
            public string StandardError
            {
                get
                {
                    return m_standardError.ToString();
                }
            }

            /// <summary>
            /// Gets exit code assuming process
            /// </summary>
            public int ExitCode
            {
                get
                {
                    return m_exitCode;
                }
            }

            #endregion

            #region [ Methods ]

            /// <summary>
            /// Releases all the resources used by the <see cref="CommandProcess"/> object.
            /// </summary>
            public void Dispose()
            {
                Dispose(true);
                GC.SuppressFinalize(this);
            }

            // Releases the unmanaged resources and optionally releases the managed resources.
            private void Dispose(bool disposing)
            {
                if (!m_disposed)
                {
                    try
                    {
                        if (disposing)
                        {
                            if ((object)m_process != null)
                            {
                                m_process.OutputDataReceived -= m_process_OutputDataReceived;
                                m_process.ErrorDataReceived -= m_process_ErrorDataReceived;
                                m_process.Dispose();
                            }
                        }
                    }
                    finally
                    {
                        m_disposed = true;  // Prevent duplicate dispose.
                    }
                }
            }

            /// <summary>
            /// Attempts to execute process.
            /// </summary>
            /// <param name="timeout">Timeout, in milliseconds, to wait for command line operation to complete.</param>
            /// <returns><c>true</c> if process completed; otherwise, <c>false</c> if process timed-out.</returns>
            public bool Execute(int timeout)
            {
                m_process.Start();

                m_process.BeginOutputReadLine();
                m_process.BeginErrorReadLine();

                if (!m_process.WaitForExit(timeout))
                {
                    m_process.CancelOutputRead();
                    m_process.CancelErrorRead();
                    return false;
                }

                m_exitCode = m_process.ExitCode;
                return true;
            }

            private void m_process_OutputDataReceived(object sender, DataReceivedEventArgs e)
            {
                m_standardOutput.AppendLine(e.Data);
            }

            private void m_process_ErrorDataReceived(object sender, DataReceivedEventArgs e)
            {
                m_standardError.AppendLine(e.Data);
            }

            #endregion
        }

        /// <summary>
        /// Executes a command line operation and returns its standard output and exit code or throws an exception with the standard error.
        /// </summary>
        /// <param name="fileName">Command line file name to execute.</param>
        /// <param name="arguments">Command line arguments to use, if any.</param>
        /// <param name="timeout">Timeout, in milliseconds, to wait for command line operation to complete.</param>
        /// <returns>A <see cref="CommandResponse"/> containing the standard output received from command and the exit code.</returns>
        /// <exception cref="CommandException">
        /// Exception occurs when executed command process reports standard error output or process times-out.
        /// </exception>
        public static CommandResponse Execute(string fileName, string arguments = null, int timeout = Timeout.Infinite)
        {
            string standardOutput, standardError;
            bool processCompleted;
            int exitCode;

            if (!Execute(fileName, arguments, out standardOutput, out standardError, out processCompleted, out exitCode, timeout))
                throw new CommandException(standardError, processCompleted, exitCode);

            if (!processCompleted)
                throw new CommandException("Process timed-out.", false, -1);

            return new CommandResponse(standardOutput, exitCode);
        }

        /// <summary>
        /// Executes a command line operation and returns <c>true</c> if there was no standard error reported.
        /// </summary>
        /// <param name="fileName">Command line file name to execute.</param>
        /// <param name="arguments">Command line arguments to use, if any.</param>
        /// <param name="standardOutput">Any standard output reported by the command line operation.</param>
        /// <param name="standardError">Any standard error reported by the command line operation.</param>
        /// <param name="exitCode">Exit code of the process, assuming process successfully completed.</param>
        /// <returns><c>true</c> if there was no standard error reported; otherwise, <c>false</c>.</returns>
        /// <remarks>This function waits indefinitely for the command line operation to complete.</remarks>
        public static bool Execute(string fileName, string arguments, out string standardOutput, out string standardError, out int exitCode)
        {
            bool processCompleted;
            return Execute(fileName, arguments, out standardOutput, out standardError, out processCompleted, out exitCode, Timeout.Infinite);
        }

        /// <summary>
        /// Executes a command line operation and returns <c>true</c> if there was no standard error reported.
        /// </summary>
        /// <param name="fileName">Command line file name to execute.</param>
        /// <param name="arguments">Command line arguments to use, if any.</param>
        /// <param name="standardOutput">Any standard output reported by the command line operation.</param>
        /// <param name="standardError">Any standard error reported by the command line operation.</param>
        /// <param name="processCompleted">Flag that determines if process completed or timed-out. This is only relevant if <paramref name="timeout"/> is not -1.</param>
        /// <param name="exitCode">Exit code of the process, assuming process successfully completed.</param>
        /// <param name="timeout">Timeout, in milliseconds, to wait for command line operation to complete. Set to <see cref="Timeout.Infinite"/>, i.e., -1, for infinite wait.</param>
        /// <returns><c>true</c> if there was no standard error reported; otherwise, <c>false</c>.</returns>
        public static bool Execute(string fileName, string arguments, out string standardOutput, out string standardError, out bool processCompleted, out int exitCode, int timeout)
        {
            using (CommandProcess process = new CommandProcess(fileName, arguments ?? ""))
            {
                processCompleted = process.Execute(timeout);
                standardOutput = process.StandardOutput;
                standardError = process.StandardError;
                exitCode = process.ExitCode;
            }

            return string.IsNullOrWhiteSpace(standardError);
        }

        /// <summary>
        /// Shell encodes a command line parameter by converting "\" to "\\".
        /// </summary>
        /// <param name="parameter">Parameter to shell encode.</param>
        /// <returns>Shell encoded <paramref name="parameter"/>.</returns>
        public static string ShellEncode(this string parameter)
        {
            if ((object)parameter == null)
                throw new ArgumentNullException(nameof(parameter));

            return parameter.Replace("\\", "\\\\");
        }

        /// <summary>
        /// Decodes a command line parameter previously encoded by <see cref="ShellEncode"/>.
        /// </summary>
        /// <param name="parameter">Parameter to decode.</param>
        /// <returns>Decoded <paramref name="parameter"/>.</returns>
        public static string ShellDecode(this string parameter)
        {
            if ((object)parameter == null)
                throw new ArgumentNullException(nameof(parameter));

            return parameter.Replace("\\\\", "\\");
        }
    }
}