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

namespace EPAServeur.Services
{
    public class FormationService : IFormationService
    {
        #region Variables

        private readonly EpContext epContext;

        #endregion

        #region Contructeurs

        /// <summary>
        /// Constructeur de la classe FormationService
        /// </summary>
        /// <param name="_epContext"></param>
        public FormationService(EpContext _epContext)
        {
            epContext = _epContext;
        }

        #endregion

        #region Méthodes Service

        /// <summary>
        /// Récupérer une formation par son id
        /// </summary>
        /// <param name="idFormation"></param>
        /// <returns></returns>
        public FormationDTO GetFormationById(long? idFormation)
        {
            Formation formation = epContext.Formation.Include(formation => formation.Statut)
                                                     .Include(formation => formation.ModeFormation)
                                                     .Include(formation => formation.Origine)
                                                     .Include(formation => formation.TypeFormation)
                                                     .FirstOrDefault(formation => formation.IdFormation == idFormation);

            if (formation == null)
                throw new FormationNotFoundException();

            return GetFormationDTO(formation);
        }

        /// <summary>
        /// Récupérer une formation par son id de manière asynchrone
        /// </summary>
        /// <param name="idFormation"></param>
        /// <returns></returns>
        public async Task<FormationDTO> GetFormationByIdAsync(long? idFormation)
        {
            Formation formation = await epContext.Formation.Include(formation => formation.Statut)
                                                     .Include(formation => formation.ModeFormation)
                                                     .Include(formation => formation.Origine)
                                                     .Include(formation => formation.TypeFormation)
                                                     .FirstOrDefaultAsync(formation => formation.IdFormation == idFormation);

            if (formation == null)
                throw new FormationNotFoundException();

            return GetFormationDTO(formation);
        }

        /// <summary>
        /// Récupérer la liste des formations
        /// </summary>
        /// <param name="asc">Préciser si les données sont dans l&#x27;ordre (true) ou dans l&#x27;ordre inverse (false)</param>
        /// <param name="numPage">Numéro de la page du tableau qui affiche les données</param>
        /// <param name="parPAge">Nombre d&#x27;éléments affiché sur chaque page du tableau</param>
        /// <param name="idAgence">id de l&#x27;agence à laquelle sont rattachées les données à récupérer</param>
        /// <param name="texte">Texte permettant d&#x27;identifier l&#x27;objet rechercher</param>
        /// <param name="tri">Colonne du tableau sur lequel le tri s&#x27;effectue</param>
        /// <returns></returns>
        public IEnumerable<FormationDTO> GetFormations(bool? asc, int? numPage, int? parPAge, long? idAgence, int? statutFormation, string texte, string tri)
        {
            IEnumerable<Formation> formations;
            IEnumerable<FormationDTO> formationDTOs;

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

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

            if (statutFormation != null && idAgence != null)
            {
                formations = epContext.Formation
                                    .Include(formation => formation.Statut)
                                    .Include(formation => formation.ModeFormation)
                                    .Include(formation => formation.Origine)
                                    .Include(formation => formation.TypeFormation)
                                    .Where(formation => formation.Statut.IdStatutFormation == statutFormation && formation.IdAgence == idAgence).Skip(skip).Take(take);
            }
            else if (statutFormation != null && idAgence == null)
            {
                formations = epContext.Formation
                     .Include(formation => formation.Statut)
                     .Include(formation => formation.ModeFormation)
                     .Include(formation => formation.Origine)
                     .Include(formation => formation.TypeFormation)
                     .Where(formation => formation.Statut.IdStatutFormation == statutFormation).Skip(skip).Take(take);
            }
            else if (idAgence != null)
            {
                formations = epContext.Formation.Where(formation => formation.IdAgence == idAgence)
                                       .Include(formation => formation.Statut)
                                       .Include(formation => formation.ModeFormation)
                                       .Include(formation => formation.Origine)
                                       .Include(formation => formation.TypeFormation).Skip(skip).Take(take);
            }
            else
            {
                formations = epContext.Formation.Include(formation => formation.Statut)
                                           .Include(formation => formation.ModeFormation)
                                           .Include(formation => formation.Origine)
                                           .Include(formation => formation.TypeFormation).Skip(skip).Take(take);
            }

            formationDTOs = formations.Where(formation => formation.Intitule.ToLower().Contains(texte)).Select(formation => GetFormationDTO(formation));

            return formationDTOs;
        }

