//            Copyright Keysight Technologies 2012-2019
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, you can obtain one at http://mozilla.org/MPL/2.0/.
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Text;
using System.Threading;

namespace OpenTap.Plugins.BasicSteps
{
    [Display("Run Program", Group: "OpenTap", Description: "Runs a program, and optionally applies regular expressions (regex) to the output.",Order:1)]
    public class ProcessStep : RegexOutputStep
    {
        public class EnvironmentVariable : ValidatingObject
        {
            [Display("Name", "The name of the environment variable.")]
            public string Name { get; set; }
            [Display("Value", "The value of the environment variable.")]
            public string Value { get; set; }

            public EnvironmentVariable()
            {
                Rules.Add(() => !string.IsNullOrEmpty(Name), "Name must not be empty.", nameof(Name));
            }

            public override bool Equals(object obj)
            {
                if (obj is EnvironmentVariable ev)
                {
                    return ev.Name == Name && ev.Value == Value;
                }
                return base.Equals(obj);
            }

            public override int GetHashCode()
            {
                var h1 = Name?.GetHashCode() ?? 0;
                var h2 = Value?.GetHashCode() ?? 0;
                return (((h1 + 742759321) * 1593213024) + h2) * 1079741372;
            }
        }

        public override bool GeneratesOutput => WaitForEnd;

        [Display("Application", Order: -2.5,
            Description:
            "The path to the program. It should contain either a relative path to OpenTAP installation folder or an absolute path to the program.")]
        [FilePath(FilePathAttribute.BehaviorChoice.Open)]
        public string Application { get; set; } = "";

        [Display("Command Line Arguments", Order: -2.4, Description: "The arguments passed to the program.")]
        [DefaultValue("")]
        public string Arguments { get; set; } = "";

        [Display("Working Directory", Order: -2.3, Description: "The directory where the program will be started in.")]
        [DirectoryPath]
        public string WorkingDirectory { get; set; } = "";

        [Display("Environment Variables", Order: -2.25, Description: "The environment variables passed to the program.")]
        public List<EnvironmentVariable> EnvironmentVariables { get; set; } = new List<EnvironmentVariable>();

        [Display("Wait For Process to End", Order: -2.2,
            Description: "Wait for the process to terminate before continuing.")]
        [DefaultValue(true)]
        public bool WaitForEnd { get; set; } = true;

        int timeoutMs = 0;
        [Display("Wait Timeout", Order: -2.1, Description: "The time to wait for the process to end. Set to 0 to wait forever.")]
        [Unit("s", PreScaling: 1000)]
        [EnabledIf("WaitForEnd", true, HideIfDisabled = true)]
        public Int32 Timeout
        {
            get { return timeoutMs; }
            set
            {
                if (value >= 0)
                    timeoutMs = value;
                else throw new Exception("Timeout must be positive");
            }
        }

        [EnabledIf(nameof(GeneratesOutput), true, HideIfDisabled = true)]
        [Display("Add to Log", Order: -2.05, Description: "If enabled the result of the query is added to the log.")]
        public bool AddToLog { get; set; }

        [EnabledIf(nameof(AddToLog), true, HideIfDisabled = true)]
        [EnabledIf(nameof(GeneratesOutput), true, HideIfDisabled = true)]
        [Display("Log Header", Order: -2.0,
            Description: "This string is added to the front of the result of the query.")]
        [DefaultValue("")]
        public string LogHeader { get; set; } = "";

        string prepend;

        [Display("Check Exit Code", "Check the exit code of the application and set verdict to fail if it is non-zero, else pass. 'Wait For End' must be set for this to work.", "Set Verdict", Order: 1.1)]
        [EnabledIf(nameof(WaitForEnd), true, HideIfDisabled = true)]
        public bool CheckExitCode { get; set; }

        [Display("Run As Administrator", "Attempt to run the application as administrator.", Order: -2.06)]
        internal bool RunElevated { get; set; } = false; // this is disabled for now.

