using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.IO.Pipes;
using System.Linq;
using System.Reflection;
using System.Security.Principal;
using System.Threading;
using System.Threading.Tasks;
using OpenTap.Diagnostic;

namespace OpenTap
{
    /// <summary>
    /// This is an abstraction for running child processes with support for elevation.
    /// It executes a test step (which can have child test steps) in a new process
    /// It supports subscribing to log events from the child process, and forwarding the logs directly.
    /// </summary>
    class SubProcessHost
    {
        public bool ForwardLogs { get; set; } 
        public string LogHeader { get; set; } = "";
        public bool Unlocked { get; set; } = false;
        public HashSet<string> MutedSources { get; } = new HashSet<string>();

        public static bool IsAdmin()
        {
            if (OperatingSystem.Current == OperatingSystem.Windows)
            {
                using (WindowsIdentity identity = WindowsIdentity.GetCurrent())
                {
                    WindowsPrincipal principal = new WindowsPrincipal(identity);
                    return principal.IsInRole(WindowsBuiltInRole.Administrator);
                }
            }
            else // assume UNIX
            {
                // id -u should print '0' if running as sudo or the current user is root
                var pInfo = new ProcessStartInfo()
                {
                    FileName = "id",
                    Arguments = "-u",
                    UseShellExecute = false,
                    CreateNoWindow = true,
                    RedirectStandardOutput = true,
                };

                using (var p = Process.Start(pInfo))
                {
                    if (p == null) return false;
                    var output = p.StandardOutput.ReadToEnd().Trim();
                    if (int.TryParse(output, out var id) && id == 0)
                        return true;
                    return false;
                }
            }
        }

        private static readonly TraceSource log = Log.CreateSource(nameof(SubProcessHost));
        internal Process LastProcessHandle;

        private static readonly object StdoutLock = new object();
        private static bool stdoutSuspended;
        private static TextWriter originalOut;
        private static StringWriter tmpOut;

        private static void SuspendStdout()
        {
            lock (StdoutLock)
            {
                if (stdoutSuspended) return;
                originalOut = Console.Out;
                tmpOut = new StringWriter();
                Console.SetOut(tmpOut);
                originalOut.Flush();
                stdoutSuspended = true;
            }
        }

        private static void ResumeStdout()
        {
            lock (StdoutLock)
            {
                if (stdoutSuspended == false) return;
                // Restore stdout after the server has connected
                Console.SetOut(originalOut);
                var lines = tmpOut.ToString()
                    .Split([Environment.NewLine], StringSplitOptions.RemoveEmptyEntries);

                foreach (var line in lines)
                {
                    Console.WriteLine(line);
                }

                stdoutSuspended = false;
                tmpOut.Dispose();
                tmpOut = null;
            }
        }

        public Verdict Run(ITestStep step, bool elevate, CancellationToken token)
        {
            var plan = new TestPlan();
            plan.ChildTestSteps.Add(step);
            try
            {
                return Run(plan, elevate, token);
            }
            catch (Win32Exception ex)
            {
                // This happens when the UAC dialog is cancelled. It should be treated as an OperationCanceledException.
                if (ex.Message.Contains("The operation was canceled by the user"))
                    throw new OperationCanceledException(ex.Message);
                throw;
            }
        }

        public Verdict Run(TestPlan step, bool elevate, CancellationToken token)
        {
            var dotnet = ExecutorClient.Dotnet;
            var tapDll = Path.Combine(ExecutorClient.ExeDir, "tap.dll");
            var handle = Guid.NewGuid().ToString();
            var pInfo = new ProcessStartInfo(dotnet)
            {
                Arguments = $"\"{tapDll}\" {nameof(ProcessCliAction)} --PipeHandle \"{handle}\"",
                CreateNoWindow = true,
                WindowStyle = ProcessWindowStyle.Hidden,
                RedirectStandardOutput = true,
                RedirectStandardError = true,
                UseShellExecute = false,
            };

            if (elevate)
            {
                if (OperatingSystem.Current == OperatingSystem.Linux)
                {
                    // -E preserves environment variables
                    pInfo.Arguments = $"-E \"{pInfo.FileName}\" {pInfo.Arguments}";
                    pInfo.FileName = "sudo";
                    if (SudoHelper.IsSudoAuthenticated() == false)
                        if (SudoHelper.Authenticate() == false)
                            throw new Exception($"User failed to authenticate as sudo.");
                }
                else
                {
                    pInfo.Verb = "runas";
                    pInfo.UseShellExecute = true;
                    pInfo.RedirectStandardOutput = false;
                    pInfo.RedirectStandardError = false;
                }
            }

            SuspendStdout();

            using var p = Process.Start(pInfo);
            LastProcessHandle = p ?? throw new Exception($"Failed to spawn process.");

            // Ensure the process is cleaned up
            TapThread.Current.AbortToken.Register(() =>
            {
                if (p.HasExited) return;

                try
                {
                    // process.Kill may throw if it has already exited.
                    p.Kill();
                }
                catch (Exception ex)
                {
                    log.Warning("Caught exception when killing process. {0}", ex.Message);
                }
            });

            try
            {
                var server = new NamedPipeServerStream(handle, PipeDirection.InOut, 1);
                try
                {
                    server.WaitForConnectionAsync(token).Wait(token);
                }
                catch (OperationCanceledException)
                {
                    throw new OperationCanceledException($"Process cancelled by the user.");
                }
                // Resume stdout after the server has connected as we now know the application has launched
                ResumeStdout();

                server.WriteMessage(step);


                while (server.IsConnected && p.HasExited == false)
                {
                    if (token.IsCancellationRequested)
                        throw new OperationCanceledException($"Process cancelled by the user.");

                    if (server.TryReadMessage<Event[]>(out var events) && ForwardLogs)
                    {
                        if (string.IsNullOrWhiteSpace(LogHeader) == false)
                        {
                            for(int i = 0; i < events.Length; i++)
                                events[i].Message = LogHeader + ": " + events[i].Message;
                        }

                        var _evt = events;
                        if (MutedSources.Any())
                        {
                            _evt = events.Where(e => !MutedSources.Contains(e.Source)).ToArray();
                        }
                        _evt.ForEach(((ILogContext2)Log.Context).AddEvent);
                    }
                }

                var processExitTask = Task.Run(() => p.WaitForExit(), token);
                var tokenCancelledTask = Task.Run(() => token.WaitHandle.WaitOne(), token);

                Task.WaitAny(processExitTask, tokenCancelledTask);
                if (token.IsCancellationRequested)
                {
                    throw new OperationCanceledException($"Process cancelled by the user.");
                }

                return (Verdict) p.ExitCode;
            }
            finally
            {
                ResumeStdout();
                if (p.HasExited == false)
                {
                    p.Kill();
                }
            }
        }
    }
}