        /// <summary>
        /// Récupérer la liste des formations de manière asynchrone
        /// </summary>
        /// <param name="asc">Préciser si les données sont dans l&#x27;ordre (true) ou dans l&#x27;ordre inverse (false)</param>
        /// <param name="numPage">Numéro de la page du tableau qui affiche les données</param>
        /// <param name="parPAge">Nombre d&#x27;éléments affiché sur chaque page du tableau</param>
        /// <param name="idAgence">id de l&#x27;agence à laquelle sont rattachées les données à récupérer</param>
        /// <param name="texte">Texte permettant d&#x27;identifier l&#x27;objet rechercher</param>
        /// <param name="tri">Colonne du tableau sur lequel le tri s&#x27;effectue</param>
        /// <returns></returns>
        public async Task<IEnumerable<FormationDTO>> GetFormationsAsync(bool? asc, int? numPage, int? parPAge, long? idAgence, int? statutFormation, string texte, string tri)
        {
            IEnumerable<Formation> formations;
            IEnumerable<FormationDTO> formationDTOs;

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

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

            if (statutFormation != null && idAgence != null)
            {
                formations = await epContext.Formation
                                          .Include(formation => formation.Statut)
                                          .Include(formation => formation.ModeFormation)
                                          .Include(formation => formation.Origine)
                                          .Include(formation => formation.TypeFormation)
                                          .Where(formation => formation.Statut.IdStatutFormation == statutFormation && formation.IdAgence == idAgence).Skip(skip).Take(take).ToListAsync();
            }
            else if (statutFormation != null && idAgence == null)
            {
                formations = await epContext.Formation
                          .Include(formation => formation.Statut)
                          .Include(formation => formation.ModeFormation)
                          .Include(formation => formation.Origine)
                          .Include(formation => formation.TypeFormation)
                          .Where(formation => formation.Statut.IdStatutFormation == statutFormation).Skip(skip).Take(take).ToListAsync();
            }
            else if (idAgence != null)
            {

                formations = await epContext.Formation
                                       .Include(formation => formation.Statut)
                                       .Include(formation => formation.ModeFormation)
                                       .Include(formation => formation.Origine)
                                       .Include(formation => formation.TypeFormation).Where(formation => formation.IdAgence == idAgence).Skip(skip).Take(take).ToListAsync();

            }
            else
            {

                formations = await epContext.Formation.Include(formation => formation.Statut)
                                           .Include(formation => formation.ModeFormation)
                                           .Include(formation => formation.Origine)
                                           .Include(formation => formation.TypeFormation).Skip(skip).Take(take).ToListAsync();

            }

            formationDTOs = formations.Where(formation => formation.Intitule.ToLower().Contains(texte)).Select(formation => GetFormationDTO(formation));

            return formationDTOs;
        }

        /// <summary>
        /// Récupérer les formations annulées
        /// </summary>
        /// <param name="asc">Préciser si les données sont dans l&#x27;ordre (true) ou dans l&#x27;ordre inverse (false)</param>
        /// <param name="numPage">Numéro de la page du tableau qui affiche les données</param>
        /// <param name="parPAge">Nombre d&#x27;éléments affiché sur chaque page du tableau</param>
        /// <param name="idAgence">id de l&#x27;agence à laquelle sont rattachées les données à récupérer</param>
        /// <param name="texte">Texte permettant d&#x27;identifier l&#x27;objet rechercher</param>
        /// <param name="tri">Colonne du tableau sur lequel le tri s&#x27;effectue</param>
        /// <returns></returns>
        public IEnumerable<FormationDTO> GetFormationAnnulees(bool? asc, int? numPage, int? parPAge, long? idAgence, string texte, string tri)
        {
            IEnumerable<Formation> formations;
            IEnumerable<FormationDTO> formationDTOs;

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

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

            if (idAgence != null)
                formations = epContext.Formation.Where(formation => formation.IdAgence == idAgence && formation.Statut.IdStatutFormation == 4)
                                                .Include(formation => formation.Statut)
                                                .Include(formation => formation.ModeFormation)
                                                .Include(formation => formation.Origine)
                                                .Include(formation => formation.TypeFormation).Skip(skip).Take(take);
            else
                formations = epContext.Formation.Where(formation => formation.Statut.IdStatutFormation == 4)
                                                .Include(formation => formation.Statut)
                                                .Include(formation => formation.ModeFormation)
                                                .Include(formation => formation.Origine)
                                                .Include(formation => formation.TypeFormation).Skip(skip).Take(take);

            formationDTOs = formations.Where(formation => formation.Intitule.ToLower().Contains(texte)).Select(formation => GetFormationDTO(formation));

            return formationDTOs;
        }

