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

namespace AltNetHispano.Agendas.Domain
{
    public class Agenda
    {
        private readonly IEventoRepository _eventosRepository;
        private readonly IPersonaRepository _personaRepository;
        private readonly IPatrocinadorRepository _patrocinadorRepository;

        private readonly IPublicador _publicador;

        public Agenda(IPublicador publicador, IEventoRepository eventosRepository,
                      IPersonaRepository personaRepository, IPatrocinadorRepository patrocinadorRepository)
        {
            _publicador = publicador;
            _patrocinadorRepository = patrocinadorRepository;
            _personaRepository = personaRepository;
            _eventosRepository = eventosRepository;
        }

        public Evento GetEvento(Guid eventoId)
        {
            Evento evento = _eventosRepository.Get(eventoId);
            if (evento == null)
                throw new EventoNotFoundException(eventoId);
            return evento;
        }

        public IList<Evento> GetEventosActivos(EventoState state)
        {
            return _eventosRepository.GetByState(state) ?? new List<Evento>();
        }

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

        public IEnumerable<Evento> GetHistorico()
        {
            return _eventosRepository.GetByState(EventoPublicadoState.GetInstance()) ?? new List<Evento>();
        }

        public Resultado ModificarEvento(Guid eventoId, string titulo, Guid ponenteId, DateTime? fecha, string urlInvitacion)
        {
            Evento evento = GetEvento(eventoId);
            Persona persona = _personaRepository.Get(ponenteId);

            if (evento.Titulo != titulo)
                evento.CambiarTitulo(titulo);

            if (evento.Fecha == null && fecha != null)
                evento.Agendar(persona, fecha, urlInvitacion);
            else if (evento.Fecha != fecha || evento.Ponente != persona || evento.UrlInvitacion != urlInvitacion)
                evento.Actualizar(persona, fecha, urlInvitacion);

            Notify(evento);

            return new Resultado(true);
        }

        public Resultado ModificarPropuesta(Guid id, string titulo, Guid ponenteId, string urlInvitacion)
        {
            return ModificarEvento(id, titulo, ponenteId, null, urlInvitacion);
        }

        public Resultado Proponer(string titulo, Guid? ponenteId, string urlInvitacion, TipoEvento tipo)
        {
            Persona persona = null;
            if (ponenteId.HasValue)
                persona = _personaRepository.Get(ponenteId.Value);

            var evento = Evento.Proponer(titulo, persona, urlInvitacion, tipo);

            if (string.IsNullOrWhiteSpace(evento.Titulo))
                return new Resultado(false);

            Notify(evento);

            _eventosRepository.Save(evento);

            return new Resultado(true);
        }

        public Resultado Agendar(string titulo, Guid ponenteId, DateTime? fecha, string urlInvitacion, TipoEvento tipo)
        {
            if (!fecha.HasValue)
                return new Resultado(false);

            Persona persona = _personaRepository.Get(ponenteId);
            if (persona == null)
                return new Resultado(false)
                           {Message = string.Format("No se encontró el ponente indicado ({0})", ponenteId)};

            Evento evento = _eventosRepository.GetPropuestaByTitulo(titulo);
            if (evento == null)
                evento = Evento.Agendar(titulo, persona, fecha.Value, urlInvitacion, tipo);
            else
                evento.Agendar(persona, fecha, urlInvitacion);

            Notify(evento);

            _eventosRepository.Save(evento);

            return new Resultado(true);
        }

        public Resultado Confirmar(Guid eventoId)
        {
            Evento evento = GetEvento(eventoId);

            evento.Confirmar();

            Notify(evento);

            _eventosRepository.Save(evento);

            return new Resultado(true);
        }

        public Resultado Publicar(Guid eventoId, short numeroOrden, string urlWiki)
        {
            if (numeroOrden <= 0)
                throw new ArgumentOutOfRangeException("numeroOrden");

            if (string.IsNullOrWhiteSpace(urlWiki))
                throw new ArgumentException("urlWiki");

            Evento evento = GetEvento(eventoId);

            evento.Publicar(numeroOrden, urlWiki);

            Notify(evento);

            _eventosRepository.Save(evento);

            return new Resultado(true);
        }

        private void Notify(Evento evento)
        {
            var tracks = evento.GetTrackNews();
            if (_publicador != null)
                _publicador.Publicar(tracks);
        }

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

        public Resultado Cancelar(Guid eventoId)
        {
            Evento evento = GetEvento(eventoId);

            evento.Cancelar();

            Notify(evento);

            _eventosRepository.Save(evento);

            return new Resultado(true);
        }

        public Resultado Descartar(Guid eventoId)
        {
            Evento evento = GetEvento(eventoId);

            evento.Descartar();

            Notify(evento);

            _eventosRepository.Save(evento);

            return new Resultado(true);
        }

        public Resultado ReProponer(Guid eventoId)
        {
            Evento evento = GetEvento(eventoId);

            evento.ReProponer();

            Notify(evento);

            _eventosRepository.Save(evento);

            return new Resultado(true);
        }

        public Resultado ReAgendar(Guid eventoId)
        {
            Evento evento = GetEvento(eventoId);

            evento.ReAgendar();

            Notify(evento);

            _eventosRepository.Save(evento);

            return new Resultado(true);
        }

        public void IndicarPatrocinadores(Guid eventoId, IEnumerable<Guid> patrocinadores)
        {
            var evento = GetEvento(eventoId);

            var agregar = new List<Patrocinador>();
            var quitar = new List<Patrocinador>();

            foreach (var patrocinadorId in patrocinadores)
            {
                if (!evento.Patrocinadores.Any(p => p.Id == patrocinadorId))
                {
                    var patrocinador = _patrocinadorRepository.Get(patrocinadorId);
                    agregar.Add(patrocinador);
                }
            }

            foreach (var patrocinador in evento.Patrocinadores)
            {
                if (!patrocinadores.Any(p => p == patrocinador.Id))
                    quitar.Add(patrocinador);
            }

            foreach (var patrocinador in agregar)
                evento.AddPatrocinador(patrocinador);

            foreach (var patrocinador in quitar)
                evento.RemovePatrocinador(patrocinador);
        }
    }
}