using System;
using System.Collections.Generic;
using System.Linq;
using AltNetHispano.Agendas.Domain;
using AltNetHispano.Agendas.Domain.Exceptions;
using AltNetHispano.Agendas.Domain.Repositories;
using AltNetHispano.Agendas.Repositories.Memory;
using Moq;
using NUnit.Framework;

namespace AltNetHispano.Agendas.Tests
{
	[TestFixture]
	public class AgendarTests : TestBase
	{
		private const string urlInvitacion = "http://groups.google.com/group/altnet-hispano/browse_thread/thread/65d6d26eb381386e";

		[Test]
		public void CompositePublicador_constructor_parametro_null_debe_generar_ArgumentNullException()
		{
			Assert.Throws<ArgumentNullException>(() => new CompositePublicador(null));
		}

		[Test]
		public void Intentar_agendar_evento_donde_ocurre_una_excepcion_no_manejada()
		{
			var publicador = new Mock<IPublicador>();
			var repository = new Mock<IEventoRepository>();

			publicador.Setup(p => p.Publicar(It.IsAny<IEnumerable<Track>>())).Throws(new Exception("Error intencional"));
			repository.Setup(r => r.GetActivos()).Returns(new List<Evento>());
			var agenda = new Agenda(publicador.Object, repository.Object, DefaultPersonaRepository, DefaultPatrocinadorRepository);

		    var fechaInicio = DateTime.Now.ToUniversalTime();
		    var fechaTermino = fechaInicio.AddHours(2);
		    Assert.Throws<Exception>(
		        () =>
		        agenda.Agendar("Van para publicar", new[]{ TestsHelper.GetOrCreatePonente("jjmontes")}, fechaInicio, fechaTermino,
		                       urlInvitacion, TipoEvento.Van));
			Assert.AreEqual(0, agenda.GetEventosActivos().Count);

			publicador.Verify(p => p.Publicar(It.IsAny<IEnumerable<Track>>()), Times.Exactly(1));
			repository.Verify(p => p.Save(It.IsAny<Evento>()), Times.Exactly(0));
		}

		[Test]
		public void Intentar_agendar_evento_sin_servicio_de_seguridad()
		{
			IdentityContext.Init(null, new PersonaRepository());

			var publicador = new Mock<IPublicador>();
			var repository = new Mock<IEventoRepository>();
			repository.Setup(r => r.GetActivos()).Returns(new List<Evento>());
			var agenda = new Agenda(publicador.Object, repository.Object, DefaultPersonaRepository, DefaultPatrocinadorRepository);

		    var fechaInicio = DateTime.Now.ToUniversalTime();
		    var fechaTermino = fechaInicio.AddHours(2);
		    Assert.Throws<IdentityContextNotConfiguredException>(
		        () =>
		        agenda.Agendar("Van para publicar", new[]{ TestsHelper.GetOrCreatePonente("jjmontes")}, fechaInicio, fechaTermino,
		                       urlInvitacion, TipoEvento.Van));
			repository.Verify(p => p.Save(It.IsAny<Evento>()), Times.Exactly(0));
		}

		[Test]
		public void Intentar_agendar_evento_sin_usuario_autenticado()
		{
			SetCurrentUser(null, null);

			var publicador = new Mock<IPublicador>();
			var repository = new Mock<IEventoRepository>();
			repository.Setup(r => r.GetActivos()).Returns(new List<Evento>());
			var agenda = new Agenda(publicador.Object, repository.Object, DefaultPersonaRepository, DefaultPatrocinadorRepository);

		    var fechaInicio = DateTime.Now.ToUniversalTime();
		    var fechaTermino = fechaInicio.AddHours(2);
		    Assert.Throws<UsuarioNoAutenticadoException>(
		        () =>
		        agenda.Agendar("Van para publicar", new[]{ TestsHelper.GetOrCreatePonente("jjmontes")}, fechaInicio, fechaTermino,
		                       urlInvitacion, TipoEvento.Van));

			publicador.Verify(p => p.Publicar(It.IsAny<IEnumerable<Track>>()), Times.Exactly(0));
			repository.Verify(p => p.Save(It.IsAny<Evento>()), Times.Exactly(0));
		}

		[Test]
		public void Intentar_agendar_van_sin_ponentes_null()
		{
			var agenda = new Agenda(null, DefaultEventoRepository, DefaultPersonaRepository, DefaultPatrocinadorRepository);

		    var fechaInicio = DateTime.Now.ToUniversalTime();
		    var fechaTermino = fechaInicio.AddHours(2);
		    var r = agenda.Agendar("Van para publicar", null, fechaInicio, fechaTermino, urlInvitacion, TipoEvento.Van);

			Assert.IsFalse(r.Succeful);
		}

