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

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
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.DI;
using Tango.Core.ExtensionMethods;
using Tango.FSE.Common.Connection;
using Tango.FSE.Common.Notifications;
using Tango.FSE.Common.Threading;
using Tango.FSE.Stubs.Dialogs;
using Tango.Integration.Operation;
using Tango.PMR;
using Tango.Scripting.Basic;

namespace Tango.FSE.Stubs
{
    public class TestContext : ITestContext
    {
        private ITestLogger _logger;
        private TestProject _project;
        private Dictionary<String, TestInput> _inputs;

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

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

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

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

        public TestContext(TestProject project, ITestLogger logger)
        {
            _project = project;
            _inputs = new Dictionary<string, TestInput>();

            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 Run(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 Run(request as IMessage, timeout);
        }

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

        public IMessage Run(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 Run<T>(IMessage messageName, int? timeout = null) where T : class, IMessage
        {
            return Run(messageName, timeout) as T;
        }

        public void RunContinuous<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 RunContinuous<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);
                }
            }

            RunContinuous<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 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)
        {
            TestInput 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 TestFailedException(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>(Activator.CreateInstance<T>(), title, message);
        }

        public T RequestUserInputFor<T>(T model, string title, string message)
        {
            UserInputDialogViewVM vm = new UserInputDialogViewVM(title, message, model);
            vm.Init();

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

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

            var result = completion.Task.GetAwaiter().GetResult();
            vm.FinalizeModel();
            return 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);
        }
    }
}