path: root/Software/Visual_Studio/FSE/Tango.FSE.UI/Connection/DefaultMachineProvider.cs

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using Tango.BL;
using Tango.BL.Entities;
using Tango.Core;
using Tango.Core.DI;
using Tango.Emulations.ExternalBridge;
using Tango.FSE.BL;
using Tango.FSE.Common.Authentication;
using Tango.FSE.Common.Connection;
using Tango.FSE.Common.Notifications;
using Tango.FSE.UI.Dialogs;
using Tango.Integration.ExternalBridge;
using Tango.Integration.Operation;
using Tango.SharedUI;
using Tango.Transport;

namespace Tango.FSE.UI.Connection
{
    public class DefaultMachineProvider : ExtendedObject, IMachineProvider
    {
        private List<EventRegistration> _eventRegistrations;

        private class EventRegistration
        {
            public Delegate Handler { get; set; }
            public EventInfo EventInfo { get; set; }

            public void RemoveHandler(Object instance)
            {
                try
                {
                    EventInfo.RemoveEventHandler(instance, Handler);
                }
                catch
                {
                    Debug.WriteLine($"Cannot remove handler '{Handler.Method.Name}' for event '{instance.GetType().Name}.{EventInfo.Name}'.");
                }
            }

            public void AddHandler(Object instance)
            {
                try
                {
                    EventInfo.AddEventHandler(instance, Handler);
                }
                catch
                {
                    Debug.WriteLine($"Cannot add handler '{Handler.Method.Name}' for event '{instance.GetType().Name}.{EventInfo.Name}'.");
                }
            }
        }

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

        [TangoInject]
        private IAuthenticationProvider AuthenticationProvider { get; set; }

        [TangoInject]
        private FSEServicesContainer Services { get; set; }

        private Machine _machine;
        /// <summary>
        /// Gets the database machine entity associated with the current machine.
        /// </summary>
        public Machine Machine
        {
            get { return _machine; }
            private set { _machine = value; RaisePropertyChangedAuto(); }
        }

        private bool _isConnected;
        /// <summary>
        /// Gets or sets a value indicating whether a machine is currently connected.
        /// </summary>
        public bool IsConnected
        {
            get { return _isConnected; }
            private set { _isConnected = value; RaisePropertyChangedAuto(); }
        }

        private bool _isBusy;
        /// <summary>
        /// Gets a value indicating whether this instance is busy connecting/disconnecting.
        /// </summary>
        public bool IsBusy
        {
            get { return _isBusy; }
            private set { _isBusy = value; RaisePropertyChangedAuto(); }
        }

