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"));

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

			Assert.Throws<Exception>(() => agenda.Agendar("Van para publicar", "jjmontes", DateTime.Now, urlInvitacion));
			Assert.AreEqual(0, agenda.GetEventosAgendados().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>();

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

			Assert.Throws<IdentityContextNotConfiguredException>(
				() => agenda.Agendar("Van para publicar", "jjmontes", DateTime.Now,
					urlInvitacion));
			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>();

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

			Assert.Throws<UsuarioNoAutenticadoException>(() => agenda.Agendar("Van para publicar", "jjmontes", DateTime.Now,
				urlInvitacion));

			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_evento_sin_ponente()
		{
			var agenda = new Agenda(null, DefaultEventoRepository, DefaultPersonaRepository);

			var r = agenda.Agendar("Van para publicar", string.Empty, DateTime.Now,
				urlInvitacion);

			Assert.IsFalse(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>();

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

			agenda.Agendar("Van para publicar", "jjmontes", DateTime.Now,
				urlInvitacion);

			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);

			agenda.Agendar("Van para publicar", "jjmontes", DateTime.Now,
				urlInvitacion);

			Assert.AreEqual(0, agenda.GetEventosPropuestos().Count);

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

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

			var evento = eventos[0];
			
			Assert.IsNotNull(evento.Ponente);
		}

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

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

			agenda.Agendar("Van para publicar", "jjmontes", DateTime.Now,
				urlInvitacion);

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

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

			DateTime fecha = evento.Fecha.Value.AddDays(7);
			agenda.ModificarEvento(evento.Id, "otro titulo", "otro ponente", fecha, urlInvitacion);

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

			evento = repository.GetEventosConFecha().First();
			Assert.AreEqual("otro titulo", evento.Titulo);
			Assert.AreEqual("otro ponente", evento.Ponente.Nombre);
			Assert.AreEqual(fecha, evento.Fecha);

			var idEventoNoExistente = new Guid("99999999999999999999999999999999");
			Assert.Throws<EventoNotFoundException>(
				() => agenda.ModificarEvento(idEventoNoExistente, "algún título", "un ponente", DateTime.Now, 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);

			agenda.Agendar("Van para publicar", "jjmontes", DateTime.Now,
				urlInvitacion);

			var van = agenda.GetEventosAgendados().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);

			agenda.Proponer("Html 5", "jjmontes", urlInvitacion);
			Assert.AreEqual(1, agenda.GetEventosPropuestos().Count);
			Assert.AreEqual(0, agenda.GetEventosAgendados().Count);

			var publicado = agenda.GetEventosPropuestos().First();
			Assert.AreEqual(1, publicado.Tracks.Count());

			agenda.ModificarEvento(publicado.Id, "Html 5", "jjmontes", DateTime.Today.AddDays(5), urlInvitacion);
			Assert.AreEqual(0, agenda.GetEventosPropuestos().Count);
			Assert.AreEqual(1, agenda.GetEventosAgendados().Count);

			var agendado = agenda.GetEventosAgendados().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);
      agenda.Proponer("Html 5", "jjmontes", urlInvitacion);

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

      Assert.IsInstanceOf(typeof(EventoPropuestoState), evento.GetEstado());
      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);
      agenda.Agendar("Html 5", "jjmontes", DateTime.MinValue, urlInvitacion);

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

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

    [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);
      agenda.Agendar("Html 5", "jjmontes", DateTime.MinValue, urlInvitacion);

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

      agenda.Confirmar(evento.Id);

      Assert.IsInstanceOf(typeof(EventoConfirmadoState), evento.GetEstado());
      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()
    {
 			var publicador1 = new Mock<IPublicador>();

      var agenda = new Agenda(publicador1.Object, DefaultEventoRepository, DefaultPersonaRepository);
      agenda.Agendar("Html 5", "jjmontes", DateTime.MinValue, urlInvitacion);

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

      agenda.Confirmar(evento.Id);
      agenda.Publicar(evento.Id);

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

    [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);
      agenda.Proponer("Html 5", "jjmontes", urlInvitacion);

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

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

      agenda.Confirmar(evento.Id);
    }

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

      var agenda = new Agenda(publicador1.Object, DefaultEventoRepository, DefaultPersonaRepository);
      agenda.Proponer("Html 5", "jjmontes", urlInvitacion);

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

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

      agenda.Publicar(evento.Id);
    }
	}
}