        [Display("Exit Code", Group: "Results", Order: 1.53, Collapsed: true, Description: "The exit code of the process.")]
        [Output]
        [Browsable(true)]
        [EnabledIf(nameof(WaitForEnd), true, HideIfDisabled = true)]
        public int ExitCode { get; private set; }
        
        StringBuilder output;


        [Display("Output", Group: "Results", Order: 1.53, Collapsed: true, Description: "The result of the execution.")]
        [EnabledIf(nameof(GeneratesOutput), true, HideIfDisabled = true)]
        [Output]
        [Browsable(true)]
        [Layout(LayoutMode.Normal, maxRowHeight: 1)]
        public string Output => output?.ToString() ?? "";


        public ProcessStep()
        {
            Rules.Add(HasNoDuplicateEnvironmentVariables, "Environment variable names must be unique.", nameof(EnvironmentVariables));
            Rules.Add(new ValidationRule(() => !string.IsNullOrWhiteSpace(Application), "Application must be set", nameof(Application)));
        }

        private bool HasNoDuplicateEnvironmentVariables()
        {
            HashSet<string> seenVariables = new HashSet<string>();
            foreach (var variable in EnvironmentVariables)
            {
                if (!seenVariables.Add(variable.Name))
                {
                    return false;
                }
            }
            return true;
        }
        public override void Run()
        {
            if (WaitForEnd == false)
            {
                Run0();
            }
            else
            {
                // for timeouts we use the regular TapThread abort feature.
                // this way it will work like if the user clicked the stop button
                // in the test plan (except from the abort verdict).
                TapThread.WithNewContext(() =>
                {
                    if(timeoutMs > 0)
                        TapThread.Current.AbortAfter(TimeSpan.FromMilliseconds(Timeout));
                    Run0();
                }, TapThread.Current);
            }
        }

