using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Xunit.Runners;

namespace Codan.Argus.TestEnvironment
{
    public class ExtendedAssemblyRunner : IDisposable
    {
        private AssemblyRunner _assemblyRunner = null;
        
        public delegate void DiscoveryCompleteEventHandler(object sender, DiscoveryCompleteInfo e);
        public event DiscoveryCompleteEventHandler DiscoveryCompleteEvent;

        public delegate void ExecutionCompleteEventHandler(object sender, ExecutionCompleteInfo e);
        public event ExecutionCompleteEventHandler ExecutionCompleteEvent;

        public delegate void TestStartingEventHandler(object sender, TestStartingInfo e);
        public event TestStartingEventHandler TestStartingEvent;

        public delegate void TestSkippedEventHandler(object sender, TestSkippedInfo e);
        public event TestSkippedEventHandler TestSkippedEvent;

        public delegate void TestFailedEventHandler(object sender, TestFailedInfo e);
        public event TestFailedEventHandler TestFailedEvent;

        //public delegate void 

        static object consoleLock = new object();
        private static ManualResetEvent finished = new ManualResetEvent(false);
        private string _testAssembly = null;

        private ExecutionCompleteData _executionCompleteData = null;

        public ExtendedAssemblyRunner(string testAssembly)
        {
            _testAssembly = testAssembly;

            _assemblyRunner = AssemblyRunner.WithAppDomain(testAssembly);
        }

        public ExecutionCompleteData ExecutionCompleteData 
        {
            get { return _executionCompleteData; }
        }
        
        private void WithAppDomain(string testAssembly)
        {
           _assemblyRunner = AssemblyRunner.WithAppDomain(testAssembly);
        }

        public void Start(string testAssembly = null)
        {
            if (testAssembly == null) testAssembly = _testAssembly;

            _assemblyRunner.OnDiscoveryComplete = OnDiscoveryCompleteEvent;
            _assemblyRunner.OnExecutionComplete = OnExecutionCompleteEvent;
            _assemblyRunner.OnTestFailed = OnTestFailedEvent;
            _assemblyRunner.OnTestSkipped = OnTestSkippedEvent;
            _assemblyRunner.OnTestStarting = OnTestStartingEvent;

            _assemblyRunner.Start(typeName: null);

            finished.WaitOne();
            finished.Dispose();
        }

        public AssemblyRunnerStatus Status
        {
            get { return _assemblyRunner.Status; }
        }

        protected void OnDiscoveryCompleteEvent(DiscoveryCompleteInfo info)
        {
            lock (consoleLock)
            {
                if (DiscoveryCompleteEvent != null)
                {
                    DiscoveryCompleteEvent(this, info);
                }

#if DEBUG
                Debug.WriteLine("Discovering...");
#endif
            }
        }


        protected void OnExecutionCompleteEvent(ExecutionCompleteInfo info)
        {
            lock (consoleLock)
            {
                if (ExecutionCompleteEvent != null)
                {
                    ExecutionCompleteEvent(this, info);
                }
#if DEBUG
                Debug.WriteLine(
                    $"Finished: {info.TotalTests} tests in {Math.Round(info.ExecutionTime, 3)}s ({info.TestsFailed} failed, {info.TestsSkipped} skipped)");
#endif
                finished.Set();
            }
        }

        protected void OnTestFailedEvent(TestFailedInfo info)
        {
            lock (consoleLock)
            {
                if (this.TestFailedEvent != null)
                {
                    TestFailedEvent(this, info);
                }

#if DEBUG
                Console.ForegroundColor = ConsoleColor.Red;
                Debug.WriteLine("[FAIL] {0}: {1}", info.TestDisplayName, info.ExceptionMessage);
                if (info.ExceptionStackTrace != null)
                {
                    Debug.WriteLine(info.ExceptionStackTrace);
                }

                Console.ResetColor();
#endif
            }
        }

        protected void OnTestStartingEvent(TestStartingInfo info)
        {
            lock (consoleLock)
            {
                if (this.TestStartingEvent != null)
                {
                    TestStartingEvent(this, info);
                }
#if DEBUG
                Console.ForegroundColor = ConsoleColor.Yellow;
                Debug.WriteLine("[TESTSTARTING] {0}: {1}", info.TestDisplayName, info.MethodName);
                Console.ResetColor();
#endif
            }
        }

        protected void OnTestSkippedEvent(TestSkippedInfo info)
        {
            lock (consoleLock)
            {
                if (this.TestSkippedEvent != null)
                {
                    TestSkippedEvent(this, info);
                }
#if DEBUG
                Console.ForegroundColor = ConsoleColor.Yellow;
                Debug.WriteLine("[SKIP] {0}: {1}", info.TestDisplayName, info.SkipReason);
                Console.ResetColor();
#endif
            }
        }

        public void Dispose()
        {
            _assemblyRunner.Dispose();
            _assemblyRunner = null;
        }
    }
}