path: root/Software/Visual_Studio/FSE/Modules/Tango.FSE.Stubs/ProcedureContext.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reactive.Concurrency;
using System.Reactive.Linq;
using System.Reflection;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Google.Protobuf;
using Tango.Core;
using Tango.Core.DI;
using Tango.Core.ExtensionMethods;
using Tango.Core.Threading;
using Tango.FSE.Common.Connection;
using Tango.FSE.Common.Diagnostics;
using Tango.FSE.Common.Notifications;
using Tango.FSE.Common.Threading;
using Tango.FSE.Procedures.Dialogs;
using Tango.Integration.Operation;
using Tango.PMR;
using Tango.Scripting.Basic;

namespace Tango.FSE.Procedures
{
    public class ProcedureContext : IProcedureContext
    {
        private IProcedureLogger _logger;
        private ProcedureProject _project;
        private Dictionary<String, ProcedureInput> _inputs;
        private DiagnosticsFrame _lastDiagnosticsFrame;

        [TangoInject]
        private IMachineProvider MachineProvider { get; set; }

        [TangoInject]
        private INotificationProvider NotificationProvider { get; set; }

        [TangoInject]
        private IDispatcherProvider DispatcherProvider { get; set; }

        [TangoInject]
        private IDiagnosticsProvider DiagnosticsProvider { get; set; }

        public ReadOnlyCollection<Result> Results { get; private set; }

        public ProcedureContext(ProcedureProject project, IProcedureLogger logger)
        {
            _project = project;
            _inputs = new Dictionary<string, ProcedureInput>();

            foreach (var input in _project.Inputs)
            {
                _inputs.Add(input.Key, input);
            }

            _logger = logger;
            Results = new ReadOnlyCollection<Result>(new List<Result>());
            TangoIOC.Default.Inject(this);
        }

        public IMessage Send(string messageName, int? timeout = null, params object[] args)
        {
            var stubType = MessageFactory.GetAvailableRequestStubs().SingleOrDefault(x => x.Name.ToLower() == messageName.ToLower() || x.Name.Replace("Request", "").ToLower() == messageName.ToLower());
            if (stubType == null)
            {
                throw new ArgumentException("Invalid stub '" + messageName + "'.");
            }

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

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

            Object request = Activator.CreateInstance(stubType);

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

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

            return Send(request as IMessage, timeout);
        }

        public T Send<T>(string messageName, int? timeout = null, params object[] args) where T : class, IMessage
        {
            return Send(messageName, timeout, args) as T;
        }

        public IMessage Send(IMessage message, int? timeout = null)
        {
            TimeSpan? timespan = null;

            if (timeout != null)
            {
                timespan = TimeSpan.FromMilliseconds(timeout.Value);
            }

            return MachineProvider.MachineOperator.SendRequest(message, new Transport.TransportRequestConfig()
            {
                Timeout = timespan,
            }).Result;
        }

        public T Send<T>(IMessage messageName, int? timeout = null) where T : class, IMessage
        {
            return Send(messageName, timeout) as T;
        }

        public void SendContinuous<T>(IMessage messageName, Action<T> callback, int? timeout = null) where T : class, IMessage
        {
            TaskCompletionSource<object> completion = new TaskCompletionSource<object>();

            TimeSpan? timespan = null;

            if (timeout != null)
            {
                timespan = TimeSpan.FromMilliseconds(timeout.Value);
            }

            MachineProvider.MachineOperator.SendContinuousRequest(messageName, new Transport.TransportContinuousRequestConfig()
            {
                Timeout = timespan,
                ContinuousTimeout = timespan
            }).ObserveOn(new NewThreadScheduler()).Subscribe((msg) =>
            {
                try
                {
                    callback?.Invoke(msg as T);
                }
                catch { }
            }, (ex) =>
            {
                completion.SetException(ex);
            }, () =>
            {
                completion.SetResult(true);
            });

            completion.Task.GetAwaiter().GetResult();
        }

        public void SendContinuous<T>(string messageName, Action<T> callback, int? timeout = null, params object[] args) where T : class, IMessage
        {
            var stubType = MessageFactory.GetAvailableRequestStubs().SingleOrDefault(x => x.Name.ToLower() == messageName.ToLower() || x.Name.Replace("Request", "").ToLower() == messageName.ToLower());
            if (stubType == null)
            {
                throw new ArgumentException("Invalid stub '" + messageName + "'.");
            }

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

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

            IMessage request = Activator.CreateInstance(stubType) as IMessage;

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

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

            SendContinuous<IMessage>(request, callback as Action<IMessage>, timeout);
        }

