using System;
using System.Linq;
using AltNetHispano.Agendas.Domain;
using AltNetHispano.Agendas.Domain.Repositories;
using AltNetHispano.Agendas.Domain.Services;
using Moq;
using NUnit.Framework;

namespace AltNetHispano.Agendas.Tests
{
	[TestFixture]
	public class PersonaServiceTests : TestBase
	{
		[Test]
		public void Crear_nueva_persona()
		{
			var personaRepository = new Mock<IPersonaRepository>();
			Persona persona=null;
			personaRepository.Setup(r => r.Save(It.IsAny<Persona>())).Callback<Persona>(p => persona = p);

            var personaService = new PersonaService(personaRepository.Object, DefaultEventoRepository);
			
			Assert.IsTrue(personaService.CreateIfNotExist(IdentityProviderEnum.Twitter, "nelopauselli", "Nelo Pauselli"));
			personaRepository.Verify(r=>r.Save(It.IsAny<Persona>()), Times.Once());
			Assert.IsNotNull(persona);
			Assert.AreEqual(1, persona.Cuentas.Count());
			Assert.AreEqual("nelopauselli", persona.Twitter);

			Cuenta cuenta = persona.Cuentas.First();
			Assert.AreEqual(IdentityProviderEnum.Twitter, cuenta.IdentityProvider);
			Assert.AreEqual("nelopauselli", cuenta.LogonName);

			personaRepository.Setup(r => r.GetCuenta(IdentityProviderEnum.Twitter, "nelopauselli")).Returns(cuenta);

			Assert.AreEqual(1, persona.Cuentas.Count());
			Assert.IsTrue(personaService.CreateIfNotExist(IdentityProviderEnum.Twitter, "nelopauselli", "Nelo Pauselli"));
			Assert.AreEqual(1, persona.Cuentas.Count());
		}

		[Test]
		public void Crear_persona_duplicada_por_nombre()
		{
			var personaRepository = new Mock<IPersonaRepository>();
			
			var persona = new Persona("Nelo Pauselli");
			personaRepository.Setup(r => r.GetByNombre(It.IsAny<string>())).Returns(persona);
			var personaService = new PersonaService(personaRepository.Object, DefaultEventoRepository);

			var result = personaService.Add("Nelo Pauselli", "nelopauselli", "nelopauselli@gmail.com", null, null);
			Assert.IsFalse(result.Succeful);
			Assert.AreEqual("Ya existe una persona con el nombre Nelo Pauselli", result.Message);

			personaRepository.Verify(r => r.Save(It.IsAny<Persona>()), Times.Never());
		}

		[Test]
		public void Crear_persona_duplicada_por_twitter()
		{
			var personaRepository = new Mock<IPersonaRepository>();

			var persona = new Persona("Nelo Pauselli");
			personaRepository.Setup(r => r.GetByTwitter(It.IsAny<string>())).Returns(persona);
			var personaService = new PersonaService(personaRepository.Object, DefaultEventoRepository);

			var result = personaService.Add("Nelo Pauselli", "nelopauselli", "nelopauselli@gmail.com", null, null);
			Assert.IsFalse(result.Succeful);
			Assert.AreEqual("Ya existe una persona con el twitter nelopauselli", result.Message);

			personaRepository.Verify(r => r.Save(It.IsAny<Persona>()), Times.Never());
		}

        [Test]
        public void Asociar_persona_existente_por_twitter()
        {
            var personaRepository = DefaultPersonaRepository;

            personaRepository.Save(new Persona("Mariano Pauselli", "marianopauselli@gmail.com", "marianopauselli", "http://marianopauselli.blogspot.com"));
            var personaService = new PersonaService(personaRepository, DefaultEventoRepository);

            Assert.IsTrue(personaService.CreateIfNotExist(IdentityProviderEnum.Twitter, "marianopauselli", "Mariano Pauselli"));

            var persona = personaRepository.GetByNombre("Mariano Pauselli");
            Assert.IsNotNull(persona);
            Assert.AreEqual(1, persona.Cuentas.Count());
            Assert.AreEqual("marianopauselli", persona.Twitter);

            Cuenta cuenta = persona.Cuentas.First();
            Assert.AreEqual(IdentityProviderEnum.Twitter, cuenta.IdentityProvider);
            Assert.AreEqual("marianopauselli", cuenta.LogonName);

            Assert.AreEqual(1, persona.Cuentas.Count());
            Assert.IsTrue(personaService.CreateIfNotExist(IdentityProviderEnum.Twitter, "marianopauselli", "Mariano Pauselli"));
            Assert.AreEqual(1, persona.Cuentas.Count());
        }

