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

namespace Persistance
{
    public class DataContractPersistance : IPersistanceManager
    {

        // DataContractSerializer pour chaque type
        public DataContractSerializer SerializerReq { get; set; }
            = new DataContractSerializer(typeof(List<Requin>));
        public DataContractSerializer SerializerUsers { get; set; }
            = new DataContractSerializer(typeof(List<Personne>));




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




        // Noms des fichiers
        string FileNameReq { get; set; }
        string FileNameReqAdd { get; set; }
        string FileNameReqEdit { get; set; }
        string FileNameUsers { get; set; }




        // Fichiers complets
        string FileReq => Path.Combine(FilePath, FileNameReq);
        string FileReqAdd => Path.Combine(FilePath, FileNameReqAdd);
        string FileReqEdit => Path.Combine(FilePath, FileNameReqEdit);
        string FileUsers => Path.Combine(FilePath, FileNameUsers);




        // Listes des requins et utilisateurs
        List<Requin> requins = new List<Requin>();
        List<Requin> requinsAdd = new List<Requin>();
        List<Requin> requinEdit = new List<Requin>();
        List<Personne> users = new List<Personne>();




        // Méthodes pour les requins de l'application
        public List<Requin> LoadRequins()
        {
            if (File.Exists(FileReq))
            {
                throw new FileNotFoundException("The persisance file Persisitance does not exist");
            }

            using (Stream stream = File.OpenRead(FileReq))
            {
                requins = SerializerReq.ReadObject(stream) as List<Requin>;
            }

            return requins;
        }
        public void SaveRequins(List<Requin> reqs)
        {
            if (!Directory.Exists(FilePath))
            {
                Directory.CreateDirectory(FilePath);
            }

            using (Stream stream = File.Create(FileReq))
            {
                SerializerReq.WriteObject(stream, requins);
            }
        }




        // Méthodes pour les requins ajoutés par les Utilisateurs
        public List<Requin> LoadRequinsAdd()
        {
            throw new NotImplementedException();
        }

        public void SaveRequinsAdd(List<Requin> reqs)
        {
            throw new NotImplementedException();
        }




        // Méthodes pour les requins édités par les utilisateurs
        public List<Requin> LoadRequinsEdit()
        {
            throw new NotImplementedException();
        }

        public void SaveRequinsEdit(List<Requin> reqs)
        {
            throw new NotImplementedException();
        }




        // Méthodes pour les utilisateurs (Utilisateur et Manager)
        public List<Personne> LoadUsers()
        {
            throw new NotImplementedException();
        }

        public void SaveUsers(List<Personne> pers)
        {
            throw new NotImplementedException();
        }

    }
}