using System;
using System.Collections.Generic;
using System.Linq;

namespace AltNetHispano.Agendas.Domain
{
	public class Evento : Identificable
	{
		protected Evento()
		{
			_tracks = new List<Track>();
			_ponentes = new List<Persona>();
			_patrocinadores = new List<Patrocinador>();
		}

		#region Propiedades del Evento

		private readonly IList<Track> _tracks;
		private readonly ICollection<Track> _newTracks = new List<Track>();

		/// <summary>
		/// Título del evento
		/// </summary>
		public virtual string Titulo { get; private set; }

		/// <summary>
		/// Fecha para la que se encuentra agendado el evento
		/// </summary>
		public virtual DateTime? FechaInicio { get; private set; }

        /// <summary>
        /// Fecha de termino o finalización del evento.
        /// </summary>
        public virtual DateTime? FechaTermino { get; private set; }

	    /// <summary>
		/// Url con la invitacion realizada por el ponente (en la mayoria de los casos va a ser un link al thread de la lista de correo)
		/// </summary>
		public virtual string UrlInvitacion { get; private set; }

		/// <summary>
		/// Url a la pagina de la wiki con el video de la reunion virtual
		/// </summary>
		public virtual string UrlWiki { get; private set; }

		/// <summary>
		/// Numero de orden en el historico de reuniones virtuales
		/// </summary>
		public virtual short NumeroOrden { get; private set; }

		/// <summary>
		/// Ponente o responsable del evento
		/// </summary>
		/// public virtual Persona Ponente { get; private set; }

		/// <summary>
		/// Track de cambios que ha sufrido el evento
		/// </summary>
		public virtual IEnumerable<Track> Tracks
		{
			get { return _tracks; }
		}

		private EventoState _estado;

		/// <summary>
		/// Estado del evento en formato string (para persistencia a DB)
		/// </summary>
		public virtual EventoState Estado
		{
			get { return _estado ?? EventoNullState.GetInstance(); }
			set { _estado = value; }
		}

		private IList<Patrocinador> _patrocinadores;

		public virtual TipoEvento Tipo { get; private set; }

		public virtual IEnumerable<Patrocinador> Patrocinadores
		{
			get
			{
				return _patrocinadores;
			}
		}

		/// <summary>
		/// Determina la duración de un evento.
		/// </summary>
		public virtual TimeSpan Duracion
		{
			get; set;
		}

		private readonly IList<Persona> _ponentes;
		public virtual IEnumerable<Persona> Ponentes
		{
			get { return _ponentes; }
		}

		public virtual void ActualizarPonentes(IEnumerable<Persona> ponentes, Accion? action)
		{
			bool modificados = false;
			
			foreach (var ponente in ponentes)
			{
				if (!_ponentes.Contains(ponente))
				{
					_ponentes.Add(ponente);
					modificados = true;
				}
			}
			var sobran = _ponentes.Where(c => !ponentes.Contains(c)).ToList();

			foreach (var sobra in sobran)
			{
				_ponentes.Remove(sobra);
				modificados = true;
			}

			if (modificados && action.HasValue)
				AddTrack(new Track(this, action.Value));
		}

		protected internal virtual void AddPatrocinador(Patrocinador patrocinador)
		{
			_patrocinadores.Add(patrocinador);
		}

		protected internal virtual void RemovePatrocinador(Patrocinador patrocinador)
		{
			_patrocinadores.Remove(patrocinador);
		}


		#endregion

		#region Acciones sobre el evento

		/// <summary>
		/// Propone un evento
		/// </summary>
		/// <param name="titulo">Título del evento propuesto</param>
		/// <param name="persona">Ponente para evento propuesto</param>
		/// <param name="urlInvitacion">Url con la invitación realizada por el ponente</param>
		/// <param name="tipo">Tipo del evento</param>
		/// <returns></returns>
		public static Evento Proponer(string titulo, string urlInvitacion, TipoEvento tipo)
		{
			var evento = new Evento { Titulo = titulo, UrlInvitacion = urlInvitacion, Tipo = tipo };
			evento.Estado.Promover(evento, Accion.Proponer);

			return evento;
		}