        /// <summary>
        /// Récupérer les formations annulées de manière asynchrone
        /// </summary>
        /// <param name="asc">Préciser si les données sont dans l&#x27;ordre (true) ou dans l&#x27;ordre inverse (false)</param>
        /// <param name="numPage">Numéro de la page du tableau qui affiche les données</param>
        /// <param name="parPAge">Nombre d&#x27;éléments affiché sur chaque page du tableau</param>
        /// <param name="idAgence">id de l&#x27;agence à laquelle sont rattachées les données à récupérer</param>
        /// <param name="texte">Texte permettant d&#x27;identifier l&#x27;objet rechercher</param>
        /// <param name="tri">Colonne du tableau sur lequel le tri s&#x27;effectue</param>
        /// <returns></returns>
        public async Task<IEnumerable<FormationDTO>> GetFormationAnnuleesAsync(bool? asc, int? numPage, int? parPAge, long? idAgence, string texte, string tri)
        {
            IEnumerable<Formation> formations;
            IEnumerable<FormationDTO> formationDTOs;

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

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

            if (idAgence != null)
                formations = await epContext.Formation.Where(formation => formation.IdAgence == idAgence && formation.Statut.IdStatutFormation == 4)
                                                .Include(formation => formation.Statut)
                                                .Include(formation => formation.ModeFormation)
                                                .Include(formation => formation.Origine)
                                                .Include(formation => formation.TypeFormation).Skip(skip).Take(take).ToListAsync();
            else
                formations = await epContext.Formation.Where(formation => formation.Statut.IdStatutFormation == 4)
                                                .Include(formation => formation.Statut)
                                                .Include(formation => formation.ModeFormation)
                                                .Include(formation => formation.Origine)
                                                .Include(formation => formation.TypeFormation).Skip(skip).Take(take).ToListAsync();

            formationDTOs = formations.Where(formation => formation.Intitule.ToLower().Contains(texte)).Select(formation => GetFormationDTO(formation));

            return formationDTOs;
        }

        /// <summary>
        /// Récupérer les formations réalisées
        /// </summary>
        /// <param name="asc">Préciser si les données sont dans l&#x27;ordre (true) ou dans l&#x27;ordre inverse (false)</param>
        /// <param name="numPage">Numéro de la page du tableau qui affiche les données</param>
        /// <param name="parPAge">Nombre d&#x27;éléments affiché sur chaque page du tableau</param>
        /// <param name="idAgence">id de l&#x27;agence à laquelle sont rattachées les données à récupérer</param>
        /// <param name="texte">Texte permettant d&#x27;identifier l&#x27;objet rechercher</param>
        /// <param name="tri">Colonne du tableau sur lequel le tri s&#x27;effectue</param>
        /// <returns></returns>
        public IEnumerable<FormationDTO> GetFormationRealisees(bool? asc, int? numPage, int? parPAge, long? idAgence, string texte, string tri)
        {
            IEnumerable<Formation> formations;
            IEnumerable<FormationDTO> formationDTOs;

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

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

            if (idAgence != null)
            {

                formations = epContext.Formation.Where(formation => formation.IdAgence == idAgence && formation.Statut.IdStatutFormation == 3)
                                                               .Include(formation => formation.Statut)
                                                               .Include(formation => formation.ModeFormation)
                                                               .Include(formation => formation.Origine)
                                                               .Include(formation => formation.TypeFormation).Skip(skip).Take(take);
            }

            else
            {

                formations = epContext.Formation.Where(formation => formation.Statut.IdStatutFormation == 3)
                                                            .Include(formation => formation.Statut)
                                                            .Include(formation => formation.ModeFormation)
                                                            .Include(formation => formation.Origine)
                                                            .Include(formation => formation.TypeFormation).Skip(skip).Take(take);

            }

            formationDTOs = formations.Where(formation => formation.Intitule.ToLower().Contains(texte)).Select(formation => GetFormationDTO(formation));

            return formationDTOs;
        }

        /// <summary>
        /// Récupérer les formations réalisées de manière asynchrone
        /// </summary>
        /// <param name="asc">Préciser si les données sont dans l&#x27;ordre (true) ou dans l&#x27;ordre inverse (false)</param>
        /// <param name="numPage">Numéro de la page du tableau qui affiche les données</param>
        /// <param name="parPAge">Nombre d&#x27;éléments affiché sur chaque page du tableau</param>
        /// <param name="idAgence">id de l&#x27;agence à laquelle sont rattachées les données à récupérer</param>
        /// <param name="texte">Texte permettant d&#x27;identifier l&#x27;objet rechercher</param>
        /// <param name="tri">Colonne du tableau sur lequel le tri s&#x27;effectue</param>
        /// <returns></returns>
        public async Task<IEnumerable<FormationDTO>> GetFormationRealiseesAsync(bool? asc, int? numPage, int? parPAge, long? idAgence, string texte, string tri)
        {
            IEnumerable<Formation> formations;
            IEnumerable<FormationDTO> formationDTOs;

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

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

            if (idAgence != null)
            {

                formations = await epContext.Formation.Where(formation => formation.IdAgence == idAgence && formation.Statut.IdStatutFormation == 3)
                                                               .Include(formation => formation.Statut)
                                                               .Include(formation => formation.ModeFormation)
                                                               .Include(formation => formation.Origine)
                                                               .Include(formation => formation.TypeFormation).Skip(skip).Take(take).ToListAsync();
            }

            else
            {

                formations = await epContext.Formation.Where(formation => formation.Statut.IdStatutFormation == 3)
                                                            .Include(formation => formation.Statut)
                                                            .Include(formation => formation.ModeFormation)
                                                            .Include(formation => formation.Origine)
                                                            .Include(formation => formation.TypeFormation).Skip(skip).Take(take).ToListAsync();
            }

            formationDTOs = formations.Where(formation => formation.Intitule.ToLower().Contains(texte)).Select(formation => GetFormationDTO(formation));

            return formationDTOs;
        }