        public void WriteLine(object obj)
        {
            String line = "null";

            if (obj != null)
            {
                if (!obj.GetType().IsValueTypeOrString())
                {
                    line = obj.ToJsonString();
                }
                else
                {
                    line = obj.ToString();
                }
            }

            _logger?.WriteLine(line);
        }

        public void Write(object obj)
        {
            String line = "null";

            if (obj != null)
            {
                if (obj.GetType().IsClass)
                {
                    line = obj.ToJsonString();
                }
                else
                {
                    line = obj.ToString();
                }
            }

            _logger?.WriteLine(line);
        }

        public void WriteLineHex(object number, int digits)
        {
            _logger?.WriteLine("#" + Convert.ToInt32(number).ToString("X" + digits.ToString()));
        }

        public void WriteHex(object number, int digits)
        {
            _logger?.Write("#" + Convert.ToInt32(number).ToString("X" + digits.ToString()));
        }

        public void Clear()
        {
            _logger?.Clear();
        }

        public void WriteToFile(string filePath, string content)
        {
            File.WriteAllText(filePath, content);
        }

        public void AppendToFile(string filePath, string content)
        {
            File.AppendAllText(filePath, content);
        }

        public Result AddResult(ResultType type, string name, object value)
        {
            var result = new Result(type, name, value);
            return AddResult(result);
        }

        public Result AddGraphResult(ResultType type, string name, IEnumerable<double> values)
        {
            return AddResult(new Result()
            {
                IsGraph = true,
                Name = name,
                Type = type,
                Value = values,
            });
        }

        public Result AddResult(Result result)
        {
            List<Result> results = new List<Result>(Results);
            results.Add(result);
            Results = new ReadOnlyCollection<Result>(results);
            return result;
        }

        public void RemoveResult(Result result)
        {
            List<Result> results = new List<Result>(Results);
            results.Remove(result);
            Results = new ReadOnlyCollection<Result>(results);
        }

        public void ClearResults()
        {
            Results = new ReadOnlyCollection<Result>(new List<Result>());
        }

        public T GetInput<T>(string key)
        {
            var value = GetInput(key);

            try
            {
                return (T)Convert.ChangeType(value, typeof(T));
            }
            catch
            {
                throw new InvalidCastException($"Error converting the specified input '{value}' to type '{typeof(T).Name}'.");
            }
        }

        public List<T> GetInputArray<T>(String key)
        {
            var value = GetInput(key);

            String[] arr = value.ToStringSafe().Split(',');
            var list = new List<T>(arr.Select(x => (T)Convert.ChangeType(x, typeof(T))));

            return list;
        }

        public object GetInput(string key)
        {
            ProcedureInput input = null;

            if (_inputs.TryGetValue(key, out input))
            {
                return input.Value;
            }
            else
            {
                throw new KeyNotFoundException($"Could no find input with key '{key}'.");
            }
        }

        public void Fail(string message)
        {
            throw new ProcedureFailedException(message);
        }

        public void ShowInfo(string message)
        {
            TaskCompletionSource<object> completion = new TaskCompletionSource<object>();

            DispatcherProvider.Invoke(async () =>
            {
                await NotificationProvider.ShowInfo(message);
                completion.SetResult(true);
            });

            completion.Task.GetAwaiter().GetResult();
        }

        public void ShowWarning(string message)
        {
            TaskCompletionSource<object> completion = new TaskCompletionSource<object>();

            DispatcherProvider.Invoke(async () =>
            {
                await NotificationProvider.ShowWarning(message);
                completion.SetResult(true);
            });

            completion.Task.GetAwaiter().GetResult();
        }

        public void ShowError(string message)
        {
            TaskCompletionSource<object> completion = new TaskCompletionSource<object>();

            DispatcherProvider.Invoke(async () =>
            {
                await NotificationProvider.ShowError(message);
                completion.SetResult(true);
            });

            completion.Task.GetAwaiter().GetResult();
        }

        public bool ShowQuestion(string message)
        {
            TaskCompletionSource<bool> completion = new TaskCompletionSource<bool>();

            DispatcherProvider.Invoke(async () =>
            {
                var result = await NotificationProvider.ShowQuestion(message);
                completion.SetResult(result);
            });

            return completion.Task.GetAwaiter().GetResult();
        }

