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

namespace EPAServeur.Services
{
    public class EngagementService : IEngagementService
    {
        #region Variables

        private readonly EpContext epContext;
        private readonly ICollaborateurService collaborateurService;
        private readonly IReferentEPService referentService;
        #endregion

        #region Contructeurs

        /// <summary>
        /// Constructeur de la classe EngagementService
        /// </summary>
        /// <param name="_epContext"></param>
        public EngagementService(EpContext _epContext, ICollaborateurService _collaborateurService, IReferentEPService _referentService)
        {
            epContext = _epContext;
            collaborateurService = _collaborateurService;
            referentService = _referentService;
        }

        #endregion

        #region Méthodes Service

        public IEnumerable<EngagementDTO> GetEngagements(bool? asc, int? numPage, int? parPAge, string texte, string tri)
        {
            IEnumerable<Engagement> engagements;

            if (texte == null)
                texte = "";
            else
                texte = texte.ToLower();

            int skip = (numPage.Value - 1) * parPAge.Value;
            int take = parPAge.Value;

            engagements = epContext.Engagement.Include(engagement => engagement.Ep).Skip(skip).Take(take);

            if (engagements == null || engagements.Count() == 0)
                return new List<EngagementDTO>();

            var engagementDTOs = engagements.Where(engagement => engagement.Modalite.ToLower().Contains(texte)).Select(engagement => GetEngagementDTO(engagement));

            return engagementDTOs;
        }

        public async Task<IEnumerable<EngagementDTO>> GetEngagementsAsync(bool? asc, int? numPage, int? parPAge, string texte, string tri)
        {
            IEnumerable<Engagement> engagements;

            if (texte == null)
                texte = "";
            else
                texte = texte.ToLower();

            int skip = (numPage.Value - 1) * parPAge.Value;
            int take = parPAge.Value;

            engagements = await epContext.Engagement.Include(engagement => engagement.Ep).Skip(skip).Take(take).ToListAsync();

            if (engagements == null || engagements.Count() == 0)
                return new List<EngagementDTO>();

            var engagementDTOs = engagements.Where(engagement => engagement.Modalite.ToLower().Contains(texte)).Select(engagement => GetEngagementDTOAsync(engagement));
            var results = await Task.WhenAll(engagementDTOs);

            return results;
        }

        public IEnumerable<EngagementDTO> GetEngagementsEnAttente(bool? asc, int? numPage, int? parPAge, string texte, string tri)
        {
            IEnumerable<Engagement> engagements;

            if (texte == null)
                texte = "";
            else
                texte = texte.ToLower();

            int skip = (numPage.Value - 1) * parPAge.Value;
            int take = parPAge.Value;

            engagements = epContext.Engagement.Include(engagement => engagement.Ep).Where(engagement => engagement.EtatEngagement == EtatEngagement.EnAttente).Skip(skip).Take(take).ToList();

            if (engagements == null || engagements.Count() == 0)
                return new List<EngagementDTO>();

            var engagementDTOs = engagements.Where(engagement => engagement.Modalite.ToLower().Contains(texte)).Select(engagement => GetEngagementDTO(engagement));

            return engagementDTOs;
        }

        public async Task<IEnumerable<EngagementDTO>> GetEngagementsEnAttenteAsync(bool? asc, int? numPage, int? parPAge, string texte, string tri)
        {
            IEnumerable<Engagement> engagements;

            if (texte == null)
                texte = "";
            else
                texte = texte.ToLower();

            int skip = (numPage.Value - 1) * parPAge.Value;
            int take = parPAge.Value;

            engagements = await epContext.Engagement.Include(engagement => engagement.Ep).Where(engagement => engagement.EtatEngagement == EtatEngagement.EnAttente).Skip(skip).Take(take).ToListAsync();

            if (engagements == null || engagements.Count() == 0)
                return new List<EngagementDTO>();

            var engagementDTOs = engagements.Where(engagement => engagement.Modalite.ToLower().Contains(texte)).Select(engagement => GetEngagementDTOAsync(engagement));
            var results = await Task.WhenAll(engagementDTOs);

            return results;
        }

        public IEnumerable<EngagementDTO> GetEngagementsRepondus(bool? asc, int? numPage, int? parPAge, string texte, string tri)
        {
            IEnumerable<Engagement> engagements;

            if (texte == null)
                texte = "";
            else
                texte = texte.ToLower();

            int skip = (numPage.Value - 1) * parPAge.Value;
            int take = parPAge.Value;

            engagements = epContext.Engagement.Include(engagement => engagement.Ep).Where(engagement => engagement.EtatEngagement == EtatEngagement.Respecte && engagement.Modalite.ToLower().Contains(texte)).Skip(skip).Take(take);

            if (engagements == null || engagements.Count() == 0)
                return new List<EngagementDTO>();

            var engagementDTOs = engagements.Where(engagement => engagement.Modalite.ToLower().Contains(texte)).Select(engagement => GetEngagementDTO(engagement));

            return engagementDTOs;
        }