        [Test]
        public void Agregar_y_modificar_persona()
        {
            var personaRepository = DefaultPersonaRepository;

            var personaService = new PersonaService(personaRepository, DefaultEventoRepository);
			var r = personaService.Add("Mariano Pauselli", "marianopauselli", string.Empty, string.Empty, null);
            Assert.IsTrue(r.Succeful);

            var todas = personaService.GetAll();
            Assert.AreEqual(2, todas.Count());

            var p1 = todas.SingleOrDefault(p => p.Nombre == "Mariano Pauselli");
            Assert.IsNotNull(p1);
            
            var personaId = p1.Id;
            var p2 = personaService.GetById(personaId);

            Assert.AreEqual(p1, p2);
            Assert.AreSame(p1, p2);

            personaService.Update(personaId, p1.Nombre, p1.Twitter, "marianopauselli@gmail.com", string.Empty,null);

            var p3 = personaService.GetById(personaId);
            Assert.IsNotNull(p3);
            Assert.AreEqual("marianopauselli@gmail.com",p3.Mail);
        }

        [Test]
        public void Agregar_y_modificar_cuenta()
        {
            var personaRepository = DefaultPersonaRepository;

            var p1 = personaRepository.GetByTwitter("nelopauselli");
            Assert.IsNotNull(p1);
            Assert.AreEqual(1, p1.Cuentas.Count());

            var personaService = new PersonaService(personaRepository, DefaultEventoRepository);

            personaService.AddCuenta(IdentityProviderEnum.Google, "nelopauselli");

            var p2 = personaRepository.GetByTwitter("nelopauselli");
            Assert.IsNotNull(p2);
            Assert.AreEqual(2, p2.Cuentas.Count());

            var personaId = p2.Id;

            personaService.RemoveCuenta(IdentityProviderEnum.Google, "nelopauselli");
            Assert.AreEqual(1, personaRepository.Get(personaId).Cuentas.Count());

            personaService.RemoveCuenta(IdentityProviderEnum.Twitter, "nelopauselli");
            Assert.AreEqual(0, personaRepository.Get(personaId).Cuentas.Count());

        }

		[Test]
		public void IdentificacionGoogle()
		{
            var builtIn = new Identification(Identification.Map[(int)IdentityProviderEnum.Google] + "nelo");
            Assert.AreEqual(IdentityProviderEnum.Google, builtIn.IdentityProvider);
			Assert.AreEqual("nelo", builtIn.LogonName);
		}

		[Test]
		public void IdentificacionTwitter()
		{
			var builtIn = new Identification(Identification.Map[(int)IdentityProviderEnum.Twitter] + "nelo");
			Assert.AreEqual(IdentityProviderEnum.Twitter, builtIn.IdentityProvider);
			Assert.AreEqual("nelo", builtIn.LogonName);
		}

		[Test]
		public void Modificar_persona_inexistente()
		{
			var personaRepository = DefaultPersonaRepository;
            var personaService = new PersonaService(personaRepository, DefaultEventoRepository);
			var r = personaService.Update(new Guid(), "Mariano Pauselli", "marianopauselli", "marianopauselli@gmail.com", string.Empty, null);

			Assert.IsFalse(r.Succeful);
		}

        [Test]
        public void Modificar_persona_con_datos_existentes()
        {
            var personaRepository = DefaultPersonaRepository;

            var personaService = new PersonaService(personaRepository, DefaultEventoRepository);
            var r = personaService.Add("Mariano Pauselli", "marianopauselli", string.Empty, string.Empty, null);
            Assert.IsTrue(r.Succeful);

            r = personaService.Add("Juan José Montes de Oca Arbós", "jjmoa", string.Empty, string.Empty, null);
            Assert.IsTrue(r.Succeful);

            var todas = personaService.GetAll();
            var personaNelo = todas.SingleOrDefault(p => p.Twitter == "marianopauselli");
            var personaJuan = todas.SingleOrDefault(p => p.Twitter == "jjmoa");
            Assert.IsNotNull(personaNelo);
            Assert.IsNotNull(personaJuan);

            var resultUpdate = personaService.Update(personaJuan.Id, personaNelo.Nombre, personaNelo.Twitter, string.Empty, string.Empty, null);
            Assert.IsFalse(resultUpdate.Succeful);
            Assert.AreEqual("Ya existe una persona con el twitter marianopauselli", resultUpdate.Message);
        }

        [Test]
        public void Eliminar_persona_no_asociado_van()
        {
            var personaRepository = DefaultPersonaRepository;

            var personaService = new PersonaService(personaRepository, DefaultEventoRepository);
            var r = personaService.Add("Alejandro Labra", "alabras", "alejandro.labra@gmail.com", string.Empty, null);
            Assert.IsTrue(r.Succeful);
            
            var persona = personaRepository.GetByNombre("Alejandro Labra");
            Assert.IsNotNull(persona);

            var delete = personaService.Delete(persona.Id);
            Assert.IsTrue(delete.Succeful);
        }

        [Test]
        public void Eliminar_persona_asociado_vans()
        {
            var publicador = new Mock<IPublicador>();
            var personaService = new PersonaService(DefaultPersonaRepository, DefaultEventoRepository);

			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("alabra")}, fechaInicio, fechaTermino,
                           "http://groups.google.com/group/altnet-hispano/browse_thread/thread/65d6d26eb381386e", TipoEvento.Van);

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

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

            var evento = eventos[0];

        	var ponente = evento.Ponentes.FirstOrDefault();
            Assert.IsNotNull(ponente);

            var delete = personaService.Delete(ponente.Id);
            Assert.IsFalse(delete.Succeful);
        }
	}
}