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
{
    public class DataContractPersistance : IPersistanceManager
    {

        // Serializers pour requins et utlisateurs/experts
        DataContractSerializer SerializerReq { get; set; }
            = new DataContractSerializer(typeof(DataToPersistReq));
        DataContractSerializer SerializerUsers { get; set; }
            = new DataContractSerializer(typeof(DataToPersistUsers));
        DataContractSerializer SerializerFun { get; set; }
            = new DataContractSerializer(typeof(List<String>));




        // DataToPersistReq et DataToPersistUsers
        DataToPersistReq dataReq = new DataToPersistReq();
        DataToPersistUsers data = new DataToPersistUsers();
        List<String> lesFunFacts = new List<String>();



        // Chemin des fichiers
        String FilePath { get; set; } = Path.Combine(Directory.GetCurrentDirectory(), "..//..//..//Persistance");



        // Noms des fichiers
        String FileNameReq { get; set; }
            = "ficReqs";
        String FileNameUsers { get; set; }
            = "ficUsers";
        String FileNameFunFacts { get; set; }
            = "ficFunFacts";



        // Fichiers complets
        String FileReq => Path.Combine(FilePath, FileNameReq);
        String FileUsers => Path.Combine(FilePath, FileNameUsers);
        String FileFunFacts => Path.Combine(FilePath, FileNameFunFacts);



        // Settings
        public XmlWriterSettings settings { get; set; }
            = new XmlWriterSettings() { Indent = true };



        // Méthodes pour les utilisateurs et experts
        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);
        }



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



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


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



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

    }
}