        public async Task<IEnumerable<EngagementDTO>> GetEngagementsRepondusAsync(bool? asc, int? numPage, int? parPAge, string texte, string tri)
        {
            IEnumerable<Engagement> engagements;

            if (texte == null)
                texte = "";
            else
                texte = texte.ToLower();

            int skip = (numPage.Value - 1) * parPAge.Value;
            int take = parPAge.Value;

            engagements = await epContext.Engagement.Include(engagement => engagement.Ep).Where(engagement => engagement.EtatEngagement == EtatEngagement.Respecte && engagement.Modalite.ToLower().Contains(texte)).Skip(skip).Take(take).ToListAsync();

            if (engagements == null || engagements.Count() == 0)
                return new List<EngagementDTO>();

            var engagementDTOs = engagements.Where(engagement => engagement.Modalite.ToLower().Contains(texte)).Select(engagement => GetEngagementDTOAsync(engagement));
            var results = await Task.WhenAll(engagementDTOs);

            return results;
        }

        /// <summary>
        /// Donner une réponse à un engagement
        /// </summary>
        /// <param name="engagementDTO"></param>
        /// <param name="idEngagement"></param>
        /// <returns></returns>
        public EngagementDTO RepondreEngagement(EngagementDTO engagementDTO, long? idEngagement)
        {

            if (!IsEngagementValide(engagementDTO))
                throw new EngagementInvalidException("Impossible de répondre à l'engagement, des données sont manquants.");

            if (engagementDTO.EtatEngagement == EtatEngagement.NonRealisable && string.IsNullOrWhiteSpace(engagementDTO.RaisonNonRealisable))
                throw new EngagementInvalidException("Impossible de répondre à l'engagement, une raison doit être rensignée lorsqu'un engagement n'est pas réalisé.");

            if (engagementDTO == null && !engagementDTO.Id.HasValue && engagementDTO.Id.Value != idEngagement)
                throw new EngagementIncompatibleIdException();


            Engagement engagement = epContext.Engagement.Include(engagement => engagement.Ep).FirstOrDefault(engagement => engagement.IdEngagement == idEngagement);

            if (engagement == null)
                throw new EngagementNotFoundException();

            engagement.EtatEngagement = engagementDTO.EtatEngagement;

            switch (engagement.EtatEngagement)
            {
                case EtatEngagement.Respecte:
                    engagement.EtatEngagement = engagementDTO.EtatEngagement;                    
                    engagement.RaisonNonRealisable = null;
                    break;
                case EtatEngagement.NonRealisable:
                    engagement.EtatEngagement = engagementDTO.EtatEngagement;
                    engagement.RaisonNonRealisable = engagementDTO.RaisonNonRealisable;
                    break;
                default:
                    engagement.EtatEngagement = engagementDTO.EtatEngagement;
                    engagement.RaisonNonRealisable = null;
                    break;
            }

            epContext.SaveChanges();

            return GetEngagementDTO(engagement);
        }


        /// <summary>
        /// Donner une réponse à un engagement de manière asynchrone
        /// </summary>
        /// <param name="engagementDTO"></param>
        /// <param name="idEngagement"></param>
        /// <returns></returns>
        public async Task<EngagementDTO> RepondreEngagementAsync(EngagementDTO engagementDTO, long? idEngagement)
        {

            if (!IsEngagementValide(engagementDTO))
                throw new EngagementInvalidException("Impossible de répondre à l'engagement, des données sont manquants.");

            if (engagementDTO.EtatEngagement == EtatEngagement.NonRealisable && string.IsNullOrWhiteSpace(engagementDTO.RaisonNonRealisable))
                throw new EngagementInvalidException("Impossible de répondre à l'engagement, une raison doit être rensignée lorsqu'un engagement n'est pas réalisé.");


            Engagement engagement = await epContext.Engagement.Include(engagement => engagement.Ep).FirstOrDefaultAsync(engagement => engagement.IdEngagement == idEngagement);

            if (engagement == null)
                throw new EngagementNotFoundException();

            engagement.EtatEngagement = engagementDTO.EtatEngagement;

            switch (engagement.EtatEngagement)
            {
                case EtatEngagement.Respecte:
                    engagement.EtatEngagement = engagementDTO.EtatEngagement;
                    engagement.RaisonNonRealisable = null;
                    break;
                case EtatEngagement.NonRealisable:
                    engagement.EtatEngagement = engagementDTO.EtatEngagement;
                    engagement.RaisonNonRealisable = engagementDTO.RaisonNonRealisable;
                    break;
                default:
                    engagement.EtatEngagement = engagementDTO.EtatEngagement;
                    engagement.RaisonNonRealisable = null;
                    break;
            }
            await epContext.SaveChangesAsync();

            return await GetEngagementDTOAsync(engagement);
        }


        #endregion

        #region Méthodes Privée
        private bool IsEngagementValide(EngagementDTO engagementDTO)
        {
                return !(engagementDTO == null || engagementDTO.Id == null || engagementDTO.Action == null || engagementDTO.DateLimite == null || engagementDTO.Dispositif == null || engagementDTO.Modalite == null);
        }

        #region Object to DTO

