void userKicked_Published(object sender, EventSubscription<UserKicked>.PublishedEventArgs e)
 {
     // Inform that user has been kicked and exit the application when UserKicked event is published
     ExecuteOnUIThread(() =>
     {
         MessageBox.Show("You have been kicked");
         this.Close();
     });
 }

 public void NullActionThrows()
 {
     var filterDelegateReference = new MockDelegateReference()
     {
         Target = (Predicate<object>)(arg =>
         {
             return true;
         })
     };
     var eventSubscription = new EventSubscription<object>(null, filterDelegateReference);
 }

        public static EventListener Create(EventSubscription eventSubscription)
        {
            switch (eventSubscription.EventType)
            {
                case "NewSensorData":
                    return new SensorDataEventListener(eventSubscription);
                case "NewPosition":
                    return new PositionEventListener(eventSubscription);
            }

            throw new ArgumentOutOfRangeException("eventSubscription", "EventType does not exist.");
        }

        public void FilterShouldNotBeNull()
        {
            var action = new Mock<IDelegateReference>();
            action.SetupGet(a => a.Target).Returns((Action<object>)delegate { });

            var filter = new Mock<IDelegateReference>();
            filter.SetupGet(a => a.Target).Returns((Predicate<object>)delegate { return true; });

            var subscription = new EventSubscription<object>(action.Object, filter.Object);

            Assert.That(subscription.Filter, Is.Not.Null);
        }

 /// <summary>
 /// Creates an instance of the correct child eventlistener
 /// </summary>
 /// <param name="eventSubscription"></param>
 /// <returns></returns>
 public static EventListener Create(EventSubscription eventSubscription)
 {
     switch (eventSubscription.EventType)
     {
         case "ButtonPressed":
         case "HumidityChanged":
         case "LightChanged":
         case "TemperatureChanged":
             return new SensorDataEventListener(eventSubscription);
         case "LocationUpdated":
             return new PositionEventListener(eventSubscription);
     }
     throw new ArgumentOutOfRangeException("eventSubscription", "EventType does not exist.");
 }

        public void CanInitEventSubscription()
        {
            var actionDelegateReference = new MockDelegateReference((Action<object>)delegate { });
            var filterDelegateReference = new MockDelegateReference((Predicate<object>)delegate { return true; });
            var eventSubscription = new EventSubscription<object>(actionDelegateReference, filterDelegateReference, null, EventCommunicatorsRelationship.All);

            var subscriptionToken = new SubscriptionToken(t => { });

            eventSubscription.SubscriptionToken = subscriptionToken;

            Assert.Same(actionDelegateReference.Target, eventSubscription.Action);
            Assert.Same(filterDelegateReference.Target, eventSubscription.Filter);
            Assert.Same(subscriptionToken, eventSubscription.SubscriptionToken);
        }

        public void NullTargetInFilterThrows()
        {
            var actionDelegateReference = new MockDelegateReference()
            {
                Target = (Action<object>)delegate { }
            };

            var filterDelegateReference = new MockDelegateReference()
            {
                Target = null
            };
            var eventSubscription = new EventSubscription<object>(actionDelegateReference,
                                                                                filterDelegateReference);
        }

 public void DifferentTargetTypeInActionThrows()
 {
     var actionDelegateReference = new MockDelegateReference()
     {
         Target = (Action<int>)delegate { }
     };
     var filterDelegateReference = new MockDelegateReference()
     {
         Target = (Predicate<string>)(arg =>
         {
             return true;
         })
     };
     var eventSubscription = new EventSubscription<string>(actionDelegateReference,
                                                                     filterDelegateReference);
 }

        private void SubscribeToEvents()
        {
            // Workaround for issue #2 'EventSubscription<TEvent> default constructor does not start the service'
            // This issue is fixed in nvents 0.7
            Events.Service.Start();

            // Create a EventSubscription for the MessageSent event
            var messageSent = new EventSubscription<MessageSent>();
            // Register a handler for when Published is raised for MessageSent event
            messageSent.Published += messageSent_Published;

            // Create a EventSubscription for the UserKicked event and filter to only the current user
            var userKicked = new EventSubscription<UserKicked>(user => user.UserId == currentUser.Id);
            // Register a handler for when Published is raised for UserKicked event (will only be raised for events that passes the subscription filter)
            userKicked.Published += userKicked_Published;
        }

 public void NullTargetInActionThrows()
 {
     Assert.ThrowsException<ArgumentException>(() =>
     {
         var actionDelegateReference = new MockDelegateReference()
         {
             Target = null
         };
         var filterDelegateReference = new MockDelegateReference()
         {
             Target = (Predicate<object>)(arg =>
             {
                 return true;
             })
         };
         var eventSubscription = new EventSubscription<object>(actionDelegateReference,
                                                                         filterDelegateReference);
     });
 }

        public void GetExecutionStrategyDoesNotExecuteActionIfFilterReturnsFalse()
        {
            bool actionExecuted = false;
            var actionDelegate = new Mock<IDelegateReference>();

            actionDelegate.SetupGet(d => d.Target).Returns((Action<int>)delegate { actionExecuted = true; });

            var filterDelegate = new Mock<IDelegateReference>();

            filterDelegate.SetupGet(d => d.Target).Returns((Predicate<int>)delegate { return false; });

            var eventSubscription = new EventSubscription<int>(actionDelegate.Object, filterDelegate.Object);

            var publishAction = eventSubscription.GetExecutionStrategy();

            publishAction.Invoke(new object[] { null });

            Assert.That(actionExecuted, Is.False);
        }

        public void DifferentTargetTypeInActionThrows()
        {
            var actionDelegateReference = new MockDelegateReference()
            {
                Target = (Action<int>)delegate { }
            };
            var filterDelegateReference = new MockDelegateReference()
            {
                Target = (Predicate<string>)(arg =>
                {
                    return true;
                })
            };

            Assert.Throws<ArgumentException>(
                () =>
                {
                    var eventSubscription = new EventSubscription<string>(actionDelegateReference,
                        filterDelegateReference, null, EventCommunicatorsRelationship.All);
                });
        }

        public IEnumerable<EventSubscription> GetAll()
        {
            var subscriptions = new List<EventSubscription>();
            var path = GetPathForSubscriptions();
            var files = Directory.GetFiles(path);

            foreach (var file in files)
            {
                var json = File.ReadAllText(file);
                var holder = _serializer.FromJson<EventSubscriptionHolder>(json);
                var subscription = new EventSubscription();
                subscription.Id = Guid.Parse(holder.Id);
                subscription.LastEventId = holder.LastEventId;
                subscription.Owner = Type.GetType(holder.Owner);
                subscription.EventType = Type.GetType(holder.EventType);
                subscription.EventName = holder.EventName;
                subscription.Method = subscription.Owner.GetMethod(Bifrost.Events.ProcessMethodInvoker.ProcessMethodName, new Type[] { subscription.EventType });
                subscriptions.Add(subscription);
            }

            return subscriptions;
        }

        public void GetExecutionStrategyShouldReturnDelegateThatExecutesTheFilterAndThenTheAction()
        {
            var executedDelegates = new List<string>();

            var actionDelegate = new Mock<IDelegateReference>();

            actionDelegate.SetupGet(d => d.Target).Returns((Action<object>) delegate { executedDelegates.Add("Action"); });

            var filterDelegate = new Mock<IDelegateReference>();

            filterDelegate.SetupGet(d => d.Target).Returns((Predicate<object>) delegate { executedDelegates.Add("Filter"); return true; });

            var eventSubscription = new EventSubscription<object>(actionDelegate.Object, filterDelegate.Object);

            var publishAction = eventSubscription.GetExecutionStrategy();

            Assert.That(publishAction, Is.Not.Null);

            publishAction.Invoke(null);

            Assert.That(executedDelegates.Count, Is.EqualTo(2));
            Assert.That(executedDelegates[0], Is.EqualTo("Filter"));
            Assert.That(executedDelegates[1], Is.EqualTo("Action"));
        }

        public void NullTargetInFilterThrows()
        {
            var actionDelegateReference = new MockDelegateReference()
            {
                Target = (Action<object>)delegate { }
            };

            var filterDelegateReference = new MockDelegateReference()
            {
                Target = null
            };

            Assert.Throws<ArgumentException>(
                () =>
                {
                    var eventSubscription = new EventSubscription<object>(actionDelegateReference,
                        filterDelegateReference, null, EventCommunicatorsRelationship.All);
                });
        }

        public void NullActionThrows()
        {
            var filterDelegateReference = new MockDelegateReference()
            {
                Target = (Predicate<object>)(arg =>
                {
                    return true;
                })
            };

            Assert.Throws<ArgumentNullException>(
                () =>
                {
                    var eventSubscription = new EventSubscription<object>(null, filterDelegateReference, null, EventCommunicatorsRelationship.All);
                });
        }

        public void Subscribe(EventSubscription eventSubscription)
        {
            if (!this.EventListeners.ContainsKey(eventSubscription.EventId))
            {
                //TODO: filters checken -> Ekahau
                var eventListener = EventListener.Create(eventSubscription);
                eventListener.EventReceived += this.EventListenerEventReceived;
                this.EventListeners.Add(eventSubscription.EventId, eventListener);

                //pass a reference to the event of the controller
                eventListener.Advise(ControllerRef);
            }      
        }

        public void NullTargetInFilterThrows()
        {
            Assert.ThrowsException<ArgumentException>(() =>
            {
                var actionDelegateReference = new MockDelegateReference()
                {
                    Target = (Action<object>)delegate { }
                };

                var filterDelegateReference = new MockDelegateReference()
                {
                    Target = null
                };
                var eventSubscription = new EventSubscription<object>(actionDelegateReference,
                                                                                filterDelegateReference);
            });
        }

        public void StrategyPassesArgumentToDelegates()
        {
            string passedArgumentToAction = null;
            string passedArgumentToFilter = null;

            var actionDelegateReference = new MockDelegateReference((Action<string>)(obj => passedArgumentToAction = obj));
            var filterDelegateReference = new MockDelegateReference((Predicate<string>)(obj =>
                                                                                            {
                                                                                                passedArgumentToFilter = obj;
                                                                                                return true;
                                                                                            }));

            var eventSubscription = new EventSubscription<string>(actionDelegateReference, filterDelegateReference);
            var publishAction = eventSubscription.GetExecutionStrategy();

            publishAction.Invoke(new[] { "TestString" });

            Assert.AreEqual("TestString", passedArgumentToAction);
            Assert.AreEqual("TestString", passedArgumentToFilter);
        }

        public void GetPublishActionReturnsNullIfFilterIsNull()
        {
            var actionDelegateReference = new MockDelegateReference((Action<object>)delegate { });
            var filterDelegateReference = new MockDelegateReference((Predicate<object>)delegate { return true; });

            var eventSubscription = new EventSubscription<object>(actionDelegateReference, filterDelegateReference);

            var publishAction = eventSubscription.GetExecutionStrategy();

            Assert.IsNotNull(publishAction);

            filterDelegateReference.Target = null;

            publishAction = eventSubscription.GetExecutionStrategy();

            Assert.IsNull(publishAction);
        }