using Google.Protobuf;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Tango.PMR;
using Tango.PMR.Common;
using Tango.Stubs;
using Tango.Transport;
using Tango.Transport.Adapters;

namespace Tango.MachineStudio.Stubs
{
    /// <summary>
    /// Represents a manager capable of executing stub scripts asynchronously.
    /// </summary>
    public class StubManager
    {
        public ITransportAdapter Adapter { get; private set; }

        /// <summary>
        /// Occurs when the stub has failed to execute.
        /// </summary>
        public event EventHandler<Exception> Failed;

        /// <summary>
        /// Occurs when the stub has completed successfully.
        /// </summary>
        public event EventHandler<String> Completed;

        /// <summary>
        /// Occurs when the stub has been initialized and executed.
        /// </summary>
        public event EventHandler<String> Executed;

        /// <summary>
        /// Gets a value indicating whether this <see cref="StubManager"/> is aborted.
        /// </summary>
        internal bool Aborted { get; private set; }

        /// <summary>
        /// Initializes a new instance of the <see cref="StubManager"/> class.
        /// </summary>
        /// <param name="adapter">The adapter.</param>
        public StubManager(ITransportAdapter adapter)
        {
            Adapter = adapter;
        }

        /// <summary>
        /// Aborts the current script.
        /// </summary>
        internal void Abort()
        {
            Aborted = true;
        }

        /// <summary>
        /// Runs the specified stub name.
        /// </summary>
        /// <param name="stubName">Name of the stub.</param>
        /// <param name="args">The arguments.</param>
        public void Run(String stubName, params Object[] args)
        {
            if (Aborted) return;

            var stubType = StubBase.GetAvailableRequestStubs().SingleOrDefault(x => x.Name.ToLower() == stubName.ToLower() || x.Name.Replace("Request", "").ToLower() == stubName.ToLower());
            if (stubType == null)
            {
                OnFailed(new ArgumentException("Invalid stub '" + stubName + "'."));
                return;
            }

            var stubProps = stubType.GetProperties(BindingFlags.Public | BindingFlags.Instance);

            if (stubProps.Length > args.Length)
            {
                OnFailed(new ArgumentOutOfRangeException("Not enough arguments for " + stubType.Name + "."));
                return;
            }

            Executed?.Invoke(this, stubType.Name);

            try
            {
                MessageContainer container = new MessageContainer();
                container.Token = Guid.NewGuid().ToString();
                container.Type = MessageFactory.ParseMessageType(stubType.Name);

                Object request = Activator.CreateInstance(stubType);

                int argIndex = 0;
                foreach (var prop in stubProps)
                {
                    String arg = args[argIndex++].ToString();

                    if (prop.PropertyType == typeof(UInt32))
                    {
                        prop.SetValue(request, UInt32.Parse(arg));
                    }
                    else if (prop.PropertyType == typeof(bool))
                    {
                        prop.SetValue(request, bool.Parse(arg));
                    }
                    else
                    {
                        object converted = Convert.ChangeType(arg, prop.PropertyType);
                        prop.SetValue(request, converted);
                    }
                }

                container.Data = typeof(IMessage).GetExtensionMethod(typeof(ByteString).Assembly, "ToByteString").Invoke(request, new object[] { request }) as ByteString;

                byte[] requestData = container.ToByteArray();

                bool done = false;

                Task.Factory.StartNew(() =>
                {
                    Adapter.Write(requestData);

                    DateTime startTime = DateTime.Now;

                    MessageContainer responseContainer = null;

                    Adapter.DataAvailable += (sender, data) =>
                    {
                        responseContainer = MessageFactory.ParseContainer(data);
                    };

                    while (responseContainer == null)
                    {
                        Thread.Sleep(2);

                        if (DateTime.Now > startTime.AddSeconds(2))
                        {
                            done = true;
                            OnFailed(new TimeoutException("Response has failed to arrive after 2 seconds."));
                            return;
                        }
                    }

                    IMessage message = MessageFactory.ExtractMessageFromContainer(responseContainer);
                    OnCompleted(JsonConvert.SerializeObject(message, Formatting.Indented));
                    done = true;
                });

                while (!done)
                {
                    Thread.Sleep(2);
                }
            }
            catch (Exception ex)
            {
                OnFailed(ex);
            }
        }

        /// <summary>
        /// Raises the <see cref="Failed"/> event.
        /// </summary>
        /// <param name="ex">The exception.</param>
        protected virtual void OnFailed(Exception ex)
        {
            Failed?.Invoke(this, ex);
        }

        /// <summary>
        /// Raises the <see cref="Completed"/> event.
        /// </summary>
        /// <param name="response">The response.</param>
        protected virtual void OnCompleted(String response)
        {
            Completed?.Invoke(this, response);
        }
    }
}