        /// <summary>
        /// Récupère un objet EngagementDTO en fonction d'un objet Engagement
        /// </summary>
        /// <param name="engagement"></param>
        /// <returns></returns>
        private EngagementDTO GetEngagementDTO(Engagement engagement)
        {
            EngagementDTO engagementDTO = new EngagementDTO()
            {
                Id = engagement.IdEngagement,
                Action = engagement.Action,
                DateLimite = engagement.DateLimite,
                Dispositif = engagement.Dispositif,
                Modalite = engagement.Modalite,
                RaisonNonRealisable = engagement.RaisonNonRealisable,
                EtatEngagement = engagement.EtatEngagement,
                Ep = GetEpInformationDTO(engagement.Ep)
            };

            return engagementDTO;
        }

        /// <summary>
        /// Récupère un objet EngagementDTO en fonction d'un objet Engagement
        /// </summary>
        /// <param name="engagement"></param>
        /// <returns></returns>
        private async Task<EngagementDTO> GetEngagementDTOAsync(Engagement engagement)
        {
            EngagementDTO engagementDTO = new EngagementDTO()
            {
                Id = engagement.IdEngagement,
                Action = engagement.Action,
                DateLimite = engagement.DateLimite,
                Dispositif = engagement.Dispositif,
                Modalite = engagement.Modalite,
                RaisonNonRealisable = engagement.RaisonNonRealisable,
                EtatEngagement = engagement.EtatEngagement,
                Ep = await GetEpInformationDTOAsync(engagement.Ep)
            };

            return engagementDTO;
        }

        /// <summary>
        /// Récupère un objet EpInformationDTO en fonction d'un objet Ep
        /// </summary>
        /// <param name="ep"></param>
        /// <returns></returns>
        private EpInformationDTO GetEpInformationDTO(Ep ep)
        {
            EpInformationDTO epInformationDTO = new EpInformationDTO()
            {
                Id = ep.IdEP,
                Type = ep.TypeEP,
                Statut = ep.Statut,
                DatePrevisionnelle = ep.DatePrevisionnelle,
                Obligatoire = ep.Obligatoire,
                //Collaborateur = collaborateurService.GetCollaborateurById(ep.IdCollaborateur),
                //Referent = referentService.GetReferentById(ep.IdReferent)
                //Ajouter la date de disponibilité
            };

            return epInformationDTO;
        }

        /// <summary>
        /// Récupère un objet EpInformationDTO en fonction d'un objet Ep
        /// </summary>
        /// <param name="ep"></param>
        /// <returns></returns>
        private async Task<EpInformationDTO> GetEpInformationDTOAsync(Ep ep)
        {
            EpInformationDTO epInformationDTO = new EpInformationDTO()
            {
                Id = ep.IdEP,
                Type = ep.TypeEP,
                Statut = ep.Statut,
                DatePrevisionnelle = ep.DatePrevisionnelle,
                Obligatoire = ep.Obligatoire
                //Ajouter la date de disponibilité
            };
            var collaborateur = collaborateurService.GetCollaborateurByIdAsync(ep.IdCollaborateur);
            var referent = collaborateurService.GetCollaborateurByIdAsync(ep.IdReferent);

            await Task.WhenAll(collaborateur, referent);

            epInformationDTO.Collaborateur = collaborateur.Result;
            epInformationDTO.Referent = referent.Result;


            return epInformationDTO;
        }

        #endregion

        #region DTO to Object

        /// <summary>
        /// Modifie un objet Engagement en fonction d'un objet FormationDTO
        /// </summary>
        /// <param name="engagement"></param>
        /// <param name="engagementDTO"></param>
        /// <returns></returns>
        private Engagement SetEngagement(Engagement engagement, EngagementDTO engagementDTO)
        {
            engagement.Action = engagementDTO.Action;
            engagement.DateLimite = engagementDTO.DateLimite.Value;
            engagement.Dispositif = engagementDTO.Dispositif;
            engagement.Modalite = engagementDTO.Modalite;
            engagement.RaisonNonRealisable = engagementDTO.RaisonNonRealisable;
            engagement.EtatEngagement = engagementDTO.EtatEngagement;
            engagement.Ep = GetEp(engagementDTO.Ep);


            return engagement;
        }

        /// <summary>
        /// Récupère un objet Ep en fonction d'un objet EpDTO
        /// </summary>
        /// <param name="origineFormationDTO"></param>
        /// <returns></returns>
        private Ep GetEp(EpInformationDTO epInformationDTO)
        {
            if (epInformationDTO == null)
                return null;

            Ep ep = new Ep()
            {
                IdEP = epInformationDTO.Id.Value,
                TypeEP = epInformationDTO.Type,
                Statut = epInformationDTO.Statut,
                DatePrevisionnelle = epInformationDTO.DatePrevisionnelle.Value,
                Obligatoire = epInformationDTO.Obligatoire.Value,
                IdReferent = epInformationDTO.Referent.Id.Value,
                IdCollaborateur = epInformationDTO.Collaborateur.Id.Value,
                // Ajouter la date de disponibilité
            };

            return ep;
        }


        #endregion

        #endregion

    }
}