		[Test]
		public void Intentar_agendar_van_sin_ponentes_empty()
		{
			var agenda = new Agenda(null, DefaultEventoRepository, DefaultPersonaRepository, DefaultPatrocinadorRepository);

			var fechaInicio = DateTime.Now.ToUniversalTime();
			var fechaTermino = fechaInicio.AddHours(2);
			var r = agenda.Agendar("Van para publicar", new[] {Guid.Empty}, fechaInicio, fechaTermino, urlInvitacion,
			                       TipoEvento.Van);

			Assert.IsFalse(r.Succeful);
		}

		[Test]
		public void Agendar_cafe_sin_ponente()
		{
			var agenda = new Agenda(null, DefaultEventoRepository, DefaultPersonaRepository, DefaultPatrocinadorRepository);

			var fechaInicio = DateTime.Now.ToUniversalTime();
			var fechaTermino = fechaInicio.AddHours(2);
			var r = agenda.Agendar("Cafe para publicar", new[] { Guid.Empty }, fechaInicio, fechaTermino, urlInvitacion, TipoEvento.Cafe);

			Console.WriteLine(r.Message);
			Assert.IsTrue(r.Succeful);
		}

		[Test]
		public void Agendar_grupo_de_estudio_sin_ponente()
		{
			var agenda = new Agenda(null, DefaultEventoRepository, DefaultPersonaRepository, DefaultPatrocinadorRepository);

			var fechaInicio = DateTime.Now.ToUniversalTime();
			var fechaTermino = fechaInicio.AddHours(2);
			var r = agenda.Agendar("GrupoEstudio para publicar", new[] { Guid.Empty }, fechaInicio, fechaTermino, urlInvitacion, TipoEvento.GrupoEstudio);

			Assert.IsTrue(r.Succeful);
		}

		[Test]
		public void Agendar_evento_con_multiples_publicadores()
		{
			var publicador1 = new Mock<IPublicador>();
			var publicador2 = new Mock<IPublicador>();

			var repository = new Mock<IEventoRepository>();
			repository.Setup(r => r.GetActivos()).Returns(new List<Evento>());
			var agenda = new Agenda(new CompositePublicador(new[] { publicador1.Object, publicador2.Object }),
															repository.Object, DefaultPersonaRepository, 
															DefaultPatrocinadorRepository);

		    var fechaInicio = DateTime.Now.ToUniversalTime();
		    var fechaTermino = fechaInicio.AddHours(2);
		    agenda.Agendar("Van para publicar", new[]{TestsHelper.GetOrCreatePonente("jjmontes")}, fechaInicio, fechaTermino,
		                   urlInvitacion, TipoEvento.Van);

			publicador1.Verify(p => p.Publicar(It.IsAny<IEnumerable<Track>>()), Times.Exactly(1));
			publicador2.Verify(p => p.Publicar(It.IsAny<IEnumerable<Track>>()), Times.Exactly(1));
			repository.Verify(p => p.Save(It.IsAny<Evento>()), Times.Exactly(1));
		}

		[Test]
		public void Agendar_evento_correctamente()
		{
			var publicador = new Mock<IPublicador>();

			var agenda = new Agenda(publicador.Object, DefaultEventoRepository, DefaultPersonaRepository, DefaultPatrocinadorRepository);

		    var fechaInicio = DateTime.Now.ToUniversalTime();
		    var fechaTermino = fechaInicio.AddHours(2);
		    agenda.Agendar("Van para publicar",new[]{ TestsHelper.GetOrCreatePonente("jjmontes")}, fechaInicio, fechaTermino,
		                   urlInvitacion, TipoEvento.Van);

			Assert.AreEqual(0, agenda.GetEventosActivos(EventoPropuestoState.GetInstance()).Count);

			var eventos = agenda.GetEventosActivos();
			Assert.AreEqual(1, eventos.Count);

			publicador.Verify(p => p.Publicar(It.IsAny<IEnumerable<Track>>()), Times.Exactly(1));

			var evento = eventos[0];

		}

