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
{
    public class Manager
    {
        public ObservableCollection<Requin> Requins { get; private set; }
        public ObservableCollection<Requin> RequinsEdit { get; private set; }
        public ObservableCollection<Requin> RequinsAdd { get; private set; }
        public Requin SelectedRequin { get; set; }


        public List<String> FunFacts { get; private set; } = new List<String>();


        /// <summary>
        ///  DéPENDANCE
        /// </summary>
    
        public IPersistanceManager Pers { get; set; }

        /// <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;
        }
        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);
            }

            SelectedRequin = null;
        }

        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);
        }

        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;
        }

        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;
        }

        public Requin GetRequin(Requin req)
        {
            return Requins.SingleOrDefault(r => r.Equals(req));
        }

        public bool ModifieRequin(Requin oldR, Requin newR)
        {
            if (!oldR.Equals(newR))
            {
                return false;
            }
            Requins.Remove(oldR);
            Requins.Add(newR);
            return true;
        }

        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;
        }

        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;
        }


        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;
        }

        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;
        }

        public Requin GetRequinEdit(Requin req)
        {
            return RequinsEdit.SingleOrDefault(r => r.Equals(req));
        }

        public Requin GetRequinAdd(Requin req)
        {
            return RequinsAdd.SingleOrDefault(r => r.Equals(req));
        }

        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;
        }

        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;
        }


        public void LoadFunFacts()
        {
            FunFacts.Clear();

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


        public void SaveFunFacts()
        {
            Pers.SaveFunFacts(FunFacts);
        }
    }
}