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

namespace AltNetHispano.Agendas.Tests
{
	[TestFixture]
	public class AgendaTests
	{
	    private static ISeguridad SeguridadServiceDefault
	    {
            get
            {
                var seguridad = new Mock<ISeguridad>();
                seguridad.Setup(s => s.GetPrincipal()).Returns(SeguridadObjectMother.GetGenericPrincipalAutenticadoSinRoles());
                return seguridad.Object;
            }
	    }

		[SetUp]
		public void LimpiarEventos()
		{
			var repository = new EventoRepository();
			foreach (var evento in repository.GetEventosConFecha())
				repository.Delete(evento);
			foreach (var evento in repository.GetEventosSinFecha())
				repository.Delete(evento);
		}

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

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

			var van = EventoObjectMother.GetVanValidaParaPublicar();

			agenda.Publicar(van.Titulo, van.Ponente, van.Fecha);
			Assert.AreEqual(1, agenda.GetEventosPublicados().Count);

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

        [Test]
        public void Publicar_van_sin_usuario_autenticado() {
            var seguridad = new Mock<ISeguridad>();
			seguridad.Setup(s => s.GetPrincipal()).Returns(SeguridadObjectMother.GetGenericPrincipalSinAutenticar());

			var publicador = new Mock<IPublicador>();
			var repository = new Mock<IEventoRepository>();

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

            var van = EventoObjectMother.GetVanValidaParaPublicar();

            Assert.Throws<UsuarioNoAutenticadoException>(() => agenda.Publicar(van.Titulo, van.Ponente, van.Fecha));

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

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

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

            var van = EventoObjectMother.GetVanValidaParaPublicar();

            Assert.Throws<UsuarioNoAutenticadoException>(() => agenda.Publicar(van.Titulo, van.Ponente, van.Fecha));
			repository.Verify(p => p.Save(It.IsAny<Evento>()), Times.Exactly(0));
		}

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

			publicador.Setup(p => p.Publicar(It.IsAny<Evento>())).Throws(new Exception("Error intencional"));

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

			var van = EventoObjectMother.GetVanValidaParaPublicar();
            Assert.Throws<Exception>(() => agenda.Publicar(van.Titulo, van.Ponente, van.Fecha));
			Assert.AreEqual(0, agenda.GetEventosPublicados().Count);

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