        /// <summary>
        /// Récupérer les formations plannifiées et replannifiées
        /// </summary>
        /// <param name="asc">Préciser si les données sont dans l&#x27;ordre (true) ou dans l&#x27;ordre inverse (false)</param>
        /// <param name="numPage">Numéro de la page du tableau qui affiche les données</param>
        /// <param name="parPAge">Nombre d&#x27;éléments affiché sur chaque page du tableau</param>
        /// <param name="idAgence">id de l&#x27;agence à laquelle sont rattachées les données à récupérer</param>
        /// <param name="texte">Texte permettant d&#x27;identifier l&#x27;objet rechercher</param>
        /// <param name="tri">Colonne du tableau sur lequel le tri s&#x27;effectue</param>
        /// <returns></returns>
        public IEnumerable<FormationDTO> GetProchainesFormation(bool? asc, int? numPage, int? parPAge, long? idAgence, string texte, string tri)
        {
            IEnumerable<Formation> formations;
            IEnumerable<FormationDTO> formationDTOs;

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

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

            if (idAgence != null)
            {
                formations = epContext.Formation.Where(formation => formation.IdAgence == idAgence && (formation.Statut.IdStatutFormation == 1 || formation.Statut.IdStatutFormation == 2))
                                            .Include(formation => formation.Statut)
                                            .Include(formation => formation.ModeFormation)
                                            .Include(formation => formation.Origine)
                                            .Include(formation => formation.TypeFormation).Skip(skip).Take(take);

            }
            else
            {
                formations = epContext.Formation.Where(formation => (formation.Statut.IdStatutFormation == 1 || formation.Statut.IdStatutFormation == 2))
                                               .Include(formation => formation.Statut)
                                               .Include(formation => formation.ModeFormation)
                                               .Include(formation => formation.Origine)
                                               .Include(formation => formation.TypeFormation).Skip(skip).Take(take);
            }

            formationDTOs = formations.Where(formation => formation.Intitule.ToLower().Contains(texte)).Select(formation => GetFormationDTO(formation));

            return formationDTOs;
        }

        /// <summary>
        /// Récupérer les formations plannifiées et replannifiées de manère asynchrone
        /// </summary>
        /// <param name="asc">Préciser si les données sont dans l&#x27;ordre (true) ou dans l&#x27;ordre inverse (false)</param>
        /// <param name="numPage">Numéro de la page du tableau qui affiche les données</param>
        /// <param name="parPAge">Nombre d&#x27;éléments affiché sur chaque page du tableau</param>
        /// <param name="idAgence">id de l&#x27;agence à laquelle sont rattachées les données à récupérer</param>
        /// <param name="texte">Texte permettant d&#x27;identifier l&#x27;objet rechercher</param>
        /// <param name="tri">Colonne du tableau sur lequel le tri s&#x27;effectue</param>
        /// <returns></returns>
        public async Task<IEnumerable<FormationDTO>> GetProchainesFormationAsync(bool? asc, int? numPage, int? parPAge, long? idAgence, string texte, string tri)
        {
            IEnumerable<Formation> formations;
            IEnumerable<FormationDTO> formationDTOs;

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

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

            if (idAgence != null)
            {
                formations = await epContext.Formation.Where(formation => formation.IdAgence == idAgence && (formation.Statut.IdStatutFormation == 1 || formation.Statut.IdStatutFormation == 2))
                                            .Include(formation => formation.Statut)
                                            .Include(formation => formation.ModeFormation)
                                            .Include(formation => formation.Origine)
                                            .Include(formation => formation.TypeFormation).Skip(skip).Take(take).ToListAsync();

            }

            else
            {
                formations = await epContext.Formation.Where(formation => (formation.Statut.IdStatutFormation == 1 || formation.Statut.IdStatutFormation == 2))
                                               .Include(formation => formation.Statut)
                                               .Include(formation => formation.ModeFormation)
                                               .Include(formation => formation.Origine)
                                               .Include(formation => formation.TypeFormation).Skip(skip).Take(take).ToListAsync();
            }

            formationDTOs = formations.Where(formation => formation.Intitule.ToLower().Contains(texte)).Select(formation => GetFormationDTO(formation));

            return formationDTOs;
        }

