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

namespace EPAServeur.Services
{
	public class DemandeDelegationService : IDemandeDelegationService
	{
		#region variables
		private readonly EpContext context;
		private readonly ICollaborateurService collaborateurService;

		#endregion

		#region constructeur
		public DemandeDelegationService(ICollaborateurService _collaborateurService, EpContext _context)
		{
			context = _context;
			collaborateurService = _collaborateurService;
		}
		#endregion


		#region services async
		public async Task<IEnumerable<DemandeDelegationDTO>> RecupererDemandesDelegation(Guid? idReferent)
		{
			IEnumerable<DemandeDelegation> demandesDelegation = context.DemandeDelegation.Include(d => d.Ep).Where(d => d.IdReferent.Equals(idReferent) && d.EtatDemande.Equals(EtatDemande.EnAttente));

			List<Guid?> guids = demandesDelegation.SelectMany(demande => new[] { (Guid?)demande.Ep.IdCollaborateur, demande.Ep.IdReferent }).ToList();
			guids.Add(idReferent);
			IEnumerable<CollaborateurDTO> collaborateursDTO = await collaborateurService.GetCollaborateurDTOsAsync(guids);

			CollaborateurDTO referent = collaborateursDTO.FirstOrDefault(c => c.Id.Equals(idReferent));
			if(referent == null)
			{
				throw new ReferentNotFoundException();
			}

			return demandesDelegation.Select(d => GetDemandeDelegationDTO(d, referent, collaborateursDTO));
			
		}

		public async Task<DemandeDelegationDTO> UpdateDemandeDelegation(long? id, DemandeDelegationDTO demandeDelegationDTO)
		{
			if (id != demandeDelegationDTO.Id)
				throw new DemandeDelegationIncompatibleException("La demande de délégation ne correspond pas avec l'identifiant reçu");
			if (demandeDelegationDTO == null || !demandeDelegationDTO.Id.HasValue || demandeDelegationDTO.Id == null)
				throw new DemandeDelegationInvalidException("Aucune demande de délégation à mettre à jour n'a été reçu");

			switch(demandeDelegationDTO.EtatDemande)
			{
				case EtatDemande.EnAttente:
					throw new DemandeDelegationInvalidException("La demande ne peut pas être mise à jour si aucune réponse n'a été donnée");
				case EtatDemande.Validee:
					demandeDelegationDTO = await AccepterDemandeDelegation(demandeDelegationDTO);
					break;
				case EtatDemande.Rejetee:
					demandeDelegationDTO = await RejeterDemandeDelegation(demandeDelegationDTO);
					break;
			}
			return demandeDelegationDTO;
		}
		#endregion

		#region méthodes privées
		private async Task<DemandeDelegationDTO> AccepterDemandeDelegation(DemandeDelegationDTO demandeDelegationDTO)
		{

			DemandeDelegation demandeDelegation = await context.DemandeDelegation.Where(d => d.IdDemandeDelegation.Equals(demandeDelegationDTO.Id.Value)).Include(d => d.Ep).FirstOrDefaultAsync();
			if (demandeDelegation == null)
				throw new DemandeDelegationNotFoundException("Aucune demande de délégation n'a été trouvée");
			Guid ancienReferent = demandeDelegation.Ep.IdReferent.Value; // devra être utilisé pour notifier l'ancien référent
			demandeDelegation.Ep.IdReferent = demandeDelegationDTO.Referent.Id;
			context.Remove(demandeDelegation);
			await context.SaveChangesAsync();
			
			return null;
		}

		private async Task<DemandeDelegationDTO> RejeterDemandeDelegation(DemandeDelegationDTO demandeDelegationDTO)
		{
			if (demandeDelegationDTO.RaisonRefus == null || demandeDelegationDTO.RaisonRefus == "")
				throw new DemandeDelegationInvalidException("Vous devez justifiez la raison du refus");
			
			DemandeDelegation demandeDelegation = await context.DemandeDelegation.FindAsync(demandeDelegationDTO.Id);
			if (demandeDelegation == null)
				throw new DemandeDelegationNotFoundException("Aucune demande de délégation n'a été trouvée");
			demandeDelegation.EtatDemande = demandeDelegationDTO.EtatDemande;
			demandeDelegation.RaisonRefus= demandeDelegationDTO.RaisonRefus;
			demandeDelegation.DateReponse = DateTime.Now;
			await context.SaveChangesAsync();
			return demandeDelegationDTO;
		}


		private EpInformationDTO GetEpInformationDTO(Ep ep, IEnumerable<CollaborateurDTO> collaborateurs)
		{
			return new EpInformationDTO()
			{
				Id = ep.IdEP,
				Collaborateur = collaborateurs.FirstOrDefault(c => c.Id.Equals(ep.IdCollaborateur)),
				Referent = collaborateurs.FirstOrDefault(c => c.Id.Equals(ep.IdReferent)),
				DatePrevisionnelle = ep.DatePrevisionnelle,
				DateDisponibilite = ep.DateDisponibilite,
				Statut = ep.Statut,
				Type = ep.TypeEP,
				Obligatoire = ep.Obligatoire,
			};
		}

		private DemandeDelegationDTO GetDemandeDelegationDTO(DemandeDelegation demande, CollaborateurDTO referent, IEnumerable<CollaborateurDTO> collaborateurs)
		{
			return new DemandeDelegationDTO()
			{
				Id = demande.IdDemandeDelegation,
				DateDemande = demande.DateDemande,
				EtatDemande = demande.EtatDemande,
				Referent = referent,
				RaisonDemande = demande.RaisonDemande,
				Ep = GetEpInformationDTO(demande.Ep, collaborateurs)
			};
			
		}

		#endregion


	}
}