using Modèle;
using Persistance;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Business
{

    /// <summary>
    ///  Class Manager qui gère les requins, les requins ajoutés, les requins modifiés et les fun facts
    /// </summary>
    public class Manager
    {
        public ObservableCollection<Requin> Requins { get; private set; }   //ObservableCollection<Requin> les requins qui ont déjà été validés
        public ObservableCollection<Requin> RequinsEdit { get; private set; }   //ObservableCollection<Requin> les requins qui ont été modifiés par des utilisateurs et qui n'ont pas encore été validés
        public ObservableCollection<Requin> RequinsAdd { get; private set; }   //ObservableCollection<Requin> les requins qui ont été ajoutés par des utilisateurs et qui n'ont pas encore été validés
        public Requin SelectedRequin { get; set; }  //Requin actuellement utilisé dans l'application


        public List<String> FunFacts { get; private set; } = new List<String>();    //List<string> la liste des fun facts


        /// <summary>
        ///  DéPENDANCE
        /// </summary>
    
        public IPersistanceManager Pers { get; set; }   //IPersistanceManager ce qui permet de gérer la persistance de l'applcation

        /// <summary>
        /// constructeur avec INJECTION DE LA DéPENDANCE
        /// </summary>

        public Manager(IPersistanceManager pers)
        {
            Requins = new ObservableCollection<Requin>();
            RequinsEdit = new ObservableCollection<Requin>();
            RequinsAdd = new ObservableCollection<Requin>();
            Pers = pers;
        }

        /// <summary>
        /// Méthode LoadRequins de la classe Manager qui permet de remplir les listes de requins grâce à l'IPersistanceManager
        /// </summary>
        public void LoadRequins()
        {

            var data = Pers.LoadRequins();

            Requins.Clear();
            foreach(var r in data.reqs)
            {
                Requins.Add(r);
            }
            RequinsAdd.Clear();
            foreach(var rA in data.reqsAdd)
            {
                RequinsAdd.Add(rA);
            }
            RequinsEdit.Clear();
            foreach(var rE in data.reqsEdit)
            {
                RequinsEdit.Add(rE);
            }
        }


        /// <summary>
        /// Méthode SaveRequins de la classe Manager qui permet de sauvegarder les listes de requins grâce à l'IPersistanceManager
        /// </summary>
        public void SaveRequins()
        {
            List<Requin> req = new List<Requin>();
            req.AddRange(Requins);
            List<Requin> edit = new List<Requin>();
            edit.AddRange(RequinsEdit);
            List<Requin> add = new List<Requin>();
            add.AddRange(RequinsAdd);

            Pers.SaveRequins(req, add, edit);
        }


        /// <summary>
        /// Méthode AjouterRequin de la classe Manager qui permet d'ajouter un requin dans la liste des requins
        /// </summary>
        /// <param name="req">Requin qui va être ajouté dans la liste</param>
        /// <returns>Booléen : true si il a été ajouté, false sinon</returns>
        public bool AjouterRequin(Requin req)
        {
            Requin test = Requins.SingleOrDefault(r => r.Equals(req));
            if (Requins.Contains(req) && test!=null){
                return false;

            }
            Requins.Add(req);
            return true;
        }

        /// <summary>
        /// Méthode SupprimerRequin de la classe Manager qui permet de supprimer un requin de la liste des requins
        /// </summary>
        /// <param name="req">Requin qui va être supprimé dans la liste</param>
        /// <returns>Booléen : true si il a été supprimé, false sinon</returns>
        public bool SupprimerRequin(Requin req)
        {
            Requin test = Requins.SingleOrDefault(r => r.Equals(req));
            if (!Requins.Contains(req) || test == null)
            {
                return false;
            }
            Requins.Remove(req);
            return true;
        }


        /// <summary>
        /// Méthode GetRequin de la classe Manager qui permet de récupérer un requin de la liste des requins
        /// </summary>
        /// <param name="req">Requin que l'on cherche dans dans la liste</param>
        /// <returns>Requin trouvé</returns>
        public Requin GetRequin(Requin req)
        {
            return Requins.SingleOrDefault(r => r.Equals(req));
        }


        /// <summary>
        /// Méthode ModifieRequin de la classe Manager qui permet de modifier un ancien requin de la liste des requins à partir d'un nouveau
        /// </summary>
        /// <param name="oldR">Requin l'ancien requin dans la liste des requins</param>
        /// <param name="newR">Requin le nouveau requin</param>
        /// <returns>Booléen : true si il a été modifié, false sinon</returns>
        public bool ModifieRequin(Requin oldR, Requin newR)
        {
            if (!oldR.Equals(newR))
            {
                return false;
            }
            Requins.Remove(oldR);
            Requins.Add(newR);
            return true;
        }


        /// <summary>
        /// Méthode AjouterRequinEdit de la classe Manager qui permet d'ajouter un requin dans la liste des requins modifiés
        /// </summary>
        /// <param name="req">Requin qui va être ajouté dans la liste</param>
        /// <returns>Booléen : true si il a été ajouté, false sinon</returns>
        public bool AjouterRequinEdit(Requin req)
        {
            Requin test = RequinsEdit.SingleOrDefault(r => r.Equals(req));
            if (RequinsEdit.Contains(req) && test != null)
            {
                return false;

            }
            RequinsEdit.Add(req);
            return true;
        }

        /// <summary>
        /// Méthode SupprimerRequinEdit de la classe Manager qui permet de supprimer un requin de la liste des requins modifiés
        /// </summary>
        /// <param name="req">Requin qui va être supprimé dans la liste</param>
        /// <returns>Booléen : true si il a été supprimé, false sinon</returns>
        public bool SupprimerRequinEdit(Requin req)
        {
            Requin test = RequinsEdit.SingleOrDefault(r => r.Equals(req));
            if (!RequinsEdit.Contains(req) || test == null)
            {
                return false;
            }
            RequinsEdit.Remove(req);
            return true;
        }


        /// <summary>
        /// Méthode AjouterRequinAdd de la classe Manager qui permet d'ajouter un requin dans la liste des requins ajoutés
        /// </summary>
        /// <param name="req">Requin qui va être ajouté dans la liste</param>
        /// <returns>Booléen : true si il a été ajouté, false sinon</returns>
        public bool AjouterRequinAdd(Requin req)
        {
            Requin test = RequinsAdd.SingleOrDefault(r => r.Equals(req));
            if (RequinsAdd.Contains(req) && test != null)
            {
                return false;

            }
            RequinsAdd.Add(req);
            return true;
        }


        /// <summary>
        /// Méthode SupprimerRequinAdd de la classe Manager qui permet de supprimer un requin de la liste des requins ajoutés
        /// </summary>
        /// <param name="req">Requin qui va être supprimé dans la liste</param>
        /// <returns>Booléen : true si il a été supprimé, false sinon</returns>
        public bool SupprimerRequinAdd(Requin req)
        {
            Requin test = RequinsAdd.SingleOrDefault(r => r.Equals(req));
            if (!RequinsAdd.Contains(req) || test == null)
            {
                return false;
            }
            RequinsAdd.Remove(req);
            return true;
        }


        /// <summary>
        /// Méthode GetRequinEdit de la classe Manager qui permet de récupérer un requin de la liste des requins modifiés
        /// </summary>
        /// <param name="req">Requin que l'on cherche dans dans la liste</param>
        /// <returns>Requin trouvé</returns>
        public Requin GetRequinEdit(Requin req)
        {
            return RequinsEdit.SingleOrDefault(r => r.Equals(req));
        }


        /// <summary>
        /// Méthode GetRequinAdd de la classe Manager qui permet de récupérer un requin de la liste des requins ajoutés
        /// </summary>
        /// <param name="req">Requin que l'on cherche dans dans la liste</param>
        /// <returns>Requin trouvé</returns>
        public Requin GetRequinAdd(Requin req)
        {
            return RequinsAdd.SingleOrDefault(r => r.Equals(req));
        }


        /// <summary>
        /// Méthode RechercherRequins qui permet de rechercher des requins dans une ObservableCollection<Requin> en fonction de leurs zones et d'un motif
        /// </summary>
        /// <param name="lRech">ObservableCollection<Requin> dans laquelle on fait la recherche</param>
        /// <param name="motif">string sur lequel on fait la recherche</param>
        /// <param name="zone">Zone? sur laquelle on fait la recherche</param>
        /// <returns>List<Requin> contenant tous les requins trouvés en fonction du motif et de la zone</returns>
        public List<Requin> RechercherRequins(ObservableCollection<Requin> lRech, Nullable<Zone> zone, string motif)
        {
            List<Requin> nvReq = new List<Requin>();
            int test = 0;
            if (!string.IsNullOrWhiteSpace(motif))
            {
                foreach (Requin req in lRech)
                {
                    if (zone == null)
                    {
                        if (req.Nom.Contains(motif) || req.NomSci.Contains(motif))
                        {
                            nvReq.Add(req);
                        }
                    }
                    else
                    {
                        foreach (Zone z in req.Repartition)
                        {
                            if ((req.Nom.Contains(motif) || req.NomSci.Contains(motif)) && zone == z)
                            {
                                test++;
                            }
                        }
                        if (test > 0)
                        {
                            nvReq.Add(req);
                        }
                    }
                    test = 0;
                }
            }
            return nvReq;
        }

        /// <summary>
        /// Méthode vérifierRequin qui permet de vérifiersi les strings que l'on donnerait au constructeur de requin son vides
        /// </summary>
        /// <returns>Booléen : true si il n'y en a pas de vide, false sinon</returns>
        public bool verifierRequin(String nom, String nomSci, String description, String photo, String video, String photoCarte)
        {
            if (String.IsNullOrWhiteSpace(nom) || String.IsNullOrWhiteSpace(nomSci) || String.IsNullOrWhiteSpace(description) || String.IsNullOrWhiteSpace(photo)
                || String.IsNullOrWhiteSpace(video) || String.IsNullOrWhiteSpace(photoCarte))
            {
                return false;
            }
            return true;
        }


        /// <summary>
        /// Méthode LoadFunFacts de la classe Manager qui permet de charger la liste de fun facts grâce à l'IPersistanceManager
        /// </summary>
        public void LoadFunFacts()
        {
            FunFacts.Clear();

            foreach(String fun in Pers.LoadFunFacts())
            {
                FunFacts.Add(fun);
            }
        }

        /// <summary>
        /// Méthode LoadFunFacts de la classe Manager qui permet de sauvegarder la liste de fun facts grâce à l'IPersistanceManager
        /// </summary>
        public void SaveFunFacts()
        {
            Pers.SaveFunFacts(FunFacts);
        }
    }
}