// Use this for initialization
 void Start()
 {
     m_behaviour = GetComponent<CartoonBehaviour>();
     m_spinRate = m_behaviour.m_spinRate;
     m_content = new GUIContent(m_text);
     eventPublisher = ObjectFinder.FindOrCreateComponent<EventPublisher>();
 }

		private ICategoryService GetCategoryService(UnitOfWork uow) {
			ICategoryRepository cateRepo = new CategoryRepository(uow);

			IState request = new DummyRequest();

			ILogger logger = new ConsoleLogger();

			IUserRepository userRepo = new UserRepository(uow);
			User user = userRepo.Create(new User {
				Name = "D. Ummy",
				ProviderId = "12345678",
				FullName = "Mr. Doh Ummy",
				EmailAddress = "[email protected]",
				Culture = "th-TH",
				TimeZone = "GMT Standard Time"
			});

			List<IEventSubscriber> subscribers = new List<IEventSubscriber>();

			IEventPublisher eventPublisher = new EventPublisher(subscribers, logger, request);
			IUserProvider userProvider = new DummyUserProvider(user);
			IPermissionService permService = new PermissionService();

			return new CategoryService(userProvider, cateRepo, eventPublisher, logger, permService);
		}

        public void WhenSourceEventRaised_ThenCollectedSubscriberIsNotNotified()
        {
            var source = new EventSource();
            var publisher = new EventPublisher(source);
            var subscriber = new EventSubscriber();

            var subscription = publisher.PropertyChanged.Subscribe(subscriber.OnChanged);

            try
            {
                subscriber = null;
                subscription.Dispose();
                GC.Collect();
                GC.WaitForFullGCApproach(-1);
                GC.WaitForFullGCComplete(-1);
                GC.WaitForPendingFinalizers();

                source.RaisePropertyChanged("Foo");

                Assert.Equal(0, EventSubscriber.ChangedProperties.Count);

            }
            finally
            {
                //subscription.Dispose();
            }
        }

		private void GetPostService(UnitOfWork uow, out ICategoryService categoryService, out IForumService forumService, out ITopicService topicService, out IPostService postService) {
			ICategoryRepository cateRepo = new CategoryRepository(uow);
			IForumRepository forumRepo = new ForumRepository(uow);
			ITopicRepository topicRepo = new TopicRepository(uow);
			IPostRepository postRepo = new PostRepository(uow);
			IForumConfigurationRepository configRepo = new ForumConfigurationRepository(uow);

			IState request = new DummyRequest();

			ILogger logger = new ConsoleLogger();

			IUserRepository userRepo = new UserRepository(uow);
			User user = userRepo.Create(new User {
				Name = "D. Ummy",
				ProviderId = "12345678",
				FullName = "Mr. Doh Ummy",
				EmailAddress = "[email protected]",
				Culture = "th-TH",
				TimeZone = "GMT Standard Time"
			});

			List<IEventSubscriber> subscribers = new List<IEventSubscriber>();

			IEventPublisher eventPublisher = new EventPublisher(subscribers, logger, request);
			IUserProvider userProvider = new DummyUserProvider(user);
			IPermissionService permService = new PermissionService();
			IForumConfigurationService confService = new ForumConfigurationService(configRepo);

			categoryService = new CategoryService(userProvider, cateRepo, eventPublisher, logger, permService);
			forumService = new ForumService(userProvider, cateRepo, forumRepo, topicRepo, postRepo, eventPublisher, logger, permService);
			topicService = new TopicService(userProvider, forumRepo, topicRepo, postRepo, eventPublisher, logger, permService, confService);
			postService = new PostService(userProvider, forumRepo, topicRepo, postRepo, eventPublisher, logger, permService, confService);
		}

 //need to have Start() so we can disable this.
 void Start()
 {
     if (GameObject.Find ("Level") != null) {
         eventPublisher = GameObject.Find ("Level").GetComponent<EventPublisher> ();
     } else {
         Debug.Log ("No level game object in scene: " + Application.loadedLevelName);
     }
 }

 private void SubscribeToEvents()
 {
     _eventPublisher = new EventPublisher();
     var numberCountedObserver = Observer.Create<NumberCountedEvent>(new Action<NumberCountedEvent>(OnNumberCounted));
     _eventPublisher.GetEvent<NumberCountedEvent>()
         .ObserveOnDispatcher()
         .Subscribe(numberCountedObserver);
 }

			protected override void Context()
			{
				EventPublisher publisher = new EventPublisher();

				publisher.Publish(new EventData("1st"));
				publisher.Publish(new EventData("2nd"));

				eventData = publisher.GetMostRecentPublication<EventData>();
			}

            public void EventEnvelopeCannotBeNull()
            {
                var messageFactory = new Mock<ICreateMessages>();
                var messageBus = new Mock<ISendMessages<EventEnvelope>>();
                var publisher = new EventPublisher(messageFactory.Object, messageBus.Object);

                var ex = Assert.Throws<ArgumentNullException>(() => publisher.Publish(HeaderCollection.Empty, null));

                Assert.Equal("payload", ex.ParamName);
            }

        private static void Main(string[] args)
        {
            var testEventHappened = new TestEventHappened
            {
                Message = "Hello Eventing World!"
            };
            var eventPublisher = new EventPublisher<TestEventHappened>();

            eventPublisher.Publish<object>(testEventHappened);
        }

            public void HeadersCanBeNull()
            {
                var messageFactory = new Mock<ICreateMessages>();
                var messageBus = new Mock<ISendMessages<EventEnvelope>>();
                var publisher = new EventPublisher(messageFactory.Object, messageBus.Object);

                publisher.Publish(null, EventEnvelope.Empty);

                messageFactory.Verify(mock => mock.Create(null, EventEnvelope.Empty), Times.Once);
                messageBus.Verify(mock => mock.Send(It.IsAny<Message<EventEnvelope>>()), Times.Once);
            }

        // ReSharper disable InconsistentNaming
        public void EventPublisherPublish_UnitTest_RegisteredType_FindsSubjectAndInvokesOnNext()
        // ReSharper restore InconsistentNaming
        {
            var memo = new DesignValidationMemo();

            var publisher = new EventPublisher();
            var subscription = publisher.GetEvent<DesignValidationMemo>().Subscribe(m => Assert.AreSame(memo, m));

            publisher.Publish(memo);
            subscription.Dispose();
        }

        // ReSharper disable InconsistentNaming
        public void EventPublisherGetEvent_UnitTest_FirstTimeForType_New()
        // ReSharper restore InconsistentNaming
        {
            var publisher = new EventPublisher();
            Assert.AreEqual(0, publisher.Count);

            var actual = publisher.GetEvent<object>();
            Assert.AreEqual(1, publisher.Count);
            Assert.IsNotNull(actual);
            Assert.IsInstanceOfType(actual, typeof(IObservable<object>));
        }

            protected override void Context()
            {
                _handler = MockRepository.GenerateMock<IEventHandler<EventData>>();

                IEventPublisher eventPublisher = new EventPublisher();

                eventPublisher.RegisterHandler(_handler);
                eventPublisher.UnregisterHandler(_handler);

                eventPublisher.Publish(new EventData("My Event Data"));
            }

 public static IApplicationServer WithEventStore(Func<ILogger, IEnumerable<IApplicationService>, ICommandRouter> routerFactory, Func<IEventStore> eventStoreFactory, IEnumerable<Func<IEventStore, IEventPublisher, IApplicationService>> appServiceFactories, Func<IEnumerable<IProjection>> projections, Func<IEnumerable<IReceptor>> receptors)
 {
     var logger = new ConsoleLogger();
     var eventListner = new EventListener(projections());
     var eventPublisher = new EventPublisher(new List<IEventListener> { eventListner }, new ReceptorSubject(receptors(), logger), logger);
     var observableEventStore = new ObservableEventStore(eventStoreFactory());
     var router = routerFactory(logger, appServiceFactories.Select(fac => fac(observableEventStore, eventPublisher)));
     var appServer = new ApplicationServer(router, logger);
     observableEventStore.Subscribe(eventPublisher);
     eventPublisher.Subscribe(cmd => appServer.DispatchAsync(cmd));
     return appServer;
 }

			protected override void Context()
			{
				_handler = MockRepository.GenerateMock<IEventHandler<EventData>>();
				_handler.Stub(h => h.Handle(null)).IgnoreArguments().Callback(delegate(EventData data)
					{
						_eventData = data.SomeData;
						return true;
					});

				IEventPublisher eventPublisher = new EventPublisher();
				eventPublisher.RegisterHandler(_handler);
				eventPublisher.Publish(new EventData("My Event Data"));
			}

        static void Main(string[] args)
        {
            EventPublisher publisher = new EventPublisher();

            EventReader1 reader1 = new EventReader1(publisher);

            EventReader2 reader2 = new EventReader2(publisher);

            publisher.DoSomthing();

            Console.WriteLine("This program already finished!");

            Console.ReadLine();
        }

        public void ShouldPublishEvent()
        {

            var ringBuffer = new RingBuffer<LongEvent>(()=>new LongEvent(0), BufferSize);
            ringBuffer.SetGatingSequences(new NoOpEventProcessor(ringBuffer).Sequence);
            var eventPublisher = new EventPublisher<LongEvent>(ringBuffer);


            eventPublisher.PublishEvent(_translator);
            eventPublisher.PublishEvent(_translator);

            Assert.AreEqual(0L + ValueAdd, ringBuffer[0].Value);
            Assert.AreEqual(1L + ValueAdd, ringBuffer[1].Value);
        }

        static void Main(string[] args)
        {
            //add event subscriptions
            EventSubscriptions.Add<EmailOrderConfirmation>();
            EventSubscriptions.Add<NotifyWarehouse>();
            EventSubscriptions.Add<DeductOnHandInventory>();

            //publish
            IEventPublisher eventPublisher = new EventPublisher(new EventSubscriptions());
            eventPublisher.PublishAsync<OrderSubmittedEvent>(new OrderSubmittedEvent { OrderId = Guid.NewGuid().ToString() });
            eventPublisher.PublishAsync<OrderSubmittedEvent>(new OrderSubmittedEvent { OrderId = Guid.NewGuid().ToString() });

            //Console.ReadKey();
        }

			protected override void Context()
			{
				_handler = SetupHandlerToThrowException();

				IEventPublisher eventPublisher = new EventPublisher();

				eventPublisher.OnHandlerError(ex =>
					{
						handlerExecuted = true;
						caughtException = ex;
					});
				
				eventPublisher.RegisterHandler(_handler);
				eventPublisher.Publish(new EventData());
			}

        public void WhenSourceEventRaised_ThenSubscriberIsNotified()
        {
            var source = new EventSource();
            var publisher = new EventPublisher(source);

            var subscriber = new EventSubscriber();

            publisher.PropertyChanged.Subscribe(subscriber.OnChanged);

            Assert.Equal(0, EventSubscriber.ChangedProperties.Count);

            source.RaisePropertyChanged("Foo");

            Assert.Equal(1, EventSubscriber.ChangedProperties.Count);
            Assert.Equal("Foo", EventSubscriber.ChangedProperties[0]);
        }