public async Task<List<Competiteur>> ImporterCSV(string cheminFichier)
        {
            List<Competiteur> ListeResult = new List<Competiteur>();

            string line;
            using (StreamReader reader = new StreamReader(cheminFichier, Encoding.GetEncoding(1252)))
            {
                string headerLine = await reader.ReadLineAsync();
                while (!reader.EndOfStream)
                {
                    line = reader.ReadLine();
                    var values = line.Split(';');

                    if (!String.IsNullOrWhiteSpace(values[0]) && !String.IsNullOrWhiteSpace(values[1]) && !String.IsNullOrWhiteSpace(values[5]))
                    {
                        Competiteur competiteurTemporaire = new Competiteur
                        {
                            Nom = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(values[0].ToLower()),
                            Prenom = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(values[1].ToLower()),
                            Club = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(values[4].ToLower()),
                        };

                        Sexes sexOut;
                        if (Enum.TryParse(values[2], out sexOut))
                        {
                            competiteurTemporaire.Sexe = (Sexes)Enum.Parse(typeof(Sexes), values[2]);
                        }

                        double doubleOut;
                        if (double.TryParse(values[3], out doubleOut))
                        {
                            competiteurTemporaire.Poids = Convert.ToDouble(values[3]);
                        }
                        else
                        {
                            competiteurTemporaire.Poids = 0;
                        }

                        Categories categoriesOut;
                        if (Enum.TryParse(values[5], out categoriesOut))
                        {
                            competiteurTemporaire.Categorie = (Categories)Enum.Parse(typeof(Categories), values[5]);
                        }
                        ListeResult.Add(competiteurTemporaire);
                    }
                }
            }
            return ListeResult;
        }
        public List<Competiteur> ImporterXLS(string cheminFichier)
        {
            List<Competiteur> ListeResult = new List<Competiteur>();

            using (Stream stream = new FileStream(cheminFichier,
                                 FileMode.Open,
                                 FileAccess.Read,
                                 FileShare.ReadWrite))
            {
                IExcelDataReader excelReader = ExcelReaderFactory.CreateOpenXmlReader(stream);
                excelReader.IsFirstRowAsColumnNames = true;

                //Skip First row
                excelReader.Read();
                while (excelReader.Read())
                {
                    Competiteur competiteurTemporaire = new Competiteur
                    {
                        Nom = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(excelReader.GetString(0).ToLower()),
                        Prenom = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(excelReader.GetString(1).ToLower()),
                        Club = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(excelReader.GetString(4).ToLower()),
                    };

                    Sexes sexOut;
                    if (Enum.TryParse(excelReader.GetString(2), out sexOut))
                    {
                        competiteurTemporaire.Sexe = (Sexes)Enum.Parse(typeof(Sexes), excelReader.GetString(2));
                    }

                    double doubleOut;
                    if (double.TryParse(excelReader.GetString(3), out doubleOut))
                    {
                        competiteurTemporaire.Poids = Convert.ToDouble(excelReader.GetString(3));
                    }
                    else
                    {
                        competiteurTemporaire.Poids = 0;
                    }

                    Categories categoriesOut;
                    if (Enum.TryParse(excelReader.GetString(5), out categoriesOut))
                    {
                        competiteurTemporaire.Categorie = (Categories)Enum.Parse(typeof(Categories), excelReader.GetString(5));
                    }

                    ListeResult.Add(competiteurTemporaire);
                }
            }
            return ListeResult;
        }
        private void GenererGroupes()
        {
            Donnee.ListeCompetiteurs = new ObservableCollection<Competiteur>(Donnee.ListeCompetiteurs.OrderBy(c => c.Categorie).ThenBy(d => d.Sexe).ThenBy(f => f.Poids).ToList());

            int poule = 1;
            int compteur = 1;

            foreach (var competiteur in Donnee.ListeCompetiteurs)
            {
                competiteur.Poule = null;
            }

            Competiteur compTemp = new Competiteur();
            bool pouleVide = true;

            foreach (var categorie in ListeCategories)
            {
                foreach (var sexe in ListeSexes)
                {
                    foreach (var competiteur in Donnee.ListeCompetiteurs.Where(c => c.EstPresent))
                    {
                        if (competiteur.Sexe == sexe && competiteur.Categorie == (categorie))
                        {
                            pouleVide = false;
                            competiteur.Poule = poule;
                            compteur++;
                            if (compteur == Donnee.NombreParPoule + 1)
                            {
                                poule++;
                                compteur = 1;
                            }
                        }
                    }
                    if (!pouleVide)
                    {
                        poule++;
                        compteur = 1;
                        pouleVide = true;
                    }
                }
                if (!pouleVide)
                {
                    poule++;
                    compteur = 1;
                    pouleVide = true;
                }
            }

            OnPropertyChanged("ListeCompetiteurs");
        }
        private void AjouterCompetiteur()
        {
            bool estValide = true;

            var newCompetiteur = new Competiteur()
            {
                Club = NouveauCompetiteurClub,
                Nom = NouveauCompetiteurNom,
                Prenom = NouveauCompetiteurPrenom,
            };
            try
            {
                newCompetiteur.Categorie = ListeCategories.FirstOrDefault(c => c.ToString().Equals(NouveauCompetiteurCategorie));
            }
            catch (Exception)
            {
                estValide = false;
                //MessageBox.Show("Catégorie non selectionnée", "Erreur", MessageBoxButton.OK, MessageBoxImage.Error);
            }

            if (!String.IsNullOrWhiteSpace(NouveauCompetiteurPoids))
                try
                {
                    NouveauCompetiteurPoids = NouveauCompetiteurPoids.Replace('.', ',');
                    newCompetiteur.Poids = Convert.ToDouble(NouveauCompetiteurPoids);
                }
                catch (FormatException)
                {
                    estValide = false;
                    //MessageBox.Show("Poids invalide", "Erreur", MessageBoxButton.OK, MessageBoxImage.Error);
                }

            //Infos  de la barre à curseur glissant qui itère entre 0 (masculin) et 1 (féminin)
            switch (NouveauCompetiteurSexe)
            {
                case 0:
                    newCompetiteur.Sexe = Sexes.M;
                    break;
                case 1:
                    {
                        estValide = false;
                        //MessageBox.Show("Sexe invalide", "Erreur", MessageBoxButton.OK, MessageBoxImage.Error);
                    }
                    break;
                case 2:
                    newCompetiteur.Sexe = Sexes.F;
                    break;
            }

            if (NouveauCompetiteurEstPresent)
                newCompetiteur.EstPresent = true;
            else
                newCompetiteur.EstPresent = false;

            if (estValide)
            {
                //grilleCompetiteurs.DataContext = donnee.ListeCompetiteurs;                
                Donnee.ListeCompetiteurs.Add(newCompetiteur);
                ResetChampsNouveauCompetiteur();
                OnPropertyChanged("ListeClubs");
                OnPropertyChanged("StatsCompetiteursPresents");
                OnPropertyChanged("StatsCompetiteursInscrits");
                OnPropertyChanged("ListeCompetiteurs");
                //affichageSelectif();
            }

        }
        public void QuickAddCompetiteur(Competiteur competiteur)
        {
            Competiteur Comp = Donnee.ListeCompetiteurs.Where(c => c.Nom.ToLower().Equals(competiteur.Nom.ToLower()) && c.Prenom.ToLower().Equals(competiteur.Prenom.ToLower())).FirstOrDefault();

            if (Comp == null)
            {
                Donnee.ListeCompetiteurs.Add(competiteur);
                OnPropertyChanged("ListeCompetiteurs");
            }
            else
            {
                if (MessageBox.Show(string.Format("Un judoka identique existe déjà : {0}-{1} {2} {3}kg {4} {5} Ajouter quand même : {6}-{7} {8} {9}kg {10}",
                    Environment.NewLine, Comp.Nom, Comp.Prenom, Comp.Poids, Comp.Categorie,
                    Environment.NewLine,
                    Environment.NewLine, competiteur.Nom, competiteur.Prenom, competiteur.Poids, competiteur.Categorie), "Doublon", MessageBoxButton.YesNo, MessageBoxImage.Warning) == MessageBoxResult.No)
                {

                }
                else
                {
                    Donnee.ListeCompetiteurs.Add(competiteur);

                }
            }
            OnPropertyChanged("ListeCompetiteurs");
            OnPropertyChanged("ListeClubs");
        }
 public void SupprimerCompetiteur(Competiteur c)
 {
     Donnee.ListeCompetiteurs.Remove(c);
     OnPropertyChanged("ListeClubs");
     OnPropertyChanged("StatsCompetiteursInscrits");
     OnPropertyChanged("StatsCompetiteursPresents");
     OnPropertyChanged("ListeCompetiteurs");
 }
 //Callback pour ajouter des Competiteurs à partir de la fenetre d'import
 private void addCompetiteurs(Competiteur competiteur)
 {
     VM.QuickAddCompetiteur(competiteur);
 }