		[Test]
		public void Agendar_evento_con_multiples_ponentes()
		{
			var agenda = new Agenda(null, DefaultEventoRepository, DefaultPersonaRepository, DefaultPatrocinadorRepository);

			var fechaInicio = DateTime.Now.ToUniversalTime();
			var fechaTermino = fechaInicio.AddHours(2);

			agenda.Agendar("Identity Providers, oAuth y Autenticaciones on-line",
			               new[] {TestsHelper.GetOrCreatePonente("Carlos Peix"), TestsHelper.GetOrCreatePonente("Nelo Pauselli")},
			               fechaInicio, fechaTermino, urlInvitacion, TipoEvento.Van);

			Assert.AreEqual(0, agenda.GetEventosActivos(EventoPropuestoState.GetInstance()).Count);

			var eventos = agenda.GetEventosActivos();
			Assert.AreEqual(1, eventos.Count);

			var evento = eventos[0];

			var carlos = evento.Ponentes.Single(p => p.Twitter == "carlospeix");
			Assert.AreEqual("Carlos Peix", carlos.Nombre);

			var nelo = evento.Ponentes.Single(p => p.Twitter == "nelopauselli");
			Assert.AreEqual("Nelo Pauselli", nelo.Nombre);
		}

		[Test]
		public void Agendar_y_modificar_evento()
		{
			var repository = DefaultEventoRepository;
			var publicador = new Mock<IPublicador>();

			var agenda = new Agenda(publicador.Object, repository, DefaultPersonaRepository, DefaultPatrocinadorRepository);
		    var fechaInicioVanPublicar = DateTime.Now.ToUniversalTime();
		    var fechaTerminoVanPublicar = fechaInicioVanPublicar.AddHours(2);

			agenda.Agendar("Van para publicar", new[] {TestsHelper.GetOrCreatePonente("jjmontes")}, fechaInicioVanPublicar, fechaTerminoVanPublicar, urlInvitacion, TipoEvento.Van);

			publicador.Verify(p => p.Publicar(It.IsAny<IEnumerable<Track>>()), Times.Exactly(1));

			var evento = repository.GetActivos().First();
			Assert.AreNotEqual(Guid.Empty, evento.Id);
			Assert.IsNotNull(evento.FechaInicio);

			var fechaInicio = evento.FechaInicio.Value.AddDays(7);
		    var fechaTermino = fechaInicio.AddHours(2);
		    agenda.ModificarEvento(evento.Id, "otro titulo", new[]{TestsHelper.GetOrCreatePonente("otro ponente")}, fechaInicio,
		                           fechaTermino, urlInvitacion);

			publicador.Verify(p => p.Publicar(It.IsAny<IEnumerable<Track>>()), Times.Exactly(2));

			evento = repository.GetActivos().First();
			Assert.AreEqual("otro titulo", evento.Titulo);
			Assert.IsTrue(evento.Ponentes.Any(p=>p.Nombre=="otro ponente"));
			Assert.AreEqual(fechaInicio, evento.FechaInicio);

			var idEventoNoExistente = new Guid("99999999999999999999999999999999");
		    Assert.Throws<EventoNotFoundException>(
		        () =>
		        agenda.ModificarEvento(idEventoNoExistente, "algún título",new[]{ TestsHelper.GetOrCreatePonente("un ponente")},
		                               DateTime.Now, DateTime.Now.AddHours(2), urlInvitacion));
		}

		[Test, Ignore("Por ahora no existe el concepto de recordar")]
		public void Agendar_y_recordar_evento()
		{
			var publicador1 = new Mock<IPublicador>();
			var publicador2 = new Mock<IPublicador>();

			var agenda = new Agenda(new CompositePublicador(new[] { publicador1.Object, publicador2.Object }),
															DefaultEventoRepository, DefaultPersonaRepository,
															DefaultPatrocinadorRepository);

		    var fechaInicio = DateTime.Now.ToUniversalTime();
		    var fechaTermino = fechaInicio.AddHours(2);
		    agenda.Agendar("Van para publicar", new[]{TestsHelper.GetOrCreatePonente("jjmontes")}, fechaInicio, fechaTermino,
		                   urlInvitacion, TipoEvento.Van);

			var van = agenda.GetEventosActivos().Single(v => v.Titulo == "Van para publicar");
			//agenda.Recordar(van.Id);

			publicador1.Verify(p => p.Publicar(It.IsAny<IEnumerable<Track>>()), Times.Exactly(1));
			publicador2.Verify(p => p.Publicar(It.IsAny<IEnumerable<Track>>()), Times.Exactly(1));
			//recordador1.Verify(r => r.Recordar(It.IsAny<Evento>()), Times.Exactly(1));
		}