		[Test]
		public void Publicar_van_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 }), null, SeguridadServiceDefault, repository.Object);

			var van = EventoObjectMother.GetVanValidaParaPublicar();
            agenda.Publicar(van.Titulo, van.Ponente, van.Fecha);

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

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

			var publicador1 = new Mock<IPublicador>();
			var publicador2 = new Mock<IPublicador>();
			var recordador1 = new Mock<IRecordador>();

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

			var van = EventoObjectMother.GetVanValidaParaPublicar();
            agenda.Publicar(van.Titulo, van.Ponente, van.Fecha);

			agenda.Recordar(van);

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

			repository.Verify(p => p.Save(It.IsAny<Evento>()), Times.Exactly(1));
		}

		[Test]
		public void Propuesta_de_van_con_usuario_autenticado()
		{
			var repository = new EventoRepository();

			var van = new Evento { Titulo = "Van propuesta" };

            var seguridad = new Mock<ISeguridad>();
            var agenda = new Agenda(null, null, seguridad.Object, repository);
            
            seguridad.Setup(s => s.GetPrincipal()).Returns(SeguridadObjectMother.GetGenericPrincipalAutenticadoSinRoles());
			agenda.Proponer(van);

			IList<Evento> eventosPropuestos = agenda.GetEventosPropuestos();
			Assert.IsNotNull(eventosPropuestos);
			Assert.AreEqual(1, eventosPropuestos.Count);
			Assert.AreEqual("Van propuesta", eventosPropuestos[0].Titulo);
		}

        [Test]
        public void Verificar_propuesta_separada_de_publicacion()
        {
			var seguridad = new Mock<ISeguridad>();
            var agenda = new Agenda(null, null, seguridad.Object, new EventoRepository());

            var vanPropuesta = new Evento { Titulo = "Van propuesta" };
            var vanPublicada = EventoObjectMother.GetVanValidaParaPublicar();
            seguridad.Setup(s => s.GetPrincipal()).Returns(SeguridadObjectMother.GetGenericPrincipalAutenticadoSinRoles());

            agenda.Proponer(vanPropuesta);
            agenda.Publicar(vanPublicada.Titulo, vanPublicada.Ponente, vanPublicada.Fecha);

            IList<Evento> eventosPropuestos = agenda.GetEventosPropuestos();
            IList<Evento> eventosPublicados = agenda.GetEventosPublicados();

            Assert.AreEqual(1, eventosPropuestos.Count);
            Assert.AreEqual(1, eventosPublicados.Count);
		}

		[Test]
		public void Propuesta_de_van_sin_titulo()
		{
			var repository = new Mock<IEventoRepository>();
			var van = new Evento();

            var seguridad = new Mock<ISeguridad>();
            var agenda = new Agenda(null, null, seguridad.Object, repository.Object);
            
            Assert.Throws<ValidationException>(() => agenda.Proponer(van));
			Assert.AreEqual(Guid.Empty, van.Id);

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

		[Test]
		public void Agendar_van_propuesta_sin_fecha()
		{
			var repository = new EventoRepository();
			
			var seguridad = new Mock<ISeguridad>();
            var agenda = new Agenda(null, null, seguridad.Object, repository);
            
            seguridad.Setup(s => s.GetPrincipal()).Returns(SeguridadObjectMother.GetGenericPrincipalAutenticadoSinRoles());

			{
				var van = new Evento {Titulo = "Van propuesta"};
                agenda.Proponer(van);
			}

			{
				var van = agenda.GetEventosPropuestos().FirstOrDefault();
				Assert.IsNotNull(van);
                Assert.Throws<ValidationException>(() => agenda.Publicar(van.Titulo, van.Ponente, van.Fecha));
			}
		}

		[Test]
		public void Agendar_van_propuesta_sin_ponente()
		{
			var repository = new EventoRepository();
						
			var seguridad = new Mock<ISeguridad>();
            var agenda = new Agenda(null, null, seguridad.Object, repository);
            
            seguridad.Setup(s => s.GetPrincipal()).Returns(SeguridadObjectMother.GetGenericPrincipalAutenticadoSinRoles());

			{
				var van = new Evento { Titulo = "Van propuesta" };
                agenda.Proponer(van);
			}

			{
				var van = agenda.GetEventosPropuestos().FirstOrDefault();
				Assert.IsNotNull(van);

				van.Fecha = DateTime.Today.AddDays(5);
                Assert.Throws<ValidationException>(() => agenda.Publicar(van.Titulo, van.Ponente, van.Fecha));
			}
		}

		[Test]
		public void Van_crud()
		{
			var van = EventoObjectMother.GetVanValidaParaPublicar();
            
            Guid vanId;
			{
                var agenda = new Agenda(null, null, SeguridadServiceDefault, new EventoRepository());
                agenda.Publicar(van.Titulo, van.Ponente, van.Fecha);

				IAgendaRepository agendaRepository = new AgendaRepository();

				agendaRepository.Save(agenda);
				vanId = agenda.Id;
			}

			{
				IAgendaRepository agendaRepository = new AgendaRepository();

				Agenda agenda = agendaRepository.Get(vanId);

				Assert.IsNotNull(agenda);
				Assert.AreEqual(1, agenda.GetEventosPublicados().Count);
                agenda.Publicar(van.Titulo, van.Ponente, van.Fecha);

				agendaRepository.Update(agenda);
			}

			{
				IAgendaRepository agendaRepository = new AgendaRepository();

				Agenda agenda = agendaRepository.Get(vanId);

				Assert.IsNotNull(agenda);
				Assert.AreEqual(2, agenda.GetEventosPublicados().Count);

				agendaRepository.Delete(agenda);
			}

			{
				IAgendaRepository agendaRepository = new AgendaRepository();

				Agenda agenda = agendaRepository.Get(vanId);

				Assert.IsNull(agenda);
			}
		}
	}
}