final update

Website/LOC.Website.Common/GameServerMonitor.cs

@@ -0,0 +1,161 @@
+namespace LOC.Website.Common
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Data.Entity;
+    using System.Linq;
+    using System.Timers;
+    using Contexts;
+    using Core.Model.Account;
+    using Core.Model.GameServer;
+    using Core.Tokens.Client;
+
+    public class GameServerMonitor : IGameServerMonitor
+    {
+        public static GameServerMonitor Instance = new GameServerMonitor();
+
+        private readonly Dictionary<int, DisplayServer> _displayServers;
+        private readonly Dictionary<int, ServerHistory> _activeServerStatuses;
+        private readonly Dictionary<int, ServerUpdate> _activeServerUpdates;
+        private readonly Dictionary<int, int> _accountServerMapping;
+
+        private readonly Timer _cleanUpTimer;
+
+        protected GameServerMonitor()
+        {
+            _displayServers = new Dictionary<int, DisplayServer>();
+            _activeServerStatuses = new Dictionary<int, ServerHistory>();
+            _activeServerUpdates = new Dictionary<int, ServerUpdate>();
+            _accountServerMapping = new Dictionary<int, int>();
+
+            _cleanUpTimer = new Timer();
+            _cleanUpTimer.Interval = 60000;
+            _cleanUpTimer.Elapsed += CleanUpTick;
+            _cleanUpTimer.AutoReset = true;
+        }
+
+        public List<DisplayServer> ServerStatuses { get { return _displayServers.Values.ToList(); } }
+
+        public void Track(Server server)
+        {
+            ClearServerUpdates(server.ServerId);
+
+            _displayServers.Remove(server.ServerId);
+            _displayServers.Add(server.ServerId, new DisplayServer(server, new ServerHistory(), (long)new TimeSpan(DateTime.Now.ToUniversalTime().Ticks - new DateTime(1970, 1, 1).Ticks).TotalMilliseconds));
+
+            if (!_cleanUpTimer.Enabled)
+            {
+                _cleanUpTimer.Enabled = true;
+                _cleanUpTimer.Start();
+            }
+        }
+
+        public void UnTrack(Server server)
+        {
+            _activeServerUpdates.Remove(server.ServerId);
+            _displayServers.Remove(server.ServerId);
+        }
+
+        public ServerUpdate GetServerUpdate(int serverId)
+        {
+            ServerUpdate serverUpdates;
+            _activeServerUpdates.TryGetValue(serverId, out serverUpdates);
+            
+            return serverUpdates;
+        }
+
+        public ServerUpdate GetServerUpdatesFor(int serverId)
+        {
+            return GetServerUpdate(serverId);
+        }
+
+        public void ClearServerUpdates(int serverId)
+        {
+            _activeServerUpdates.Remove(serverId);
+            _activeServerUpdates.Add(serverId, new ServerUpdate());
+        }
+        
+        public void AccountChanged(int accountId)
+        {
+            if (_accountServerMapping.ContainsKey(accountId))
+            {
+                int serverId;
+                if (_accountServerMapping.TryGetValue(accountId, out serverId))
+                {
+                    var serverUpdates = GetServerUpdate(serverId);
+
+                    if (serverUpdates != null)
+                    {
+                        using (var context = new LocContext())
+                        {
+                            serverUpdates.ClientTokens.Add(new ClientToken(context.Accounts.Include(x => x.Rank).Include(x => x.PvpTransactions).Single(x => x.AccountId == accountId)));
+                        }
+                    }
+                }
+            }
+        }
+
+        public void PlayerLoggedIn(Account account, int serverId)
+        {
+            _accountServerMapping.Remove(account.AccountId);
+            _accountServerMapping.Add(account.AccountId, serverId);
+        }
+
+        public void PlayerLoggedOut(Account account)
+        {
+            int serverId;
+
+            if (_accountServerMapping.TryGetValue(account.AccountId, out serverId))
+            {
+                _accountServerMapping.Remove(account.AccountId);
+
+                ServerUpdate serverUpdates;
+                _activeServerUpdates.TryGetValue(serverId, out serverUpdates);
+
+                if (serverUpdates != null && serverUpdates.ClientTokens.Any(x => x.AccountId == account.AccountId))
+                {
+                    serverUpdates.ClientTokens.Remove(serverUpdates.ClientTokens.First(x  => x.AccountId == account.AccountId));
+
+                    _activeServerUpdates.Remove(serverId);
+                    _activeServerUpdates.Add(serverId, serverUpdates);
+                }
+            }
+        }
+
+        public void WikiItemChanged(int itemWikiId)
+        {
+            //throw new NotImplementedException();
+        }
+
+        public void WikiPlayerChanged(int playerWikiId)
+        {
+            //throw new NotImplementedException();
+        }
+
+        public void UpdateServerStatus(ServerHistory serverHistory)
+        {
+            _activeServerStatuses.Remove(serverHistory.ServerId);
+            _activeServerStatuses.Add(serverHistory.ServerId, serverHistory);
+
+            if (_displayServers.Any(x => x.Key == serverHistory.ServerId))
+            {
+                DisplayServer displayServer;
+                _displayServers.TryGetValue(serverHistory.ServerId, out displayServer);
+
+                displayServer.Update(serverHistory);
+            }
+        }
+
+        protected void CleanUpTick(object sender, EventArgs eventArgs)
+        {
+            var currentTimeSpan = new TimeSpan(DateTime.Now.ToUniversalTime().Ticks - new DateTime(1970, 1, 1).Ticks);
+            var deadServers = _activeServerStatuses.Where(x => currentTimeSpan.Subtract(TimeSpan.FromMilliseconds(x.Value.Time)).TotalMilliseconds > TimeSpan.FromMinutes(1).TotalMilliseconds).ToList();
+            
+            foreach (var deadServer in deadServers)
+            {
+                _activeServerStatuses.Remove(deadServer.Key);
+                _displayServers.Remove(deadServer.Key);
+            }
+        }
+    }
+}