path: root/Software/Visual_Studio/Tango.Integration/ExternalBridge/ExternalBridgeService.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Google.Protobuf;
using Tango.BL.Entities;
using Tango.Integration.Operation;
using Tango.PMR;
using Tango.PMR.Common;
using Tango.Transport;
using Tango.Transport.Transporters;
using Tango.PMR.Integration;
using Tango.Transport.Discovery;
using Tango.Transport.Servers;
using Tango.Transport.Adapters;
using Tango.PMR.Connection;
using Tango.PMR.Diagnostics;
using Tango.PMR.Debugging;
using System.Security.Authentication;
using Tango.Settings;
using Tango.Core.ExtensionMethods;
using Tango.PMR.MachineStatus;
using Tango.PMR.Power;
using Tango.Core;
using Microsoft.AspNet.SignalR.Client;
using Tango.Integration.ExternalBridge.Web;

namespace Tango.Integration.ExternalBridge
{
    public class ExternalBridgeService : ExtendedObject, IExternalBridgeService
    {
        private List<ExternalBridgeReceiver> _receivers;
        private UdpDiscoveryService<ExternalBridgeUdpDiscoveryPacket> _discoveryService;
        private TcpServer _tcpServer;
        private int _discovery_port = 8888; //Will be overridden by settings in constructor..
        private int _external_bridge_port = 1984; //Will be overridden by settings in constructor..
        private HubConnection _connection;
        private IHubProxy _proxy;

        #region Events

        /// <summary>
        /// Occurs when a new client is waiting for authentication.
        /// </summary>
        public event EventHandler<ExternalBridgeClientConnectedEventArgs> ConnectionRequest;

        /// <summary>
        /// Occurs when the last client has been disconnected.
        /// </summary>
        public event EventHandler FullControlSessionDisconnected;

        /// <summary>
        /// Occurs when the service has received a new color profile request.
        /// </summary>
        public event EventHandler<ColorProfileRequestEventArgs> ColorProfileRequest;

        #endregion

        #region Properties

        /// <summary>
        /// Gets or sets the SignalR configuration.
        /// </summary>
        public ExternalBridgeSignalRConfiguration SignalRConfiguration { get; set; }

        private IMachineOperator _machineOperator;
        /// <summary>
        /// Gets or sets the machine operator.
        /// </summary>
        public IMachineOperator MachineOperator
        {
            get { return _machineOperator; }
            set { _machineOperator = value; OnMachineOperatorChanged(); }
        }

        private Machine _machine;
        /// <summary>
        /// Gets or sets the machine.
        /// </summary>
        public Machine Machine
        {
            get { return _machine; }
            set { _machine = value; OnMachineChanged(); }
        }

        /// <summary>
        /// Gets a value indicating whether this instance is started.
        /// </summary>
        public bool IsStarted { get; private set; }

        private bool _enabled;
        /// <summary>
        /// Gets or sets a value indicating whether this <see cref="IExternalBridgeService" /> is enabled.
        /// </summary>
        public bool Enabled
        {
            get { return _enabled; }
            set
            {
                _enabled = value;

                if (_enabled)
                {
                    Start();
                }
                else
                {
                    Stop();
                }

                RaisePropertyChangedAuto();
            }
        }

        private bool _hasSessions;
        /// <summary>
        /// Gets a value indicating whether there are any connected sessions.
        /// </summary>
        public bool HasSessions
        {
            get { return _hasSessions; }
            private set { _hasSessions = value; RaisePropertyChangedAuto(); }
        }

        private ExternalBridgeReceiver _fullControlSessionReceiver;
        /// <summary>
        /// Gets the current full control session receiver.
        /// </summary>
        public ExternalBridgeReceiver FullControlSessionReceiver
        {
            get { return _fullControlSessionReceiver; }
            private set { _fullControlSessionReceiver = value; RaisePropertyChangedAuto(); }
        }


        #endregion

        #region Constructors