        private IExternalBridgeClient _machineOperator;
        /// <summary>
        /// Gets the machine operator.
        /// </summary>
        public IExternalBridgeClient MachineOperator
        {
            get { return _machineOperator; }
            private set { _machineOperator = value; RaisePropertyChangedAuto(); }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="DefaultMachineProvider"/> class.
        /// </summary>
        public DefaultMachineProvider()
        {
            MachineOperator = new ExternalBridgeTcpClient("N/A", "N/A");
            MachineOperator.StateChanged += MachineOperator_StateChanged;
            MachineOperator.As<ExternalBridgeTcpClient>().SessionClosed += DefaultMachineProvider_SessionClosed;
        }

        /// <summary>
        /// Connects to the specified machine.
        /// </summary>
        /// <param name="machine">The machine.</param>
        /// <returns></returns>
        public async Task<bool> ConnectToMachine(IExternalBridgeClient machine)
        {
            try
            {
                IsBusy = true;

                MachineConnectionBaseViewVM vm = null;

                if (machine.GetType() == typeof(ExternalBridgeUsbClient))
                {
                    vm = await NotificationProvider.ShowDialog<MachineConnectionUsbViewVM>();
                }
                else if (machine.GetType() == typeof(EmulatorExternalBridge))
                {
                    vm = await NotificationProvider.ShowDialog<MachineConnectionEmulatorViewVM>();
                }
                else if (machine is ExternalBridgeTcpClient)
                {
                    var secureClient = machine.As<ExternalBridgeTcpClient>();

                    if (machine.GetType() == typeof(ExternalBridgeTcpClient))
                    {
                        vm = await NotificationProvider.ShowDialog(new MachineConnectionWifiViewVM(secureClient));
                    }
                    else
                    {
                        vm = await NotificationProvider.ShowDialog(new MachineConnectionSignalRViewVM(secureClient));
                    }

                    secureClient.LoginRequest = new PMR.Integration.ExternalBridgeLoginRequest()
                    {
                        AppID = "Tango FSE",
                        HostName = Environment.MachineName,
                        Password = (vm as MachineConnectionWifiViewVM).Password,
                        Intent = (vm as MachineConnectionWifiViewVM).SelectedIntent,
                        UserGuid = AuthenticationProvider.CurrentUser.Guid,
                    };
                }
                else
                {
                    throw new NotSupportedException($"The specified type {machine.GetType().Name} is not supported.");
                }

                if (vm.DialogResult)
                {
                    if (IsConnected)
                    {
                        await DisconnectMachine();
                    }

                    IsBusy = true;

                    String serial = vm.GetMachineSerialNumber();

                    using (var task = NotificationProvider.PushTaskItem($"Connecting to machine '{serial}'..."))
                    {
                        Machine = await Services.MachinesService.GetMachine(serial);

                        if (Machine == null)
                        {
                            throw new KeyNotFoundException("The specified machine was not found on the database.");
                        }

                        ReassignEventHandlers(MachineOperator, machine);
                        MachineOperator = machine;

                        ApplyOperatorSettings();

                        await MachineOperator.Connect();

                        IsConnected = true;
                        return true;
                    }
                }
                else
                {
                    return false;
                }
            }
            catch
            {
                throw;
            }
            finally
            {
                IsBusy = false;
            }
        }

        /// <summary>
        /// Disconnects the current connected machine.
        /// </summary>
        /// <returns></returns>
        public async Task DisconnectMachine()
        {
            if (IsConnected)
            {
                using (var task = NotificationProvider.PushTaskItem("Disconnecting from current machine..."))
                {
                    try
                    {
                        IsBusy = true;
                        Machine = null;
                        await MachineOperator.Disconnect();
                    }
                    catch (Exception ex)
                    {
                        LogManager.Log(ex, "Error disconnecting from machine.");
                    }
                    finally
                    {
                        IsConnected = false;
                        IsBusy = false;
                    }
                }
            }
        }

        #region Machine Operator Event Handlers

        private void MachineOperator_StateChanged(object sender, TransportComponentState state)
        {
            if (IsConnected && state == TransportComponentState.Failed)
            {
                IsConnected = false;

                InvokeUI(async () =>
                {
                    var vm = await NotificationProvider.ShowDialog<MachineConnectionLostViewVM>(new MachineConnectionLostViewVM(MachineOperator, MachineOperator.FailedStateException.FlattenMessage(), 10));

                    if (vm.DialogResult)
                    {
                        try
                        {
                            IsBusy = true;
                            using (var task = NotificationProvider.PushTaskItem($"Reconnecting to machine '{Machine.SerialNumber}'..."))
                            {
                                await Task.Delay(2000);
                                await MachineOperator.Connect();
                                IsConnected = true;
                            }
                        }
                        catch (Exception ex)
                        {
                            await NotificationProvider.ShowError($"Failed to reconnect to the last connected machine.\n{ex.FlattenMessage()}");
                        }
                        finally
                        {
                            IsBusy = false;
                        }
                    }
                });
            }
        }

        private void DefaultMachineProvider_SessionClosed(object sender, EventArgs e)
        {
            IsConnected = false;

            InvokeUI(() =>
            {
                NotificationProvider.ShowError("The connection has been terminated by the remote machine.");
            });
        }

        #endregion

        private void ApplyOperatorSettings()
        {
            MachineOperator.EnableDiagnostics = true;
            MachineOperator.EnableMachineStatusUpdates = true;
            MachineOperator.EnableEmbeddedDebugging = true;
            MachineOperator.EnableEventsNotification = true;
            MachineOperator.UseKeepAlive = true;
            MachineOperator.JobUnitsMethod = JobUnitsMethods.Device;
            MachineOperator.JobRunsLogger.JobSource = Tango.BL.Enumerations.JobSource.Remote;
            MachineOperator.RequestTimeout = TimeSpan.FromSeconds(5);
            MachineOperator.ContinuousRequestTimeout = TimeSpan.FromSeconds(5);
        }

        /// <summary>
        /// Reassigns the event handlers from the previous connected machine to a new one.
        /// </summary>
        /// <param name="oldInstance">The old instance.</param>
        /// <param name="newInstance">The new instance.</param>
        /// <exception cref="NullReferenceException"></exception>
        private void ReassignEventHandlers(IMachineOperator oldInstance, IMachineOperator newInstance)
        {
            if (_eventRegistrations == null)
            {
                _eventRegistrations = GetEventsRegistrations(oldInstance);
            }

            foreach (var registration in _eventRegistrations)
            {
                registration.RemoveHandler(oldInstance);
                registration.AddHandler(newInstance);
            }
        }

        private List<EventRegistration> GetEventsRegistrations(IMachineOperator instance)
        {
            List<EventRegistration> registrations = new List<EventRegistration>();

            var instanceEvents = instance.GetType().GetEvents(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static).ToList();

            foreach (var ev in instanceEvents)
            {
                if (ev.IsMulticast)
                {

                    FieldInfo eventField = null;
                    Type type = instance.GetType();

                    while (eventField == null)
                    {
                        eventField = type.GetField(ev.Name, BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Static);

                        if (eventField == null)
                        {
                            type = type.BaseType;
                        }

                        if (type == typeof(Object))
                        {
                            break;
                        }
                    }

                    if (eventField == null)
                    {
                        throw new NullReferenceException($"Could not locate event field for '{ev.Name}'.");
                    }

                    var eventDelegate = (MulticastDelegate)type.GetField(ev.Name, BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Static).GetValue(instance);

                    if (eventDelegate != null)
                    {
                        foreach (var handler in eventDelegate.GetInvocationList())
                        {
                            registrations.Add(new EventRegistration()
                            {
                                EventInfo = ev,
                                Handler = handler,
                            });
                        }
                    }
                }
            }

            return registrations;
        }
    }
}