using Microsoft.AspNet.SignalR;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Web;
using Tango.Integration.ExternalBridge.Web;

namespace Tango.MachineService.Hubs
{
    public class ExternalBridgeHub : Hub
    {
        private static List<ExternalBridgeInfo> _externalBridges;
        private static List<MachineSession> _sessions;

        public class ExternalBridgeInfo
        {
            public String ConnectionID { get; set; }
            public MachineInfo MachineInfo { get; set; }
        }

        public class MachineSession
        {
            public String SessionID { get; set; }
            public String ReceiverConnectionID { get; set; }
            public String ControllerConnectionID { get; set; }
            public ExternalBridgeInfo ExternalBridge { get; set; }

            public MachineSession()
            {
                SessionID = Guid.NewGuid().ToString();
            }
        }

        static ExternalBridgeHub()
        {
            _externalBridges = new List<ExternalBridgeInfo>();
            _sessions = new List<MachineSession>();
        }

        public void RegisterMachine(MachineInfo machineInfo)
        {
            _externalBridges.RemoveAll(x => x.MachineInfo.SerialNumber == machineInfo.SerialNumber);
            _sessions.RemoveAll(x => x.ExternalBridge.ConnectionID == Context.ConnectionId);

            machineInfo.IPAddress = GetIpAddress();

            _externalBridges.Add(new ExternalBridgeInfo()
            {
                MachineInfo = machineInfo,
                ConnectionID = Context.ConnectionId,
            });
        }

        public void UnregisterMachine()
        {
            _externalBridges.RemoveAll(x => x.ConnectionID == Context.ConnectionId);
            _sessions.RemoveAll(x => x.ExternalBridge.ConnectionID == Context.ConnectionId);
        }

        public String Ping()
        {
            return "Ping";
        }

        public List<MachineInfo> GetAvailableMachines()
        {
            return _externalBridges.Select(x => x.MachineInfo).ToList();
        }

        public String CreateSession(String serialNumber)
        {
            var externalBridge = _externalBridges.SingleOrDefault(x => x.MachineInfo.SerialNumber == serialNumber);

            if (externalBridge != null)
            {
                var existingSession = GetSession();

                if (existingSession != null)
                {
                    _sessions.Remove(existingSession);
                }

                MachineSession session = new MachineSession();
                session.ControllerConnectionID = Context.ConnectionId;
                session.ExternalBridge = externalBridge;
                _sessions.Add(session);
                Clients.Client(externalBridge.ConnectionID).OnSessionCreated(session.SessionID);
                return session.SessionID;
            }

            return null;
        }

        public void JoinSession(String sessionID)
        {
            var session = _sessions.SingleOrDefault(x => x.SessionID == sessionID);

            if (session != null)
            {
                session.ReceiverConnectionID = Context.ConnectionId;
                Clients.Client(session.ControllerConnectionID).SessionCreated();
            }
        }

        public void Write(List<byte[]> dataCollection)
        {
            var connectionID = GetOtherSideConnectionID();

            if (connectionID != null)
            {
                Clients.Client(connectionID).DataAvailable(dataCollection);
            }
        }

        public void LeaveSession()
        {
            var connectionID = GetOtherSideConnectionID();
            ClearSession();
            Clients.Client(connectionID).OnSessionClosed();
        }

        public override Task OnDisconnected(bool stopCalled)
        {
            _externalBridges.RemoveAll(x => x.ConnectionID == Context.ConnectionId);
            _sessions.RemoveAll(x => x.ControllerConnectionID == Context.ConnectionId || x.ReceiverConnectionID == Context.ConnectionId || x.ExternalBridge.ConnectionID == Context.ConnectionId);
            return base.OnDisconnected(stopCalled);
        }

        private void ClearSession()
        {
            _sessions.RemoveAll(x => x.ControllerConnectionID == Context.ConnectionId || x.ReceiverConnectionID == Context.ConnectionId);
        }

        private MachineSession GetSession()
        {
            return _sessions.SingleOrDefault(x => x.ReceiverConnectionID == Context.ConnectionId || x.ControllerConnectionID == Context.ConnectionId);
        }

        private String GetOtherSideConnectionID()
        {
            var session = GetSession();

            if (session != null)
            {
                String connectionID = String.Empty;

                if (session.ReceiverConnectionID == Context.ConnectionId)
                {
                    connectionID = session.ControllerConnectionID;
                }
                else
                {
                    connectionID = session.ReceiverConnectionID;
                }

                return connectionID;
            }

            return null;
        }

        protected string GetIpAddress()
        {
            try
            {
                string ipAddress;
                object tempObject;

                Context.Request.Environment.TryGetValue("server.RemoteIpAddress", out tempObject);

                if (tempObject != null)
                {
                    ipAddress = (string)tempObject;
                }
                else
                {
                    ipAddress = "";
                }

                return ipAddress;
            }
            catch
            {
                return String.Empty;
            }
        }
    }
}