        /// <summary>
        /// Récupérer les modes de formation
        /// </summary>
        /// <returns></returns>
        public IEnumerable<ModeFormationDTO> GetModesFormation()
        {
            IEnumerable<ModeFormation> modeFormations;
            IEnumerable<ModeFormationDTO> modeFormationDTOs;

            modeFormations = epContext.ModeFormation;

            modeFormationDTOs = modeFormations.Select(modeFormation => GetModeFormationDTO(modeFormation));

            return modeFormationDTOs;
        }

        /// <summary>
        /// Récupérer les modes de formation de manière asynchrone
        /// </summary>
        /// <returns></returns>
        public async Task<IEnumerable<ModeFormationDTO>> GetModesFormationAsync()
        {
            IEnumerable<ModeFormation> modeFormations;
            IEnumerable<ModeFormationDTO> modeFormationDTOs;
            modeFormations = await epContext.ModeFormation.ToListAsync();

            modeFormationDTOs = modeFormations.Select(modeFormation => GetModeFormationDTO(modeFormation));

            return modeFormationDTOs;
        }

        /// <summary>
        /// Récupérer les origines de formation
        /// </summary>
        /// <returns></returns>
        public IEnumerable<OrigineFormationDTO> GetOriginesFormation()
        {
            IEnumerable<OrigineFormation> origineFormations;
            IEnumerable<OrigineFormationDTO> origineFormationDTOs;

            origineFormations = epContext.OrigineFormation;

            origineFormationDTOs = origineFormations.Select(origineFormation => GetOrigineFormationDTO(origineFormation));

            return origineFormationDTOs;
        }

        /// <summary>
        /// Récupérer les origines de formation de manière asynchrone
        /// </summary>
        /// <returns></returns>
        public async Task<IEnumerable<OrigineFormationDTO>> GetOriginesFormationAsync()
        {
            IEnumerable<OrigineFormation> origineFormations;
            IEnumerable<OrigineFormationDTO> origineFormationDTOs;

            origineFormations = await epContext.OrigineFormation.ToListAsync();

            origineFormationDTOs = origineFormations.Select(origineFormation => GetOrigineFormationDTO(origineFormation));

            return origineFormationDTOs;
        }

        /// <summary>
        /// Récupérer les statuts de formation
        /// </summary>
        /// <returns></returns>
        public IEnumerable<StatutFormationDTO> GetStatutsFormation()
        {
            IEnumerable<StatutFormation> statutFormations;
            IEnumerable<StatutFormationDTO> statutFormationDTOs;

            statutFormations = epContext.StatutFormation;

            statutFormationDTOs = statutFormations.Select(statutFormation => GetStatutFormationDTO(statutFormation));

            return statutFormationDTOs;
        }

        /// <summary>
        /// Récupérer les statuts de formation de manière asynchrone
        /// </summary>
        /// <returns></returns>
        public async Task<IEnumerable<StatutFormationDTO>> GetStatutsFormationAsync()
        {
            IEnumerable<StatutFormation> statutFormations;
            IEnumerable<StatutFormationDTO> statutFormationDTOs;

            statutFormations = await epContext.StatutFormation.ToListAsync();

            statutFormationDTOs = statutFormations.Select(statutFormation => GetStatutFormationDTO(statutFormation));

            return statutFormationDTOs;
        }

        /// <summary>
        /// Récupérer les types de formation
        /// </summary>
        /// <returns></returns>
        public IEnumerable<TypeFormationDTO> GetTypesFormation()
        {
            IEnumerable<TypeFormation> typeFormations;
            IEnumerable<TypeFormationDTO> typeFormationDTOs;

            typeFormations = epContext.TypeFormation;

            typeFormationDTOs = typeFormations.Select(typeFormation => GetTypeFormationDTO(typeFormation));

            return typeFormationDTOs;
        }

        /// <summary>
        /// Récupérer les types de formation de manière asynchrone
        /// </summary>
        /// <returns></returns>
        public async Task<IEnumerable<TypeFormationDTO>> GetTypesFormationAsync()
        {
            IEnumerable<TypeFormation> typeFormations;
            IEnumerable<TypeFormationDTO> typeFormationDTOs;

            typeFormations = await epContext.TypeFormation.ToListAsync();

            typeFormationDTOs = typeFormations.Select(typeFormation => GetTypeFormationDTO(typeFormation));

            return typeFormationDTOs;
        }

