using System;
using System.Collections.Generic;
using AltNetHispano.Agendas.Domain.Exceptions;
using AltNetHispano.Agendas.Domain.Repositories;

namespace AltNetHispano.Agendas.Domain
{
	public class Agenda
	{
		private readonly IPublicador _publicador;
		private readonly IRecordador _recordador;
        private readonly ISeguridad _seguridad;
		private readonly IEventoRepository _eventosRepository;
		private readonly IPonenteRepository _ponenteRepository;

		public Agenda(IPublicador publicador, IRecordador recordador, ISeguridad seguridad, IEventoRepository eventosRepository, IPonenteRepository ponenteRepository)
		{
			_publicador = publicador;
			_ponenteRepository = ponenteRepository;
			_eventosRepository = eventosRepository;
			_recordador = recordador;
            _seguridad = seguridad;
		}

        public void Publicar(string titulo, string ponenteNombre, DateTime? fecha)
        {
        	var ponente = GetPonente(ponenteNombre);

        	var evento = _eventosRepository.GetPropuestaByTitulo(titulo) ?? new Evento (titulo);
            evento.Actualizar(ponente, fecha);

        	if (!evento.Fecha.HasValue)
        		throw new ValidationException();
        	if (NoEstaAutenticado(_seguridad))
        		throw new UsuarioNoAutenticadoException();
        	if (string.IsNullOrWhiteSpace(evento.Ponente.Nombre))
        		throw new ValidationException();

        	if (_publicador != null)
        		_publicador.Publicar(evento);

            evento.AddTracks(new Track(Accion.Publicar));

        	_eventosRepository.Save(evento);
        	_ponenteRepository.Save(ponente);
        }

		public void Recordar(Guid eventoId)
		{
			var evento = _eventosRepository.Get(eventoId);
			if (_recordador != null)
				_recordador.Recordar(evento);
		}

		public void Proponer(string titulo, string ponenteNombre)
		{
			var ponente = GetPonente(ponenteNombre);
			var evento = new Evento (titulo);
		    evento.Actualizar(ponente);

			if (string.IsNullOrWhiteSpace(evento.Titulo))
				throw new ValidationException();
            if (NoEstaAutenticado(_seguridad))
                throw new UsuarioNoAutenticadoException();
			_eventosRepository.Save(evento);
			_ponenteRepository.Save(ponente);
		}

        public IList<Evento> GetEventosPropuestos()
        {
			return _eventosRepository.GetEventosSinFecha() ?? new List<Evento>();
        }

        public IList<Evento> GetEventosPublicados()
        {
            return _eventosRepository.GetEventosConFecha() ?? new List<Evento>();
        }

        private static bool NoEstaAutenticado(ISeguridad seguridad)
        {
            return seguridad == null || seguridad.GetPrincipal() == null
                || string.IsNullOrWhiteSpace(seguridad.GetPrincipal().Identity.Name);
        }

		public void ModificarEvento(Guid id, string titulo, string ponenteNombre, DateTime? fecha)
		{
			var evento = _eventosRepository.Get(id);
			if (evento == null)
				throw new EventoNotFoundException();

			var ponente = GetPonente(ponenteNombre);

            if (evento.Titulo != titulo)
            {
                evento.CambiarTitulo(titulo);
                evento.AddTracks(new Track(Accion.CambiarTitulo));
            }

		    if (evento.Fecha != fecha || evento.Ponente != ponente)
            {
                evento.Actualizar(ponente, fecha);
                evento.AddTracks(new Track(Accion.Modificar));
            }


		    if (_publicador != null)
				_publicador.Publicar(evento);
		}

		public Evento GetEvento(Guid id)
		{
			return _eventosRepository.Get(id);
		}

		public void RegistrarPonente(string nombre, string mail, string twitter, string blog)
		{
		    var ponente = new Ponente(nombre, mail, twitter, blog);
			_ponenteRepository.Save(ponente);
		}

		private Ponente GetPonente(string nombre)
		{
		    var ponente=_ponenteRepository.GetByNombre(nombre) ?? new Ponente(nombre);
            _ponenteRepository.Save(ponente);
		    return ponente;
		}

		public void ModificarPropuesta(Guid id, string titulo, string ponenteNombre)
		{
			ModificarEvento(id, titulo, ponenteNombre, null);
		}

	    public void RealizarEvento(Guid eventoId, string sintesis)
	    {
	        var evento = _eventosRepository.Get(eventoId);
            if (evento != null)
            {
                evento.Realizado(sintesis);
                evento.AddTracks(new Track(Accion.Realizar));
            }
	    }
	}

	public class EventoNotFoundException : Exception
	{
	}

	public class UsuarioNoAutenticadoException : Exception
    {
    }
}