        /// <summary>
        /// Initializes a new instance of the <see cref="ExternalBridgeService"/> class.
        /// </summary>
        public ExternalBridgeService()
        {
            SignalRConfiguration = new ExternalBridgeSignalRConfiguration();

            _receivers = new List<ExternalBridgeReceiver>();

            var settings = SettingsManager.Default.GetOrCreate<IntegrationSettings>();

            _discovery_port = settings.ExternalBridgeServiceDiscoveryPort;
            _external_bridge_port = settings.ExternalBridgeServicePort;

            _tcpServer = new TcpServer(_external_bridge_port);
            _tcpServer.ClientConnected += _tcpServer_ClientConnected;

            LogManager.NewLog += LogManager_NewLog;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ExternalBridgeService"/> class.
        /// </summary>
        /// <param name="machineOperator">The machine operator.</param>
        /// <param name="machine">The machine.</param>
        public ExternalBridgeService(IMachineOperator machineOperator, Machine machine) : this()
        {
            Machine = machine;
            MachineOperator = machineOperator;
        }

        #endregion

        #region Properties Changes

        /// <summary>
        /// Called when the machine has been changed
        /// </summary>
        protected virtual void OnMachineChanged()
        {
            if (_discoveryService != null && _discoveryService.IsStarted)
            {
                _discoveryService.Stop();
            }

            _discoveryService = new UdpDiscoveryService<ExternalBridgeUdpDiscoveryPacket>(_discovery_port, new ExternalBridgeUdpDiscoveryPacket()
            {
                SerialNumber = Machine.SerialNumber,
            });

            _discoveryService.BeforeBroadcasting -= _discoverySevice_BeforeBroadcasting;
            _discoveryService.BeforeBroadcasting += _discoverySevice_BeforeBroadcasting;
        }

        private void _discoverySevice_BeforeBroadcasting(object sender, ExternalBridgeUdpDiscoveryPacket e)
        {
            e.Time = DateTime.Now.ToString("dd/MM/yyyy HH:mm:ss");
        }

        /// <summary>
        /// Called when the machine operator has been changed
        /// </summary>
        protected virtual void OnMachineOperatorChanged()
        {
            if (MachineOperator != null)
            {
                MachineOperator.StatusChanged -= MachineOperator_StatusChanged;
                MachineOperator.StatusChanged += MachineOperator_StatusChanged;
                MachineOperator.PendingResponseReceived -= MachineOperator_PendingResponseReceived;
                MachineOperator.PendingResponseReceived += MachineOperator_PendingResponseReceived;
            }
        }

        #endregion

        #region Event Handlers

        /// <summary>
        /// Handles the ClientConnected event of the _tcpServer control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="ClientConnectedEventArgs"/> instance containing the event data.</param>
        private async void _tcpServer_ClientConnected(object sender, ClientConnectedEventArgs e)
        {
            LogManager.Log("External bridge TCP client connected from: " + e.Socket.GetIPAddress());
            ExternalBridgeReceiver receiver = new ExternalBridgeReceiver(e.Socket, MachineOperator);
            receiver.LoginRequest += Receiver_LoginRequest;
            receiver.ColorProfileRequest += Receiver_ColorProfileRequest;
            receiver.Disconnected += Receiver_Disconnected;
            _receivers.Add(receiver);
            await receiver.Connect();
        }

        private async void OnSignalRSessionCreated(String sessionID)
        {
            LogManager.Log("External bridge SignalR client connected.");

            var adapter = new SignalRTransportAdapter(SignalRConfiguration.Address, SignalRConfiguration.Hub, SignalRTransportAdapterMode.JoinSession, Machine.SerialNumber, sessionID); ;

            ExternalBridgeReceiver receiver = new ExternalBridgeReceiver(adapter, MachineOperator);
            receiver.LoginRequest += Receiver_LoginRequest;
            receiver.ColorProfileRequest += Receiver_ColorProfileRequest;
            receiver.Disconnected += Receiver_Disconnected;
            _receivers.Add(receiver);
            await receiver.Connect();
            //await _proxy.Invoke("NotifySessionCreated");
        }

        private void MachineOperator_StatusChanged(object sender, MachineStatuses status)
        {
            try
            {
                _receivers.ToList().Where(x => x.IsLoggedInAndRequiresDiagnostics).ToList().ForEach(x => x.UpdateMachineOperatorStatus((UpdateStatus)status));
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error updating status of external bridge service client.");
            }
        }

        private void LogManager_NewLog(object sender, Tango.Logging.LogItemBase e)
        {
            var toSend = _receivers.ToList().Where(x => x.IsLoggedInAndRequiresDiagnostics && x.RequiresApplicationLogs).ToList();

            if (_receivers.Count > 0)
            {
                var msg = MessageFactory.CreateTangoMessage<StartApplicationLogsResponse>(new StartApplicationLogsResponse()
                {
                    LogItem = ByteString.CopyFrom(e.Serialize())
                });

                msg.ToBytes();

                toSend.ToList().ForEach(x => x.UpdateApplicationLogs(msg.Container));
            }
        }

        private void MachineOperator_PendingResponseReceived(object sender, MessageContainer container)
        {
            OnOperatorResponseReceived(container);
        }

        #endregion

        #region Receiver Events Handlers

        private void Receiver_Disconnected(object sender, EventArgs e)
        {
            var receiver = sender as ExternalBridgeReceiver;

            receiver.LoginRequest -= Receiver_LoginRequest;
            receiver.ColorProfileRequest -= Receiver_ColorProfileRequest;
            receiver.Disconnected -= Receiver_Disconnected;

            _receivers.Remove(receiver);

            if (receiver.LoginIntent == ExternalBridgeLoginIntent.FullControl)
            {
                FullControlSessionDisconnected?.Invoke(this, new EventArgs());
            }

            HasSessions = _receivers.Count(x => x.IsLoggedIn) > 0;

            FullControlSessionReceiver = _receivers.SingleOrDefault(x => x.IsLoggedIn && x.LoginIntent == ExternalBridgeLoginIntent.FullControl);
        }

        private void Receiver_ColorProfileRequest(object sender, ColorProfileRequestEventArgs e)
        {
            ColorProfileRequest?.Invoke(this, e);
        }

        private void Receiver_LoginRequest(object sender, ExternalBridgeReceiverLoginRequestEventArgs e)
        {
            var request = e.Request;

            if (request.Intent == ExternalBridgeLoginIntent.FullControl && _receivers.Any(x => x.IsLoggedIn && x.LoginIntent == ExternalBridgeLoginIntent.FullControl))
            {
                e.Decline("Only one full control client is allowed.");
                return;
            }

            if (request.Intent == ExternalBridgeLoginIntent.FullControl && MachineOperator.IsPrinting)
            {
                e.Decline($"External bridge client login failed because the machine is currently printing and '{ExternalBridgeLoginIntent.FullControl}' intent was requested.");
                return;
            }

            ExternalBridgeClientConnectedEventArgs args = new ExternalBridgeClientConnectedEventArgs();
            args.Request = request;
            args.Address = e.Address;
            ConnectionRequest?.Invoke(this, args);

            var response = new ExternalBridgeLoginResponse();
            response.Authenticated = args.Confirmed;
            response.SerialNumber = Machine.SerialNumber;
            response.DeviceInformation = MachineOperator.DeviceInformation;

            if (args.Confirmed)
            {
                e.Confirm(Machine, MachineOperator.DeviceInformation);
                HasSessions = true;

                if (request.Intent == ExternalBridgeLoginIntent.FullControl)
                {
                    FullControlSessionReceiver = sender as ExternalBridgeReceiver;
                }
            }
            else
            {
                e.Decline("Invalid password or intent.");
            }
        }

        #endregion

        #region Public Methods

        /// <summary>
        /// Starts this instance.
        /// </summary>
        public void Start()
        {
            if (!IsStarted)
            {
                _tcpServer.Start();
                _discoveryService.Start();

                if (SignalRConfiguration.Enabled)
                {
                    _connection = new HubConnection(SignalRConfiguration.Address);
                    _proxy = _connection.CreateHubProxy(SignalRConfiguration.Hub);
                    _proxy.On<String>("OnSessionCreated", OnSignalRSessionCreated);
                    _connection.Start();
                    _connection.StateChanged += (x) =>
                    {
                        if (x.NewState == ConnectionState.Connected)
                        {
                            _proxy.Invoke("RegisterMachine", new MachineInfo()
                            {
                                SerialNumber = Machine.SerialNumber,
                                Organization = Machine.Organization.Name,
                            });
                        }
                    };
                }

                IsStarted = true;
                _enabled = true;
                RaisePropertyChanged(nameof(Enabled));
            }
        }

        /// <summary>
        /// Stops this instance.
        /// </summary>
        public async void Stop()
        {
            if (IsStarted)
            {
                _tcpServer.Stop();
                _discoveryService.Stop();

                foreach (var receiver in _receivers.ToList())
                {
                    await receiver.Disconnect();
                }

                if (SignalRConfiguration.Enabled)
                {
                    await _proxy.Invoke("UnregisterMachine");
                    _connection.Stop();
                    _connection.Dispose();
                }

                IsStarted = false;
                HasSessions = false;
                _enabled = false;
                RaisePropertyChanged(nameof(Enabled));
            }
        }

        /// <summary>
        /// Disconnects the current remote client session.
        /// </summary>
        public async void DisconnectFullControlSession()
        {
            var sessionReceiver = _receivers.SingleOrDefault(x => x.IsLoggedIn && x.LoginIntent == ExternalBridgeLoginIntent.FullControl);
            if (sessionReceiver != null)
            {
                await sessionReceiver.Disconnect();
            }
        }

        #endregion

        #region Virtual Methods

        protected virtual void OnOperatorResponseReceived(MessageContainer container)
        {
            try
            {
                switch (container.Type)
                {
                    case MessageType.StartDiagnosticsResponse:
                        _receivers.ToList().Where(x => x.IsLoggedInAndRequiresDiagnostics && x.RequiresDiagnostics).ToList().ForEach(x => x.UpdateDiagnostics(container));
                        break;
                    case MessageType.StartDebugLogResponse:
                        _receivers.ToList().Where(x => x.IsLoggedInAndRequiresDiagnostics && x.RequiresDebugLogs).ToList().ForEach(x => x.UpdateDebugLogs(container));
                        break;
                    case MessageType.StartEventsNotificationResponse:
                        _receivers.ToList().Where(x => x.IsLoggedInAndRequiresDiagnostics && x.RequiresEventsNotification).ToList().ForEach(x => x.UpdateEvents(container));
                        break;
                    case MessageType.StartMachineStatusUpdateResponse:
                        _receivers.ToList().Where(x => x.IsLoggedInAndRequiresDiagnostics && x.RequiresMachineStatusUpdate).ToList().ForEach(x => x.UpdateMachineStatus(container));
                        break;
                }

            }
            catch { }
        }

        #endregion
    }
}