        /// <summary>
        /// Ajouter une formation
        /// </summary>
        /// <param name="formationDTO"></param>
        /// <returns></returns>
        public FormationDTO AddFormation(FormationDTO formationDTO)
        {
            if (!IsFormationValide(formationDTO))
                throw new FormationInvalidException();

            Formation formation = new Formation();
            formation = SetFormation(formation, formationDTO);

            epContext.StatutFormation.Attach(formation.Statut);
            epContext.OrigineFormation.Attach(formation.Origine);
            epContext.ModeFormation.Attach(formation.ModeFormation);
            epContext.TypeFormation.Attach(formation.TypeFormation);
            epContext.Add(formation);

            epContext.SaveChanges();

            return GetFormationDTO(formation);
        }

        /// <summary>
        /// Ajouter une formation de manière asynchrone
        /// </summary>
        /// <param name="formationDTO"></param>
        /// <returns></returns>
        public async Task<FormationDTO> AddFormationAsync(FormationDTO formationDTO)
        {
            if (!await IsFormationValideAsync(formationDTO))
                throw new FormationInvalidException();

            Formation formation = new Formation();
            formation = SetFormation(formation, formationDTO);

            epContext.StatutFormation.Attach(formation.Statut);
            epContext.OrigineFormation.Attach(formation.Origine);
            epContext.ModeFormation.Attach(formation.ModeFormation);
            epContext.TypeFormation.Attach(formation.TypeFormation);
            epContext.Add(formation);

            await epContext.SaveChangesAsync();

            return GetFormationDTO(formation);
        }

        /// <summary>
        /// Modifier une formation
        /// </summary>
        /// <param name="idFormation"></param>
        /// <param name="formationDTO"></param>
        /// <returns></returns>
        public FormationDTO UpdateFormation(long? idFormation, FormationDTO formationDTO)
        {
            if (!IsFormationValide(formationDTO))
                throw new FormationInvalidException();

            if (!formationDTO.Id.HasValue || formationDTO.Id.Value != idFormation)
                throw new FormationIncompatibleIdException();

            Formation formation = epContext.Formation.Find(idFormation.Value);

            if (formation == null)
                return null;

            formation = SetFormation(formation, formationDTO);

            epContext.SaveChanges();

            return GetFormationDTO(formation);
        }

        /// <summary>
        /// Modifier une formation de manière asynchrone
        /// </summary>
        /// <param name="idFormation"></param>
        /// <param name="formationDTO"></param>
        /// <returns></returns>
        public async Task<FormationDTO> UpdateFormationAsync(long? idFormation, FormationDTO formationDTO)
        {
            if (!IsFormationValide(formationDTO))
                throw new FormationInvalidException();

            if (!formationDTO.Id.HasValue || formationDTO.Id.Value != idFormation)
                throw new FormationIncompatibleIdException();

            Formation formation = await epContext.Formation.FindAsync(idFormation.Value);

            if (formation == null)
                return null;

            formation = SetFormation(formation, formationDTO);
            await epContext.SaveChangesAsync();

            return GetFormationDTO(formation);
        }

        /// <summary>
        /// Supprimer une formation
        /// </summary>
        /// <param name="idFormation"></param>
        /// <returns></returns>
        public FormationDTO DeleteFormationById(long? idFormation)
        {
            if (!idFormation.HasValue)
                throw new FormationIncompatibleIdException();


            Formation formation = epContext.Formation.Find(idFormation.Value);

            if (formation == null)
                throw new FormationNotFoundException();

            epContext.Remove(formation);

            epContext.SaveChanges();

            return GetFormationDTO(formation);
        }

        /// <summary>
        /// Supprimer une formation de manière asynchrone
        /// </summary>
        /// <param name="idFormation"></param>
        /// <returns></returns>
        public async Task<FormationDTO> DeleteFormationByIdAsync(long? idFormation)
        {
            if (!idFormation.HasValue)
                throw new FormationIncompatibleIdException();

            Formation formation = await epContext.Formation.FindAsync(idFormation.Value);

            if (formation == null)
                throw new FormationNotFoundException();

            epContext.Remove(formation);

            await epContext.SaveChangesAsync();

            return GetFormationDTO(formation);
        }
        #endregion

