using EPAServeur.Context;
using EPAServeur.Exceptions;
using EPAServeur.IServices;
using EPAServeur.Models.EP;
using IO.Swagger.ApiCollaborateur;
using IO.Swagger.ClientCollaborateur;
using IO.Swagger.DTO;
using IO.Swagger.ModelCollaborateur;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace EPAServeur.Services
{
	public class ReferentEPService : IReferentEPService
	{
		private readonly EpContext context;
		private readonly ICollaborateurApi collaborateurApi;

		#region Constructeurs
		public ReferentEPService(EpContext _context, ICollaborateurApi _collaborateurApi)
		{
			context = _context;
			collaborateurApi = _collaborateurApi;
		}
		#endregion

		#region Service Async
		public async Task<ReferentEPDTO> UpdateCollaborateursReferentAsync(ReferentEPDTO body, Guid? idReferent)
		{
			//Vérifier que l'id du référent et l'id référent dans l'objet body est le même
			CheckReferentId(idReferent, body);


			Collaborateur referent = await collaborateurApi.ChercherCollabIdAsync(idReferent);

			//Vérifier que le référent est valide
			CheckReferentValide(referent);


			IEnumerable<Collaborateur> collaborateurs = await collaborateurApi.ChercherCollabAsync(collabsId: body.IdsCollaborateur);


			//Vérifier que la liste des collaborateurs est valide
			CheckListesCollaborateurs(collaborateurs);
			//Si il manque un collaborateur, c'est qu'il n'a pas été trouvé
			if (collaborateurs.Count() < body.IdsCollaborateur.Count)
				throw new CollaborateurNotFoundException("Un collaborateur n'a pas pu être récupéré");


			//Si on se retrouve avec plus de collaborateur que demandé
			if (collaborateurs.Count() > body.IdsCollaborateur.Count)
				throw new ApiException(415, "Une erreur est survenu lors de la récupération des données avec le serveur");

			this.SetReferentEPAsync(body.IdsCollaborateur, idReferent);

			return body;
		}

		public async Task<ReferentEPDTO> UpdateReferentCollaborateurAsync(ReferentEPDTO body, Guid? idCollaborateur)
		{
			CheckCollaborateurId(idCollaborateur, body);
			CheckListesIdsCollaborateurs(body.IdsCollaborateur);

			Collaborateur referent = await collaborateurApi.ChercherCollabIdAsync(body.IdReferent);
			CheckReferentValide(referent);

			Collaborateur collaborateur = await collaborateurApi.ChercherCollabIdAsync(idCollaborateur);
			CheckCollaborateurValide(collaborateur);
			
			bool premierReferentEP = false;
			ReferentEP referentEP = await context.ReferentEP.FindAsync(idCollaborateur);
			if (referentEP == null)
			{
				referentEP = new ReferentEP
				{
					IdCollaborateur = idCollaborateur.Value
				};
				premierReferentEP = true;
			}

			//Si le nouveau référent est déjà le référent actuel du collaborateur, il n'est pas nécessaire de faire quoique ce soit
			if (referentEP.IdReferent != null && referentEP.IdReferent.HasValue && referentEP.IdReferent.Value.Equals(body.IdReferent.Value))
			{
				return body;
			}


			Guid? ancienReferent = referentEP.IdReferent; //Si non null, il faudra notifier le référent qu'il n'est plus le référent EP du collaborateur


			referentEP.IdReferent = body.IdReferent;
			if (premierReferentEP)
			{
				await context.ReferentEP.AddAsync(referentEP);
			}
			await context.SaveChangesAsync();

			if (ancienReferent != null && ancienReferent.HasValue)
			{
				//notifier l'ancien référent 
			}
			//TODO : Notifier le référent et le collaborateur

			return body;
		}
		#endregion

		#region Methodes privees Sync

		/// <summary>
		/// Vérifier que l'id référent en paramètre et celui dans l'objet sont les même
		/// </summary>
		/// <param name="idReferent">Id du référent dans l'url</param>
		/// <param name="body">objet contenant l'id du référent</param>
		private void CheckReferentId(Guid? idReferent, ReferentEPDTO body) {
			if (!body.IdReferent.HasValue || !idReferent.Value.Equals(body.IdReferent.Value))
				throw new ReferentIncompatibleException("Les données du référents ne correspondent pas");
		}


		/// <summary>
		/// Vérifier que le référent existe et qu'il est toujours présent chez Apside
		/// </summary>
		/// <param name="referent">Le référent a validé</param>
		private void CheckReferentValide(Collaborateur referent)
		{
			//Vérifier que le référent existe
			if (referent == null)
				throw new ReferentNotFoundException("Le référent n'a pas été trouvé");

			//Vérifier que le référent est toujours présent dans l'entreprise
			if (referent.DateDepart.HasValue)
				throw new CollaborateurPartiException("Le référent récupéré ne travail plus pour l'entreprise");
		}

		/// <summary>
		/// Vérfier que l'id du collaborateur en paramtère ete l'id du collaborateur dans la liste des ids sont les même
		/// </summary>
		/// <param name="idCollaborateur">L'id du collaborateur</param>
		/// <param name="body">objet contenat l'id du collaborateur</param>
		private void CheckCollaborateurId(Guid? idCollaborateur, ReferentEPDTO body) {
			if (!body.IdsCollaborateur[0].HasValue || !idCollaborateur.Value.Equals(body.IdsCollaborateur[0].Value))
			{
				throw new CollaborateurIncompatibleException("Les ids du collaborateur ne correspondent pas ou sont nulls");
			}
		}
		
		/// <summary>
		/// Vérifier que le collaborateur existe est qu'il est toujours présent chez Apside
		/// </summary>
		/// <param name="collaborateur">Le collaborateur a validé</param>
		private void CheckCollaborateurValide(Collaborateur collaborateur) 
		{
			//Aucune valeur nulle n'a été retrouvée
			if (collaborateur == null)
				throw new CollaborateurNotFoundException("Un collaborateur n'a pas été retrouvé");
			//Le collaborateur est toujours présent dans l'entreprise
			if (collaborateur.DateDepart.HasValue)
				throw new CollaborateurPartiException("Un collaborateur récupéré ne travaille plus pour l'entreprise");
		}

		
		private void CheckListesCollaborateurs(IEnumerable<Collaborateur> collaborateurs) 
		{
			foreach(Collaborateur c in collaborateurs) {
				//Aucune valeur nulle n'a été retrouvée
				CheckCollaborateurValide(c);
			}
		}
		
		private void CheckListesIdsCollaborateurs(IEnumerable<Guid?> idsCollaborateurs)
		{
			if (idsCollaborateurs == null || idsCollaborateurs.Count() == 0)
				throw new ListeIdsCollaborateursVideException("La liste des collaborateurs ne peut pas être vide");
		}

		#endregion

		#region Methodes privees Async
		private async void SetReferentEPAsync(IEnumerable<Guid?> idsCollaborateur, Guid? idReferent)
		{
			//Garder le lien entre l'anciens référent et le collaborateur pour notifier les anciens référents qu'ils ne sont plus référents
			Dictionary<Guid?, Guid?> anciensReferentCollaborateurs = new Dictionary<Guid?, Guid?>();

			//La liste des nouveaux collaborateurs du référents qui devront être notifiés de leur nouveau référent
			List<Guid?> nouveauxCollaborateurs = new List<Guid?>();

			foreach (Guid? idCollaborateur in idsCollaborateur)
			{
				ReferentEP referentEP = await context.ReferentEP.FindAsync(idCollaborateur);

				//Le collaborateur n'a jamais eu de référent donc on lui crée un référentEP et il en sera simplement notifié
				if (referentEP == null)
				{
					referentEP = new ReferentEP
					{
						IdReferent = idReferent,
						IdCollaborateur = idCollaborateur.Value
					};
					await context.ReferentEP.AddAsync(referentEP);
					//context.SaveChanges();
					//nouveauxCollaborateurs.Add(idCollaborateur);
				}
				else
				{
					//Si le collaborateur a actuellement un référent
					if (referentEP.IdReferent != null && referentEP.IdReferent.HasValue)
					{
						//Si le nouveau référent est déjà le référent actuel du collaborateur, il n'y a rien à faire
						if (referentEP.IdReferent.Value.Equals(referentEP.IdReferent.Value))
							continue;

						//Sauvegarder l'ancien référent et le collaborateur suite au changement
						anciensReferentCollaborateurs.Add(idCollaborateur, idReferent);
					}
					referentEP.IdReferent = idReferent;
					//context.SaveChanges();
					//nouveauxCollaborateurs.Add(idCollaborateur);
				}

				await context.SaveChangesAsync();
				nouveauxCollaborateurs.Add(idCollaborateur);
			}

		}
		#endregion
	}
}