using Modèle;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Runtime.Serialization;
using System.Text;
using System.Threading.Tasks;
using System.Xml;

namespace Persistance
{
    /// <summary>
    /// Classe DataContractPersistance qui implémente IPersistanceManager et stocke les données dans les fichiers de persistance
    /// </summary>
    public class DataContractPersistance : IPersistanceManager
    {

        // Serializers pour requins et utlisateurs/experts

        /// <summary>
        /// DataContractSerializer permet de serialiser le type DataToPersistReq
        /// </summary>
        DataContractSerializer SerializerReq { get; set; }
            = new DataContractSerializer(typeof(DataToPersistReq));
        /// <summary>
        /// DataContractSerializer permet de serialiser le type DataToPersistUsers
        /// </summary>
        DataContractSerializer SerializerUsers { get; set; }
            = new DataContractSerializer(typeof(DataToPersistUsers));
        /// <summary>
        /// DataContractSerializer permet de serialiser le type List de String
        /// </summary>
        DataContractSerializer SerializerFun { get; set; }
            = new DataContractSerializer(typeof(List<String>));




        // DataToPersistReq et DataToPersistUsers

        /// <summary>
        /// DataToPersistReq permet de structurer le fichier de persistance des requins
        /// </summary>
        DataToPersistReq dataReq = new DataToPersistReq();
        /// <summary>
        /// DataToPersistUsers permet de structurer le fichier de persistance des utilisateurs
        /// </summary>
        DataToPersistUsers data = new DataToPersistUsers();
        /// <summary>
        /// List de String permet de strcturer le fichier de persistance des fun facts
        /// </summary>
        List<String> lesFunFacts = new List<String>();



        // Chemin des fichiers

        /// <summary>
        /// String le chemin des fichiers de persistance
        /// </summary>
        String FilePath { get; set; } = Path.Combine(Directory.GetCurrentDirectory(), "..//..//..//Persistance");



        // Noms des fichiers

        /// <summary>
        /// String le nom du fichier de persistance des requins
        /// </summary>
        String FileNameReq { get; set; }
            = "ficReqs";
        /// <summary>
        /// String le nom du fichier de persistance des utilisateurs
        /// </summary>
        String FileNameUsers { get; set; }
            = "ficUsers";
        /// <summary>
        /// String le nom du fichier de persistance des fun facts
        /// </summary>
        String FileNameFunFacts { get; set; }
            = "ficFunFacts";



        // Fichiers complets

        /// <summary>
        /// String le chemin complet du fichier de persistance des requins
        /// </summary>
        String FileReq => Path.Combine(FilePath, FileNameReq);
        /// <summary>
        /// String le chemin complet du fichier de persistance des utilisateurs
        /// </summary>
        String FileUsers => Path.Combine(FilePath, FileNameUsers);
        /// <summary>
        /// String le chemin compket du fichier de persistance des fun facts
        /// </summary>
        String FileFunFacts => Path.Combine(FilePath, FileNameFunFacts);



        // Settings

        /// <summary>
        /// XmlWriterSettings permet de rajouter des paramètres dans l'écriture des fichiers de persistance
        /// </summary>
        public XmlWriterSettings settings { get; set; }
            = new XmlWriterSettings() { Indent = true };



        // Méthodes pour les utilisateurs et experts

        /// <summary>
        /// Charge les utilisateurs des fichiers 
        /// </summary>
        /// <returns>Les List d'Utilisateur et d'Expert du fichier</returns>
        public (List<Utilisateur>, List<Expert>) LoadUsers()
        {
            if (!File.Exists(FileUsers))
            {
                throw new FileNotFoundException("The persistance file does not exist");
            }

            using (Stream stream = File.OpenRead(FileUsers))
            {
                data = SerializerUsers.ReadObject(stream) as DataToPersistUsers;
            }

            return (data.Users, data.Experts);
        }


