WhileYouWereGone

/// <summary>
    /// The helpers for queing and sending messages
    /// Ofcourse you can make this more intelligent to jsut store messages for a certain time or maybe get reciepts etc.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public static class QueueHelper<T> where T : IXBaseSocket
    {
        public class MessageWrapper<T> where T : IXBaseSocket
        {
            public Func<T, bool> Func { get; set; }
            public ITextArgs TextArgs { get; set; }

            public MessageWrapper(ITextArgs textArgs, Func<T, bool> func)
            {
                this.Func = func;
                this.TextArgs = textArgs;
            }

            public MessageWrapper(ITextArgs textArgs)
            {
                this.Func = null;
                this.TextArgs = textArgs;
            }
        }
        private static IDictionary<Guid, IDictionary<string, IList<MessageWrapper<T>>>> queue;

        static QueueHelper()
        {
            queue = new Dictionary<Guid, IDictionary<string, IList<MessageWrapper<T>>>>();
        }

        public static void OfflineSubscribe(T socket, params string[] events)
        {
            if (!queue.ContainsKey(socket.StorageGuid))
            {
                queue.Add(socket.StorageGuid, new Dictionary<string, IList<MessageWrapper<T>>>());
            }

            foreach (var @event in events.Where(@event => !queue[socket.StorageGuid].ContainsKey(socket.Alias + @event)))
            {
                queue[socket.StorageGuid].Add(socket.Alias + @event, new List<MessageWrapper<T>>());
            }
        }

        public static void OnlinePublish(T socket)
        {

            if (queue.ContainsKey(socket.StorageGuid))
            {
                foreach (var message in queue[socket.StorageGuid].SelectMany(messages => messages.Value))
                {
                    if (message.Func != null)
                    {
                        if (socket.GetIXBaseSockets<T>(message.Func).Count(x => x.StorageGuid == socket.StorageGuid) > 0)
                        {
                            socket.Send(message.TextArgs);
                        }
                    }
                    else
                    {
                        socket.Send(message.TextArgs);
                    }
                }
                queue[socket.StorageGuid] = new Dictionary<string, IList<MessageWrapper<T>>>();
            }
        }

        public static void Queue(T socket, ITextArgs message, Func<T, bool> func)
        {
            foreach (var client in queue.Where(client => client.Value.ContainsKey(socket.Alias + message.@event)))
            {
                client.Value[socket.Alias + message.@event].Add(new MessageWrapper<T>(message, func));
            }
        }

        public static void Queue(T socket, ITextArgs message)
        {
            foreach (var client in queue.Where(client => client.Value.ContainsKey(socket.Alias + message.@event)))
            {
                client.Value[socket.Alias + message.@event].Add(new MessageWrapper<T>(message));
            }
        }
    }