		[Test]
		public void Agendar_evento_propuesto()
		{
			var publicador1 = new Mock<IPublicador>();
			var publicador2 = new Mock<IPublicador>();

			var agenda = new Agenda(new CompositePublicador(new[] { publicador1.Object, publicador2.Object }),
															DefaultEventoRepository, DefaultPersonaRepository, 
															DefaultPatrocinadorRepository);

			agenda.Proponer("Html 5", new[]{TestsHelper.GetOrCreatePonente("jjmontes")},  urlInvitacion, TipoEvento.Van);
			Assert.AreEqual(1, agenda.GetEventosActivos(EventoPropuestoState.GetInstance()).Count);
			Assert.AreEqual(1, agenda.GetEventosActivos().Count);

			var publicado = agenda.GetEventosActivos(EventoPropuestoState.GetInstance()).First();
			Assert.AreEqual(1, publicado.Tracks.Count());

		    var fechaInicio = DateTime.Today.AddDays(5).ToUniversalTime();
		    var fechaTermino = fechaInicio.AddHours(2);
		    agenda.ModificarEvento(publicado.Id, "Html 5", new[]{TestsHelper.GetOrCreatePonente("jjmontes")}, fechaInicio,
		                           fechaTermino, urlInvitacion);
			Assert.AreEqual(0, agenda.GetEventosActivos(EventoPropuestoState.GetInstance()).Count);
			Assert.AreEqual(1, agenda.GetEventosActivos(EventoAgendadoState.GetInstance()).Count);
			Assert.AreEqual(1, agenda.GetEventosActivos().Count);

			var agendado = agenda.GetEventosActivos().First();
			Assert.AreSame(publicado, agendado);
			Assert.AreEqual(2, agendado.Tracks.Count());

			Assert.IsNotNull(agendado.Tracks.Where(t => t.Accion == Accion.Proponer).SingleOrDefault());
			Assert.IsNotNull(agendado.Tracks.Where(t => t.Accion == Accion.Agendar).SingleOrDefault());
		}

		[Test]
		public void Al_proponer_un_evento_debe_quedar_con_estado_EventoPropuestoState_y_debe_generar_el_track_correspondiente()
		{
			var publicador1 = new Mock<IPublicador>();

			var agenda = new Agenda(publicador1.Object, DefaultEventoRepository, DefaultPersonaRepository, DefaultPatrocinadorRepository);
			agenda.Proponer("Html 5", new[]{TestsHelper.GetOrCreatePonente("jjmontes")},  urlInvitacion, TipoEvento.Van);

			var evento =
				DefaultEventoRepository.GetByState(EventoPropuestoState.GetInstance()).Single(e => e.Titulo == "Html 5");

			Assert.IsInstanceOf(typeof(EventoPropuestoState), evento.Estado);
			Assert.That(evento.GetTrackNews().Count(t => t.Accion == Accion.Proponer) == 1);
		}

		[Test]
		public void Al_agendar_un_evento_debe_quedar_con_estado_EventoAgendadoState_y_debe_generar_el_track_correspondiente()
		{
			var publicador1 = new Mock<IPublicador>();

			var agenda = new Agenda(publicador1.Object, DefaultEventoRepository, DefaultPersonaRepository, DefaultPatrocinadorRepository);
		    var fechaInicio = DateTime.MinValue.ToUniversalTime();
		    var fechatermino = fechaInicio.AddHours(2);
		    agenda.Agendar("Html 5", new[]{TestsHelper.GetOrCreatePonente("jjmontes")},  fechaInicio, fechatermino, urlInvitacion,
		                   TipoEvento.Van);

			var evento = DefaultEventoRepository.GetActivos().Single(e => e.Titulo == "Html 5");

			Assert.IsInstanceOf(typeof(EventoAgendadoState), evento.Estado);
			Assert.That(evento.GetTrackNews().Count(t => t.Accion == Accion.Agendar) == 1);
		}

        [Test]
        public void Al_cancelar_un_evento_debe_quedar_con_estado_EventoCanceladoState_y_debe_generar_el_track_correspondiente()
        {
            var publicador1 = new Mock<IPublicador>();

			var agenda = new Agenda(publicador1.Object, DefaultEventoRepository, DefaultPersonaRepository, DefaultPatrocinadorRepository);
            var fechaInicio = DateTime.MinValue.ToUniversalTime();
            var fechaTermino = fechaInicio.AddHours(2);
            agenda.Agendar("Html 5", new[]{TestsHelper.GetOrCreatePonente("jjmontes")},  fechaInicio, fechaTermino,
                           urlInvitacion, TipoEvento.Van);

            var evento = DefaultEventoRepository.GetActivos().Single(e => e.Titulo == "Html 5");

            agenda.Cancelar(evento.Id);

            Assert.IsInstanceOf(typeof(EventoCanceladoState), evento.Estado);
            Assert.That(evento.GetTrackNews().Count(t => t.Accion == Accion.Cancelar) == 1);
            Assert.AreEqual(EventoCanceladoState.GetInstance(), evento.Estado);
        }