        #region Méthodes Privée
        /// <summary>
        /// Vérifier si un objet FormationDTO est valide pour ajout ou mise à jour
        /// </summary>
        /// <remarks> Un objet FormationDTO est valide si aucune de ses propriétés n'est à null,si la date de début de la formation est inférieur à la date de fin et si le statut, l'origine,le mode et le type sont présents dans la base de données</remarks>
        /// <param name="formation"></param>
        /// <returns>true si l'objet est valide, false sinon</returns>
        private bool IsFormationValide(FormationDTO formation)
        {
            return !(formation == null || formation.Statut == null || formation.Mode == null || formation.Origine == null || formation.Type == null
            || !formation.IdAgence.HasValue || formation.IdAgence == 0
            || string.IsNullOrWhiteSpace(formation.Intitule) || string.IsNullOrWhiteSpace(formation.Organisme)
            || !formation.DateDebut.HasValue || !formation.DateFin.HasValue || formation.DateDebut.Value > formation.DateFin.Value
            || !formation.Statut.Id.HasValue || !formation.Mode.Id.HasValue || !formation.Origine.Id.HasValue || !formation.Type.Id.HasValue
            || !epContext.StatutFormation.Any(statut => statut.IdStatutFormation == formation.Statut.Id.Value && statut.Libelle == formation.Statut.Libelle)
            || !epContext.ModeFormation.Any(mode => mode.IdModeFormation == formation.Mode.Id.Value && mode.Libelle == formation.Mode.Libelle)
            || !epContext.OrigineFormation.Any(origine => origine.IdOrigineFormation == formation.Origine.Id.Value && origine.Libelle == formation.Origine.Libelle)
            || !epContext.TypeFormation.Any(type => type.IdTypeFormation == formation.Type.Id.Value && type.Libelle == formation.Type.Libelle));
        }

        /// <summary>
        /// Vérifier si un objet FormationDTO est valide pour ajout ou mise à jour
        /// </summary>
        /// <remarks> Un objet FormationDTO est valide si aucune de ses propriétés n'est à null,si la date de début de la formation est inférieur à la date de fin et si le statut, l'origine,le mode et le type sont présents dans la base de données</remarks>
        /// <param name="formation"></param>
        /// <returns>true si l'objet est valide, false sinon</returns>
        private async Task<bool> IsFormationValideAsync(FormationDTO formation)
        {
            return !(formation == null || formation.Statut == null || formation.Mode == null || formation.Origine == null || formation.Type == null
            || !formation.IdAgence.HasValue || formation.IdAgence == 0
            || string.IsNullOrWhiteSpace(formation.Intitule) || string.IsNullOrWhiteSpace(formation.Organisme)
            || !formation.DateDebut.HasValue || !formation.DateFin.HasValue || formation.DateDebut.Value > formation.DateFin.Value
            || !formation.Statut.Id.HasValue || !formation.Mode.Id.HasValue || !formation.Origine.Id.HasValue || !formation.Type.Id.HasValue
            || ! await epContext.StatutFormation.AnyAsync(statut => statut.IdStatutFormation == formation.Statut.Id.Value && statut.Libelle == formation.Statut.Libelle)
            || ! await epContext.ModeFormation.AnyAsync(mode => mode.IdModeFormation == formation.Mode.Id.Value && mode.Libelle == formation.Mode.Libelle)
            || ! await epContext.OrigineFormation.AnyAsync(origine => origine.IdOrigineFormation == formation.Origine.Id.Value && origine.Libelle == formation.Origine.Libelle)
            || ! await epContext.TypeFormation.AnyAsync(type => type.IdTypeFormation == formation.Type.Id.Value && type.Libelle == formation.Type.Libelle));
        }
        #region Object to DTO
        /// <summary>
        /// Récupère un objet FormationDTO en fonction d'un objet Formation
        /// </summary>
        /// <param name="formation"></param>
        /// <returns></returns>
        private FormationDTO GetFormationDTO(Formation formation)
        {
            FormationDTO formationDTO = new FormationDTO()
            {
                Id = formation.IdFormation,
                Intitule = formation.Intitule,
                IdAgence = formation.IdAgence,
                DateDebut = formation.DateDebut,
                DateFin = formation.DateFin,
                Heure = formation.Heure,
                Jour = formation.Jour,
                Organisme = formation.Organisme,
                EstCertifiee = formation.EstCertifiee,
                Origine = GetOrigineFormationDTO(formation.Origine),
                Statut = GetStatutFormationDTO(formation.Statut),
                Mode = GetModeFormationDTO(formation.ModeFormation),
                Type = GetTypeFormationDTO(formation.TypeFormation)
            };

            return formationDTO;
        }

        /// <summary>
        /// Récupère un objet OrigineFormationDTO en fonction d'un objet OrigineFormation
        /// </summary>
        /// <param name="origineFormation"></param>
        /// <returns></returns>
        private OrigineFormationDTO GetOrigineFormationDTO(OrigineFormation origineFormation)
        {
            if (origineFormation == null)
                return null;
            OrigineFormationDTO origineFormationDTO = new OrigineFormationDTO()
            {
                Id = origineFormation.IdOrigineFormation,
                Libelle = origineFormation.Libelle
            };
            return origineFormationDTO;
        }