        /// <summary>
        /// Sauvegarde les listes en paramètres dans le fichier des utilisateurs
        /// </summary>
        /// <param name="users"></param>
        /// <param name="experts"></param>
        public void SaveUsers(List<Utilisateur> users, List<Expert> experts)
        {
            if (!Directory.Exists(FilePath))
            {
                Directory.CreateDirectory(FileUsers);
            }
            data.Users.Clear();
            data.Experts.Clear();
            data.Users.AddRange(users);
            data.Experts.AddRange(experts);

            using (TextWriter tw = File.CreateText(Path.Combine(FilePath, FileNameUsers)))
            {
                using (XmlWriter writer = XmlWriter.Create(tw, settings))
                {
                    SerializerUsers.WriteObject(writer, data);
                }
            }
        }



        // Méthodes pour tous les requins

        /// <summary>
        /// Charge les listes des requins depuis les fichiers et les retourne
        /// </summary>
        /// <returns>Les List de Requin : ceux de l'application, ceux ajoutés par les utilisateurs, et ceux édités par les utilisateurs</returns>
        public (List<Requin>, List<Requin>, List<Requin>) LoadRequins()
        {
            if (!File.Exists(FileReq))
            {
                throw new FileNotFoundException("The persistance file does not exist");
            }

            using (Stream stream = File.OpenRead(FileReq))
            {
                dataReq = SerializerReq.ReadObject(stream) as DataToPersistReq;
            }

            return (dataReq.Requins, dataReq.RequinsAdd, dataReq.RequinsEdit);
        }



        /// <summary>
        /// Sauvegarde les listes de requins en paramètres dans le fichier de persistance pour les requins
        /// </summary>
        /// <param name="reqs"></param>
        /// <param name="reqsAdd"></param>
        /// <param name="reqsEdit"></param>
        public void SaveRequins(List<Requin> reqs, List<Requin> reqsAdd, List<Requin> reqsEdit)
        {
            if (!Directory.Exists(FilePath))
            {
                Directory.CreateDirectory(FilePath);
            }


            dataReq.Requins.Clear();
            dataReq.RequinsAdd.Clear();
            dataReq.RequinsEdit.Clear();
            dataReq.Requins.AddRange(reqs);
            dataReq.RequinsAdd.AddRange(reqsAdd);
            dataReq.RequinsEdit.AddRange(reqsEdit);

            using (TextWriter tw = File.CreateText(Path.Combine(FilePath, FileReq)))
            {
                using (XmlWriter writer = XmlWriter.Create(tw, settings))
                {
                    SerializerReq.WriteObject(writer, dataReq);
                }
            }
        }

        /// <summary>
        /// Charge les fun facts du fichier de persistance dans un liste et la retourne
        /// </summary>
        /// <returns>List de String avec les fun facts du fichier dedans</returns>
        public List<String> LoadFunFacts()
        {
            if (!File.Exists(FileFunFacts))
            {
                throw new FileNotFoundException("The persistance file does not exist");
            }

            using (Stream stream = File.OpenRead(FileFunFacts))
            {
                lesFunFacts = SerializerFun.ReadObject(stream) as List<String>;
            }

            return lesFunFacts;
        }


        /// <summary>
        /// Sauvegarde les fun facts de la liste en paramètre dans le fichier de persistance des fun facts
        /// </summary>
        /// <param name="funFacts"></param>
        public void SaveFunFacts(List<String> funFacts)
        {
            if (!Directory.Exists(FilePath))
            {
                Directory.CreateDirectory(FilePath);
            }

            lesFunFacts.Clear();
            lesFunFacts.AddRange(funFacts);

            using (TextWriter tw = File.CreateText(Path.Combine(FilePath, FileFunFacts)))
            {
                using (XmlWriter writer = XmlWriter.Create(tw, settings))
                {
                    SerializerFun.WriteObject(writer, lesFunFacts);
                }
            }
        }

    }
}