        void Run0()
        {
            output?.Clear();
            ThrowOnValidationError(true);
            if (RunElevated &&!SubProcessHost.IsAdmin())
            {
                // note, this part is currently never enabled.
                try
                {
                    // Set RunElevated = false so ProcessHelper doesn't infinitely loop
                    RunElevated = false;
                    var processRunner = new SubProcessHost { ForwardLogs = AddToLog, LogHeader = LogHeader};
                    var verdict = processRunner.Run(this, true, TapThread.Current.AbortToken);
                    UpgradeVerdict(verdict);
                    return;
                }
                catch
                {
                    UpgradeVerdict(Verdict.Error);
                    throw;
                }
                finally
                {
                    RunElevated = true;
                }
            }

            prepend = string.IsNullOrEmpty(LogHeader) ? "" : LogHeader + " ";

            var process = new Process
            {
                StartInfo =
                {
                    FileName = Application,
                    Arguments = Arguments,
                    WorkingDirectory = string.IsNullOrEmpty(WorkingDirectory) ? Directory.GetCurrentDirectory() : Path.GetFullPath(WorkingDirectory),
                    UseShellExecute = false,
                    RedirectStandardOutput = true,
                    RedirectStandardError = true,
                    RedirectStandardInput = true,
                    CreateNoWindow = true
                }
            };
            foreach (var environmentVariable in EnvironmentVariables)
            {
                process.StartInfo.Environment.Add(environmentVariable.Name, environmentVariable.Value);
            }
            var startEvent = new ManualResetEventSlim();
            var abortRegistration = TapThread.Current.AbortToken.Register(() =>
            {
                startEvent.Wait(500);
                if (process.HasExited) return;
                Log.Debug("Ending process '{0}'.", Application);
                try
                {  // process.Kill may throw if it has already exited.
                    try
                    {
                        // signal to the sub process that no more input will arrive.
                        // For many process this has the same effect as CTRL+C as stdin is closed.
                        process.StandardInput.Close();
                    }
                    catch
                    {
                        // this might be ok. It probably means that the input has already been closed.
                    }

                    if (!process.HasExited && !process.WaitForExit(500)) // give some time for the process to close by itself.
                    {
                        Thread.Sleep(100);
                        if(process.HasExited == false)
                            process.Kill();
                    }
                }
                catch(Exception ex)
                {
                    Log.Warning("Caught exception when killing process. {0}", ex.Message);
                }
            });

            if (WaitForEnd)
            {
                output = new StringBuilder();
                
                using(process)
                using(abortRegistration)
                {
                    process.OutputDataReceived += OutputDataRecv;
                    process.ErrorDataReceived += ErrorDataRecv;

                    Log.Debug("Starting process {0} with arguments \"{1}\"", Application, Arguments);
                    // Ensure that all asynchronous processing is completed by calling process.WaitForExit()
                    // Only the overload with no parameters has this guarantee. See remarks at
                    // https://docs.microsoft.com/en-us/dotnet/api/system.diagnostics.process.waitforexit?view=netframework-4.8
                    var done = new ManualResetEventSlim(false);
                    var elapsed = Stopwatch.StartNew();
                    process.Exited += (s, e) =>
                    {
                        done.Set();
                        elapsed.Stop();
                    };

                    process.Start();

                    process.BeginOutputReadLine();
                    process.BeginErrorReadLine();

                    startEvent.Set();


                    // Wait for the process to exit, allowing for cancellation every 100 ms
                    while (process.WaitForExit(100) == false)
                        if (TapThread.Current.AbortToken.IsCancellationRequested)
                            break;

                    while (process.HasExited == false && done.WaitHandle.WaitOne(100) == false)
                    {
                        if (process.HasExited)
                            break;

                        if (TapThread.Current.AbortToken.IsCancellationRequested)
                            break;
                    }

                    if (TapThread.Current.AbortToken.IsCancellationRequested)
                    {
                        try
                        {
                            process.WaitForExit(500);
                        }
                        catch
                        {
                            // ok
                        }
                    }

                    ExitCode = process.HasExited ? process.ExitCode : -1;
                    if (elapsed.Elapsed.TotalMilliseconds < timeoutMs || timeoutMs == 0)
                    {
                        var resultData = output.ToString();

                        ProcessOutput(resultData);
                        if (CheckExitCode)
                        {
                            if (ExitCode != 0)
                                UpgradeVerdict(Verdict.Fail);
                            else
                                UpgradeVerdict(Verdict.Pass);
                        }
                    }
                    else
                    {
                        process.OutputDataReceived -= OutputDataRecv;
                        process.ErrorDataReceived -= ErrorDataRecv;

                        var resultData = output.ToString();

                        ProcessOutput(resultData);

                        if (!TapThread.Current.Parent.AbortToken.IsCancellationRequested)
                        {
                            Log.Info("Timed out while waiting for process to end.");
                            Verdict = Verdict.Fail;
                        }
                        else
                        {
                            TapThread.ThrowIfAborted();
                        }
                    }
                }
            }
            else
            {
                TapThread.Start(() =>
                {
                    using (process)
                    using(abortRegistration)
                    {
                        process.Start();
                        process.WaitForExit();
                    }
                });
            }
        }

        void OutputDataRecv(object sender, DataReceivedEventArgs e)
        {
            try
            {
                if (e.Data != null)
                {
                    if(AddToLog)
                        Log.Info("{0}{1}", prepend, e.Data);
                    lock(output)
                        output.AppendLine(e.Data);
                }
            }
            catch (ObjectDisposedException)
            {
                // Suppress - Test plan has been aborted and process is disconnected
            }
        }

        void ErrorDataRecv(object sender, DataReceivedEventArgs e)
        {
            try
            {
                if (e.Data != null)
                {
                    if(AddToLog)
                        Log.Error("{0}{1}", prepend, e.Data);
                    lock(output)
                        output.AppendLine(e.Data);
                }
            }
            catch (ObjectDisposedException)
            {
                // Suppress - Test plan has been aborted and process is disconnected
            }
        }
    }
}