        [Test]
        public void Al_descartar_un_evento_debe_quedar_con_estado_EventoDescartadoState_y_debe_generar_el_track_correspondiente()
        {
            var publicador1 = new Mock<IPublicador>();

			var agenda = new Agenda(publicador1.Object, DefaultEventoRepository, DefaultPersonaRepository, DefaultPatrocinadorRepository);
            var fechaInicio = DateTime.MinValue.ToUniversalTime();
            var fechaTermino = fechaInicio.AddHours(2);
            agenda.Agendar("Html 5", new[]{TestsHelper.GetOrCreatePonente("jjmontes")},  fechaInicio, fechaTermino,
                           urlInvitacion, TipoEvento.Van);

            var evento = DefaultEventoRepository.GetActivos().Single(e => e.Titulo == "Html 5");

            agenda.Cancelar(evento.Id);
            agenda.Descartar(evento.Id);

            Assert.IsInstanceOf(typeof(EventoDescartadoState), evento.Estado);
            Assert.That(evento.GetTrackNews().Count(t => t.Accion == Accion.Descartar) == 1);
            Assert.AreEqual(EventoDescartadoState.GetInstance(), evento.Estado);
        }
	    
        [Test]
		public void Al_confirmar_un_evento_debe_quedar_con_estado_EventoConfirmadoState_y_debe_generar_el_track_correspondiente()
		{
			var publicador1 = new Mock<IPublicador>();

			var agenda = new Agenda(publicador1.Object, DefaultEventoRepository, DefaultPersonaRepository, DefaultPatrocinadorRepository);
            var fechaInicio = DateTime.MinValue.ToUniversalTime();
            var fechaTermino = fechaInicio.AddHours(2);
            agenda.Agendar("Html 5", new[]{TestsHelper.GetOrCreatePonente("jjmontes")},  fechaInicio, fechaTermino,
                           urlInvitacion, TipoEvento.Van);

			var evento = DefaultEventoRepository.GetActivos().Single(e => e.Titulo == "Html 5");

			agenda.Confirmar(evento.Id);

			Assert.IsInstanceOf(typeof(EventoConfirmadoState), evento.Estado);
			Assert.That(evento.GetTrackNews().Count(t => t.Accion == Accion.Confirmar) == 1);
		}

		[Test]
		public void Al_publicar_un_evento_debe_quedar_con_estado_EventoPublicadoState_y_debe_generar_el_track_correspondiente()
		{
			const string urlWiki = "http://www.altnethispano.org/wiki/van-2010-10-21-mono-cecil.ashx";
			var duracion = new TimeSpan(1, 34, 00);
			var publicador1 = new Mock<IPublicador>();

			var agenda = new Agenda(publicador1.Object, DefaultEventoRepository, DefaultPersonaRepository, DefaultPatrocinadorRepository);
		    var fechaInicio = DateTime.MinValue.ToUniversalTime();
		    var fechaTermino = fechaInicio.AddHours(2);
		    agenda.Agendar("Html 5", new[]{TestsHelper.GetOrCreatePonente("jjmontes")},  fechaInicio, fechaTermino, urlInvitacion,
		                   TipoEvento.Van);

			var evento = DefaultEventoRepository.GetActivos().Single(e => e.Titulo == "Html 5");

			agenda.Confirmar(evento.Id);
			agenda.IndicarPatrocinadores(evento.Id, new List<Guid> { TestsHelper.GetOrCreatePatrocinador("Apress", "http://apress.com/") });
			agenda.Publicar(evento.Id, 1, urlWiki, duracion);

			Assert.IsInstanceOf(typeof(EventoPublicadoState), evento.Estado);
			Assert.That(evento.GetTrackNews().Count(t => t.Accion == Accion.Publicar) == 1);
		}