        public bool ShowWarningQuestion(string message)
        {
            TaskCompletionSource<bool> completion = new TaskCompletionSource<bool>();

            DispatcherProvider.Invoke(async () =>
            {
                var result = await NotificationProvider.ShowWarningQuestion(message);
                completion.SetResult(result);
            });

            return completion.Task.GetAwaiter().GetResult();
        }

        public T RequestUserInputFor<T>(string title, string message)
        {
            return RequestUserInputFor<T>(typeof(T).IsValueTypeOrString() ? default(T) : Activator.CreateInstance<T>(), title, message);
        }

        public T RequestUserInputFor<T>(T model, string title, string message)
        {
            Object obj = model;

            if (typeof(T) == typeof(String) && model == null)
            {
                obj = "";
            }

            UserInputDialogViewVM vm = new UserInputDialogViewVM(title, message, obj);
            vm.Init();

            TaskCompletionSource<Object> completion = new TaskCompletionSource<Object>();

            DispatcherProvider.Invoke(async () =>
            {
                await NotificationProvider.ShowDialog(vm);
                completion.SetResult(obj);
            });

            var result = completion.Task.GetAwaiter().GetResult();
            vm.FinalizeModel();
            return (T)vm.Model;
        }

        public void WriteLineArray(IEnumerable array, ArrayParsingStyle style)
        {
            String line = String.Empty;

            List<Object> list = new List<object>();

            foreach (var item in array)
            {
                list.Add(item);
            }

            if (style == ArrayParsingStyle.Comma)
            {
                line = String.Join(", ", list.Select(x => x.ToStringSafe()));
            }
            else
            {
                foreach (var item in list)
                {
                    line += $"[{item.ToStringSafe()}] ";
                }
            }

            WriteLine(line);
        }

        public DiagnosticsPackage GetDiagnosticsPackage(bool waitForNext = false)
        {
            if (waitForNext)
            {
                Stopwatch watch = new Stopwatch();
                watch.Start();

                while (_lastDiagnosticsFrame == DiagnosticsProvider.CurrentFrame)
                {
                    Thread.Sleep(10);

                    if (watch.Elapsed.TotalSeconds > 5)
                    {
                        throw new TimeoutException("Diagnostics package did not arrive within the given time of 5 seconds.");
                    }
                }
            }

            _lastDiagnosticsFrame = DiagnosticsProvider.CurrentFrame;

            return DiagnosticsProvider.CurrentFrame.ToPackage();
        }

        public void Sleep(int milliseconds)
        {
            Thread.Sleep(milliseconds);
        }

        public Thread RunAsync(Action action)
        {
            return ThreadFactory.StartNew(action);
        }

        public string GetFileText(string path)
        {
            return File.ReadAllText(path);
        }

        public byte[] GetFileBytes(string path)
        {
            return File.ReadAllBytes(path);
        }

        public String RequestFileOpen(string message, string extension = "*.*")
        {
            OpenFileDialogViewVM vm = new OpenFileDialogViewVM(message, extension);

            TaskCompletionSource<String> completion = new TaskCompletionSource<String>();

            DispatcherProvider.Invoke(async () =>
            {
                await NotificationProvider.ShowDialog(vm);
                completion.SetResult(vm.SelectedFile);
            });

            var result = completion.Task.GetAwaiter().GetResult();
            return result;
        }

        public string RequestFileSave(string message, string extension = "*.*", string defaultFileName = null)
        {
            SaveFileDialogViewVM vm = new SaveFileDialogViewVM(message, extension, defaultFileName);

            TaskCompletionSource<String> completion = new TaskCompletionSource<String>();

            DispatcherProvider.Invoke(async () =>
            {
                await NotificationProvider.ShowDialog(vm);
                completion.SetResult(vm.SelectedFile);
            });

            var result = completion.Task.GetAwaiter().GetResult();
            return result;
        }

        public void UpdateProgress(string message, bool isIndeterminate = true, double value = 0, double maximum = 100)
        {
            Progress?.Invoke(this, new TangoProgressChangedEventArgs<double>()
            {
                Progress = new TangoProgress<double>()
                {
                    IsIndeterminate = isIndeterminate,
                    Message = message,
                    Maximum = maximum,
                    Value = value
                },
            });
        }

        public event EventHandler<TangoProgressChangedEventArgs<double>> Progress;
    }
}