	    /// <summary>
	    /// Agenda un evento que no estaba propuesto
	    /// </summary>
	    /// <param name="titulo">Título del evento a agendar</param>
	    /// <param name="fechaInicio">Fecha de realización del evento</param>
	    /// <param name="fechaTermino">Fecha de termino del evento</param>
	    /// <param name="urlInvitacion">Url con la invitación realizada por el ponente</param>
	    /// <param name="tipo">Tipo del evento</param>
	    /// <returns></returns>
	    public static Evento Agendar(string titulo, DateTime fechaInicio, DateTime fechaTermino, string urlInvitacion, TipoEvento tipo)
		{
			var evento = new Evento { Titulo = titulo, Tipo = tipo };
			evento.Agendar(fechaInicio, fechaTermino, urlInvitacion);

			return evento;
		}

	    /// <summary>
	    /// Agenda el evento actual
	    /// </summary>
        /// <param name="fechaInicio">Fecha de realización del evento</param>
	    /// <param name="fechaTermino">Fecha de termino del evento</param>
	    /// <param name="urlInvitacion">Url con la invitación realizada por el ponente</param>
	    public virtual void Agendar(DateTime? fechaInicio, DateTime? fechaTermino, string urlInvitacion)
		{
            FechaInicio = fechaInicio;
	        FechaTermino = fechaTermino;
			UrlInvitacion = urlInvitacion;
			Estado.Promover(this, Accion.Agendar);
		}

		public virtual void Actualizar(DateTime? fechaInicio, DateTime? fechaTermino, string urlInvitacion)
		{
			FechaInicio = fechaInicio;
		    FechaTermino = fechaTermino;
			UrlInvitacion = urlInvitacion;

			AddTrack(new Track(this, Accion.Modificar));
		}

		public virtual void CambiarTitulo(string titulo)
		{
			Titulo = titulo;
			AddTrack(new Track(this, Accion.CambiarTitulo));
		}

		public virtual void Confirmar()
		{
			Estado.Promover(this, Accion.Confirmar);
		}

		public virtual void Publicar(short numeroOrden, string urlWiki, TimeSpan duracion)
		{
			NumeroOrden = numeroOrden;
			UrlWiki = urlWiki;
			Duracion = duracion;
			Estado.Promover(this, Accion.Publicar);
		}

		public virtual void Cancelar()
		{
			Estado.Promover(this, Accion.Cancelar);
		}

		public virtual void Descartar()
		{
			Estado.Promover(this, Accion.Descartar);
		}

		public virtual void ReProponer()
		{
			Estado.Promover(this, Accion.ReProponer);
		}

		public virtual void ReAgendar()
		{
			Estado.Promover(this, Accion.ReAgendar);
		}
		#endregion

		protected internal virtual void AddTrack(Track track)
		{
			_newTracks.Add(track);
			_tracks.Add(track);
		}

		public virtual IEnumerable<Track> GetTrackNews()
		{
			return _newTracks;
		}

		public virtual IEnumerable<TrackLog> GetLogsNews()
		{
			var logs = new List<TrackLog>();
			foreach (var track in _newTracks)
				logs.AddRange(track.GetLogsNews());
			return logs;
		}

		public virtual string GetPonentesAsString(Func<Persona, string> predicate)
		{
    		var nombres = Ponentes.Select(predicate.Invoke).ToArray();
			string texto = string.Empty;
			for (int i = 0; i < nombres.Length; i++)
			{
				var nombre = nombres[i];
				if (i == nombres.Length - 1 && i>0)
					texto += " y ";
				else if (i != 0)
					texto += ", ";
				texto += nombre;
			}
			return texto;
		}
	}
}