		[Test]
		public void Al_publicar_un_evento_debe_asignarse_el_nro_de_reunion_la_url_de_la_wiki_y_la_duracion()
		{
			const string urlWiki = "http://www.altnethispano.org/wiki/van-2010-10-21-mono-cecil.ashx";
			var duracion = new TimeSpan(1, 34, 00);
			var publicador1 = new Mock<IPublicador>();

			var agenda = new Agenda(publicador1.Object, DefaultEventoRepository, DefaultPersonaRepository, DefaultPatrocinadorRepository);
		    var fechaInicio = DateTime.MinValue.ToUniversalTime();
		    var fechaTermino = fechaInicio.AddHours(2);
		    agenda.Agendar("Html 5", new[]{TestsHelper.GetOrCreatePonente("jjmontes")},  fechaInicio, fechaTermino, urlInvitacion,
		                   TipoEvento.Van);

			var evento = DefaultEventoRepository.GetActivos().Single(e => e.Titulo == "Html 5");
			agenda.Confirmar(evento.Id);
			agenda.IndicarPatrocinadores(evento.Id, new List<Guid> { TestsHelper.GetOrCreatePatrocinador("Apress", "http://apress.com/") });
			agenda.Publicar(evento.Id, 71, urlWiki, duracion);

			Assert.AreEqual(71, evento.NumeroOrden);
			Assert.AreEqual(urlWiki, evento.UrlWiki);
			Assert.AreEqual(duracion, evento.Duracion);
		}

		[Test]
		//[ExpectedException(typeof(AccionNoSoportadaException))]
		public void Al_confirmar_sin_agendar_debe_lanzarse_excepcion()
		{
			var publicador1 = new Mock<IPublicador>();

			var agenda = new Agenda(publicador1.Object, DefaultEventoRepository, DefaultPersonaRepository, DefaultPatrocinadorRepository);
			agenda.Proponer("Html 5", new[]{TestsHelper.GetOrCreatePonente("jjmontes")},  urlInvitacion, TipoEvento.Van);

			var evento =
				DefaultEventoRepository.GetByState(EventoPropuestoState.GetInstance()).Single(e => e.Titulo == "Html 5");

			Assert.IsFalse(evento.Estado.GetType() == typeof(EventoAgendadoState));

			Assert.Throws<AccionNoSoportadaException>(()=>agenda.Confirmar(evento.Id));
		}

		[Test]
		//[ExpectedException(typeof(AccionNoSoportadaException))]
		public void Al_publicar_sin_confirmar_debe_lanzarse_excepcion()
		{
			const string urlWiki = "http://www.altnethispano.org/wiki/van-2010-10-21-mono-cecil.ashx";
			var duracion = new TimeSpan(1, 34, 00);
			var publicador1 = new Mock<IPublicador>();

			var agenda = new Agenda(publicador1.Object, DefaultEventoRepository, DefaultPersonaRepository, DefaultPatrocinadorRepository);
			agenda.Proponer("Html 5", new[]{TestsHelper.GetOrCreatePonente("jjmontes")},  urlInvitacion, TipoEvento.Van);

			var evento =
				DefaultEventoRepository.GetByState(EventoPropuestoState.GetInstance()).Single(e => e.Titulo == "Html 5");

			agenda.IndicarPatrocinadores(evento.Id, new List<Guid> { TestsHelper.GetOrCreatePatrocinador("Apress", "http://apress.com/") });

			Assert.IsFalse(evento.Estado.GetType() == typeof(EventoConfirmadoState));
			Assert.Throws<AccionNoSoportadaException>(() => agenda.Publicar(evento.Id, 1, urlWiki, duracion));
		}

        [Test]
        public void Publicar_Evento_Con_NroOrden_Invalido_Genera_Excepcion()
        {
			var duracion = new TimeSpan(1, 34, 00);
            var publicador1 = new Mock<IPublicador>();

			var agenda = new Agenda(publicador1.Object, DefaultEventoRepository, DefaultPersonaRepository, DefaultPatrocinadorRepository);
            var fechaInicio = DateTime.MinValue.ToUniversalTime();
            var fechaTermino = fechaInicio.AddHours(2);
            agenda.Agendar("Html 5", new[]{TestsHelper.GetOrCreatePonente("jjmontes")},  fechaInicio, fechaTermino,
                           urlInvitacion, TipoEvento.Van);

            var evento = DefaultEventoRepository.GetActivos().Single(e => e.Titulo == "Html 5");
            agenda.Confirmar(evento.Id);

            const string urlWiki = "http://www.altnethispano.org/wiki/van-2010-10-21-mono-cecil.ashx";

            var eventoResultado = agenda.Publicar(evento.Id, 0, urlWiki, duracion);
            Assert.IsFalse(eventoResultado.Succeful);
            Assert.AreEqual("Número de Orden fuera de rango", eventoResultado.Message);
            eventoResultado = agenda.Publicar(evento.Id, -1, urlWiki, duracion);
            Assert.IsFalse(eventoResultado.Succeful);
            Assert.AreEqual("Número de Orden fuera de rango", eventoResultado.Message);
        }