        /// <summary>
        /// Récupère un objet StatutFormationDTO en fonction d'un objet StatutFormation
        /// </summary>
        /// <param name="statutFormation"></param>
        /// <returns></returns>
        private StatutFormationDTO GetStatutFormationDTO(StatutFormation statutFormation)
        {
            if (statutFormation == null)
                return null;
            StatutFormationDTO statutFormationDTO = new StatutFormationDTO()
            {
                Id = statutFormation.IdStatutFormation,
                Libelle = statutFormation.Libelle
            };
            return statutFormationDTO;
        }

        /// <summary>
        /// Récupère un objet ModeFormationDTO en fonction d'un objet ModeFormation
        /// </summary>
        /// <param name="modeFormation"></param>
        /// <returns></returns>
        private ModeFormationDTO GetModeFormationDTO(ModeFormation modeFormation)
        {
            if (modeFormation == null)
                return null;
            ModeFormationDTO modeFormationDTO = new ModeFormationDTO()
            {
                Id = modeFormation.IdModeFormation,
                Libelle = modeFormation.Libelle
            };
            return modeFormationDTO;
        }
        /// <summary>
        /// Récupère un objet TypeFormationDTO en fonction d'un objet TypeFormation
        /// </summary>
        /// <param name="typeFormation"></param>
        /// <returns></returns>
        private TypeFormationDTO GetTypeFormationDTO(TypeFormation typeFormation)
        {
            if (typeFormation == null)
                return null;
            TypeFormationDTO typeFormationDTO = new TypeFormationDTO()
            {
                Id = typeFormation.IdTypeFormation,
                Libelle = typeFormation.Libelle
            };
            return typeFormationDTO;
        }

        #endregion

        #region DTO to Object

        /// <summary>
        /// Modifie un objet Formation en fonction d'un objet FormationDTO
        /// </summary>
        /// <param name="formation"></param>
        /// <param name="formationDTO"></param>
        /// <returns></returns>
        private Formation SetFormation(Formation formation, FormationDTO formationDTO)
        {
            formation.Intitule = formationDTO.Intitule;
            formation.IdAgence = formationDTO.IdAgence.Value;
            formation.DateDebut = formationDTO.DateDebut.Value;
            formation.DateFin = formationDTO.DateFin.Value;
            formation.Heure = Convert.ToInt32(formationDTO.Heure.Value);
            formation.Jour = Convert.ToInt32(formationDTO.Jour.Value);
            formation.Organisme = formationDTO.Organisme;
            formation.EstCertifiee = formationDTO.EstCertifiee.Value;
            formation.Origine = GetOrigineFormation(formationDTO.Origine);
            formation.Statut = GetStatutFormation(formationDTO.Statut);
            formation.ModeFormation = GetModeFormation(formationDTO.Mode);
            formation.TypeFormation = GetTypeFormation(formationDTO.Type);

            return formation;
        }

        /// <summary>
        /// Récupère un objet OrigineFormation en fonction d'un objet OrigineFormationDTO
        /// </summary>
        /// <param name="origineFormationDTO"></param>
        /// <returns></returns>
        private OrigineFormation GetOrigineFormation(OrigineFormationDTO origineFormationDTO)
        {
            OrigineFormation origineFormation = new OrigineFormation()
            {
                IdOrigineFormation = origineFormationDTO.Id.Value,
                Libelle = origineFormationDTO.Libelle
            };
            return origineFormation;
        }

        /// <summary>
        /// Récupère un objet StatutFormation en fonction d'un objet StatutFormationDTO
        /// </summary>
        /// <param name="statutFormationDTO"></param>
        /// <returns></returns>
        private StatutFormation GetStatutFormation(StatutFormationDTO statutFormationDTO)
        {
            StatutFormation statutFormation = new StatutFormation()
            {
                IdStatutFormation = statutFormationDTO.Id.Value,
                Libelle = statutFormationDTO.Libelle
            };
            return statutFormation;
        }

        /// <summary>
        /// Récupère un objet ModeFormation en fonction d'un objet ModeFormationDTO
        /// </summary>
        /// <param name="modeFormationDTO"></param>
        /// <returns></returns>
        private ModeFormation GetModeFormation(ModeFormationDTO modeFormationDTO)
        {
            ModeFormation modeFormation = new ModeFormation()
            {
                IdModeFormation = modeFormationDTO.Id.Value,
                Libelle = modeFormationDTO.Libelle
            };
            return modeFormation;
        }

        /// <summary>
        /// Récupère un objet TypeFormation en fonction d'un objet TypeFormationDTO
        /// </summary>
        /// <param name="typeFormationDTO"></param>
        /// <returns></returns>
        private TypeFormation GetTypeFormation(TypeFormationDTO typeFormationDTO)
        {
            TypeFormation typeFormation = new TypeFormation()
            {
                IdTypeFormation = typeFormationDTO.Id.Value,
                Libelle = typeFormationDTO.Libelle
            };
            return typeFormation;
        }

        #endregion

        #endregion

    }
}