        [Test]
        public void Publicar_Evento_Con_Url_Invalida_Genera_Excepcion()
        {
            var duracion = new TimeSpan(1, 34, 00);
            var publicador1 = new Mock<IPublicador>();

			var agenda = new Agenda(publicador1.Object, DefaultEventoRepository, DefaultPersonaRepository, DefaultPatrocinadorRepository);
            var fechaInicio = DateTime.MinValue.ToUniversalTime();
            var fechaTermino = fechaInicio.AddHours(2);
            agenda.Agendar("Html 5", new[] {TestsHelper.GetOrCreatePonente("jjmontes")}, fechaInicio, fechaTermino,
                           urlInvitacion, TipoEvento.Van);

            var evento = DefaultEventoRepository.GetActivos().Single(e => e.Titulo == "Html 5");
            agenda.Confirmar(evento.Id);

            var eventoResultado = agenda.Publicar(evento.Id, 1, "", duracion);
            Assert.IsFalse(eventoResultado.Succeful);
            Assert.AreEqual("Url Wiki incorrecto", eventoResultado.Message);
            eventoResultado = agenda.Publicar(evento.Id, 1, " ", duracion);
            Assert.IsFalse(eventoResultado.Succeful);
            Assert.AreEqual("Url Wiki incorrecto", eventoResultado.Message);
        }

	    [Test]
		public void Publicar_Evento_Con_Duracion_Invalida_Genera_Excepcion()
		{
			const string urlWiki = "http://www.altnethispano.org/wiki/van-2010-10-21-mono-cecil.ashx";
			var publicador1 = new Mock<IPublicador>();

			var agenda = new Agenda(publicador1.Object, DefaultEventoRepository, DefaultPersonaRepository, DefaultPatrocinadorRepository);
		    var fechaInicio = DateTime.MinValue.ToUniversalTime();
		    var fechaTermino = fechaInicio.AddHours(2);
		    agenda.Agendar("Html 5", new[]{TestsHelper.GetOrCreatePonente("jjmontes")},  fechaInicio, fechaTermino, urlInvitacion,
		                   TipoEvento.Van);

			var evento = DefaultEventoRepository.GetActivos().Single(e => e.Titulo == "Html 5");
			agenda.Confirmar(evento.Id);

			var eventoResultado = agenda.Publicar(evento.Id, 1, urlWiki, new TimeSpan(0, 0, 0));
            Assert.IsFalse(eventoResultado.Succeful);
            Assert.AreEqual("Duración fuera de rango", eventoResultado.Message);
			eventoResultado = agenda.Publicar(evento.Id, 1, urlWiki, new TimeSpan(0, 0, 59));
            Assert.IsFalse(eventoResultado.Succeful);
            Assert.AreEqual("Duración fuera de rango", eventoResultado.Message);
        }

		[Test]
		public void Verificar_que_no_se_puedan_agendar_dos_eventos_para_el_mismo_intervalo()
		{
			var publicador1 = new Mock<IPublicador>();
			var agenda = new Agenda(publicador1.Object, DefaultEventoRepository, DefaultPersonaRepository, DefaultPatrocinadorRepository);
			var fechaInicio = new DateTime(2011, 7, 1, 18, 00, 00);
			var fechaTermino = fechaInicio.AddHours(2);

			var r = agenda.Agendar("Conceptos de HTTP y Fiddler web debugger", new[]{TestsHelper.GetOrCreatePonente("jjmontes")},  fechaInicio,
						   fechaTermino, string.Empty, TipoEvento.Van);
			Assert.IsTrue(r.Succeful);

			fechaInicio = new DateTime(2011, 7, 1, 05, 00, 00);
			fechaTermino = fechaInicio.AddHours(2);
			r = agenda.Agendar("Una primer van que NO se superpone",
						   new[]{TestsHelper.GetOrCreatePonente("jjmontes")},
						   fechaInicio,
						   fechaTermino, string.Empty, TipoEvento.Van);
			Assert.IsTrue(r.Succeful);
			
			r = agenda.Agendar("Otra van que se superpone",
			                       new[]{TestsHelper.GetOrCreatePonente("jjmontes")},
			                       fechaInicio,
			                       fechaTermino, string.Empty, TipoEvento.Van);
			Assert.IsFalse(r.Succeful);

			fechaInicio = new DateTime(2011, 7, 1, 17, 00, 00);
			fechaTermino = fechaInicio.AddHours(2);
			r = agenda.Agendar("Otra van que se superpone",
			                   new[]{TestsHelper.GetOrCreatePonente("jjmontes")},
			                   fechaInicio,
			                   fechaTermino, string.Empty, TipoEvento.Van);
			Assert.IsFalse(r.Succeful);

			fechaInicio = new DateTime(2011, 7, 1, 19, 00, 00);
			fechaTermino = fechaInicio.AddHours(2);
			r = agenda.Agendar("Otra van que se superpone",
			                   new[]{TestsHelper.GetOrCreatePonente("jjmontes")},
			                   fechaInicio,
			                   fechaTermino, string.Empty, TipoEvento.Van);
			Assert.IsFalse(r.Succeful);

			fechaInicio = new DateTime(2011, 7, 1, 21, 00, 00);
			fechaTermino = fechaInicio.AddHours(2);
			r = agenda.Agendar("Una segunda van que NO se superpone",
			                   new[]{TestsHelper.GetOrCreatePonente("jjmontes")},
			                   fechaInicio,
			                   fechaTermino, string.Empty, TipoEvento.Van);
			Assert.IsTrue(r.Succeful);
		}

		[Test]
		public void Verificar_que_no_se_modifique_una_propuesta_de_VAN_al_intentar_agendarla_con_fechas_usadas()
		{
			var publicador1 = new Mock<IPublicador>();
			var agenda = new Agenda(publicador1.Object, DefaultEventoRepository, DefaultPersonaRepository, DefaultPatrocinadorRepository);
			var fechaInicio = new DateTime(2011, 7, 1, 18, 00, 00);
			var fechaTermino = fechaInicio.AddHours(2);

			agenda.Agendar("Conceptos de HTTP y Fiddler web debugger", new[]{TestsHelper.GetOrCreatePonente("jjmontes")},  fechaInicio,
						   fechaTermino, string.Empty, TipoEvento.Van);

			agenda.Proponer("Otra van que se superpone", new[]{TestsHelper.GetOrCreatePonente("jjmontes")},  string.Empty, TipoEvento.Van);
			var eventoPropuesto = DefaultEventoRepository.GetPropuestaByTitulo("Otra van que se superpone");
			Assert.IsNotNull(eventoPropuesto);
			Assert.IsNull(eventoPropuesto.FechaInicio);
			Assert.IsNull(eventoPropuesto.FechaTermino);
			var r = agenda.Agendar("Otra van que se superpone",
								   new[]{TestsHelper.GetOrCreatePonente("jjmontes")},
								   fechaInicio,
								   fechaTermino, string.Empty, TipoEvento.Van);
			Assert.IsFalse(r.Succeful);

			Assert.IsNotNull(eventoPropuesto);
			Assert.IsNull(eventoPropuesto.FechaInicio);
			Assert.IsNull(eventoPropuesto.FechaTermino);
		}

        [Test]
        public void Verificar_que_no_sea_posible_crear_dos_van_diferentes_con_igual_titulo()
        {
            var publicador1 = new Mock<IPublicador>();
			var agenda = new Agenda(publicador1.Object, DefaultEventoRepository, DefaultPersonaRepository, DefaultPatrocinadorRepository);
            var fechaInicio = new DateTime(2011, 8, 20, 18, 00, 00);
            var fechaTermino = fechaInicio.AddHours(2);

            var r = agenda.Agendar("Conceptos de HTTP y Fiddler web debugger", new[]{TestsHelper.GetOrCreatePonente("jjmontes")},  fechaInicio,
                           fechaTermino, string.Empty, TipoEvento.Van);
            Assert.IsTrue(r.Succeful);

            fechaInicio = new DateTime(2011, 8, 27, 05, 00, 00);
            fechaTermino = fechaInicio.AddHours(2);
            r = agenda.Agendar("Conceptos de HTTP y Fiddler web debugger",
                           new[]{TestsHelper.GetOrCreatePonente("alabra")},
                           fechaInicio,
                           fechaTermino, string.Empty, TipoEvento.Van);
            
            Assert.IsFalse(r.Succeful);
        }
	}
}