using Model.Classes;
using Model.Serializer;
using Model.Stub;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Serialization;

namespace TestProject1
{
    public class XMLSerializerTests
    {
        public XML_Serializer serializer = new XML_Serializer();
        private string TestFolderPath = Directory.GetCurrentDirectory();
        [Fact]
        public void InitialiserFichiers_FileDoesNotExist_SetPersonnageIfStubManagerReturnsNonNull()
        {
            // Arrange
            var serializer = new XML_Serializer(TestFolderPath);
            var stubManager = new StubManager();
            var expectedPersonnages = stubManager.GetPersonnages();
            var expectedBateaux = stubManager.GetBateaux();
            var expectedFruits = stubManager.GetFruits();
            var expectedBestiaires= stubManager.GetBestiaires();
            var expectedEquipages=stubManager.GetEquipages();
            var expectedIles = stubManager.GetIles();

            // Act
            serializer.InitialiserFichiers(stubManager);

            // Assert
            if (!File.Exists(Path.Combine(TestFolderPath, "./personnage.xml")))
            {
                if (expectedPersonnages != null)
                {
                    Assert.True(expectedPersonnages.ToList()== serializer.GetPersonnages());
                }
            }

            if (!File.Exists(Path.Combine(TestFolderPath, "./bateau.xml")))
            {
                if (expectedBateaux != null)
                {
                    Assert.True(expectedBateaux.ToList() == serializer.GetBateaux());
                }
            }

            if (!File.Exists(Path.Combine(TestFolderPath, "./fruitdudemon.xml")))
            {
                if (expectedFruits != null)
                {
                    Assert.True(expectedFruits.ToList() == serializer.GetFruits());
                }
            }

            if (!File.Exists(Path.Combine(TestFolderPath, "./equipage.xml")))
            {
                if (expectedEquipages != null)
                {
                    Assert.True(expectedEquipages.ToList() == serializer.GetEquipages());
                }
            }

            if (!File.Exists(Path.Combine(TestFolderPath, "./ile.xml")))
            {
                if (expectedIles != null)
                {
                    Assert.True(expectedIles.ToList() == serializer.GetIles());
                }
            }
        }
        [Fact]
        public void SetPersonnage_SerializesAndWritesToFile()
        {
            var obj1 = new Personnage("Personnage 1", 0, "", 0, 0, "", "", "");
            var obj2 = new Personnage("Personnage 2", 0, "", 0, 0, "", "", "");
            var listePerso = new List<Personnage>
            {
              obj1,
              obj2,      
            };

            serializer.SetPersonnage(listePerso);

            string xmlFilePath = Path.Combine(serializer.Chemin, "personnage.xml");
            Assert.True(File.Exists(xmlFilePath));

            using (Stream stream = File.OpenRead(xmlFilePath))
            {
                var deserializer = new DataContractSerializer(typeof(List<Personnage>));
                var result = deserializer.ReadObject(stream) as List<Personnage>;

                
                Assert.NotNull(result);
                Assert.Contains(obj1,result);
                Assert.Contains(obj2,result);
            }
        }

        [Fact]
        public void GetPersonnages_ReadsFromFileAndDeserializes()
        {
            var obj1 = new Personnage("Personnage 1", 0, "", 0, 0, "", "", "");
            var obj2 = new Personnage("Personnage 2", 0, "", 0, 0, "", "", "");
            var listePerso = new List<Personnage>
            {
              obj1,
              obj2,
            };
            string xmlFilePath = Path.Combine(serializer.Chemin, "personnage.xml");
            using (Stream stream = File.Create(xmlFilePath))
            {
                var xmlSerializer = new DataContractSerializer(typeof(List<Personnage>));
                xmlSerializer.WriteObject(stream, listePerso);
            }

            var result = serializer.GetPersonnages();

            Assert.NotNull(result);
            var resultList = result.ToList();
            Assert.Contains(obj1, result);
            Assert.Contains(obj2, result);
        }


        [Fact]
        public void SetEquipages_SerializesAndWritesToFile()
        {
            var obj1 = new Equipage("Equipage 1", "","", 0, 0,true, "");
            var obj2 = new Equipage("Equipage 2", "", "", 0, 0, true, "");
            var listeEquip = new List<Equipage>
            {
              obj1,
              obj2,
            };

            serializer.SetEquipage(listeEquip);
            string xmlFilePath = Path.Combine(serializer.Chemin, "equipage.xml");

            Assert.True(File.Exists(xmlFilePath));

            using (Stream stream = File.OpenRead(xmlFilePath))
            {
                var deserializer = new DataContractSerializer(typeof(List<Equipage>));
                var result = deserializer.ReadObject(stream) as List<Equipage>;


                Assert.NotNull(result);
                Assert.Contains(obj1, result);
                Assert.Contains(obj2, result);
            }
        }

        [Fact]
        public void GetEquipages_ReadsFromFileAndDeserializes()
        {
            var obj1 = new Equipage("Equipage 1", "", "", 0, 0, true, "");
            var obj2 = new Equipage("Equipage 2", "", "", 0, 0, true, "");
            var listeEquip = new List<Equipage>
            {
              obj1,
              obj2,
            };
            string xmlFilePath = Path.Combine(serializer.Chemin, "equipage.xml");
            using (Stream stream = File.Create(xmlFilePath))
            {
                var xmlSerializer = new DataContractSerializer(typeof(List<Equipage>));
                xmlSerializer.WriteObject(stream, listeEquip);
            }

            // Act
            var result = serializer.GetEquipages();

            // Assert
            Assert.NotNull(result);
            var resultList = result.ToList();
            Assert.Contains(obj1, result);
            Assert.Contains(obj2, result);
        }

        [Fact]
        public void SetFDD_SerializesAndWritesToFile()
        {
            /// Arrange
            var obj1 = new FruitDuDemon("Fruit 1", "","", 0, 0, "", "", "");
            var obj2 = new FruitDuDemon("Fruit 2", "", "", 0, 0, "", "", "");
            var listFDD = new List<FruitDuDemon>
            {
              obj1,
              obj2,
            };

            // Act
            serializer.SetFDD(listFDD);

            // Assert
            string xmlFilePath = Path.Combine(serializer.Chemin, "fruitdudemon.xml");
            Assert.True(File.Exists(xmlFilePath));

            using (Stream stream = File.OpenRead(xmlFilePath))
            {
                var deserializer = new DataContractSerializer(typeof(List<FruitDuDemon>));
                var result = deserializer.ReadObject(stream) as List<FruitDuDemon>;


                Assert.NotNull(result);
                Assert.Contains(obj1, result);
                Assert.Contains(obj2, result);
            }
        }

        [Fact]
        public void GetFDD_ReadsFromFileAndDeserializes()
        {
            var obj1 = new FruitDuDemon("Fruit 1", "", "", 0, 0, "", "", "");
            var obj2 = new FruitDuDemon("Fruit 2", "", "", 0, 0, "", "", "");
            var listFDD = new List<FruitDuDemon>
            {
              obj1,
              obj2,
            };
            string xmlFilePath = Path.Combine(serializer.Chemin, "fruitdudemon.xml");
            using (Stream stream = File.Create(xmlFilePath))
            {
                var xmlSerializer = new DataContractSerializer(typeof(List<FruitDuDemon>));
                xmlSerializer.WriteObject(stream, listFDD);
            }

            // Act
            var result = serializer.GetFruits();

            // Assert
            Assert.NotNull(result);
            var resultList = result.ToList();
            Assert.Contains(obj1, result);
            Assert.Contains(obj2, result);
        }

        [Fact]
        public void SetBestiaire_SerializesAndWritesToFile()
        {
            /// Arrange
            var obj1 = new Bestiaire("Bestiaire 1", "", "", "");
            var obj2 = new Bestiaire("Bestiaire 2", "", "", "");
            var listBest = new List<Bestiaire>
            {
              obj1,
              obj2,
            };

            // Act
            serializer.SetBestiaire(listBest);

            // Assert
            string xmlFilePath = Path.Combine(serializer.Chemin, "bestiaire.xml");
            Assert.True(File.Exists(xmlFilePath));

            using (Stream stream = File.OpenRead(xmlFilePath))
            {
                var deserializer = new DataContractSerializer(typeof(List<Bestiaire>));
                var result = deserializer.ReadObject(stream) as List<Bestiaire>;


                Assert.NotNull(result);
                Assert.Contains(obj1, result);
                Assert.Contains(obj2, result);
            }
        }

        [Fact]
        public void GetBestiaire_ReadsFromFileAndDeserializes()
        {
            // Arrange
            var obj1 = new Bestiaire("Bestiaire 1", "", "", "");
            var obj2 = new Bestiaire("Bestiaire 2", "", "", "");
            var listBest = new List<Bestiaire>
            {
              obj1,
              obj2,
            };
            string xmlFilePath = Path.Combine(serializer.Chemin, "bestiaire.xml");
            using (Stream stream = File.Create(xmlFilePath))
            {
                var xmlSerializer = new DataContractSerializer(typeof(List<Bestiaire>));
                xmlSerializer.WriteObject(stream, listBest);
            }

            // Act
            var result = serializer.GetBestiaires();

            // Assert
            Assert.NotNull(result);
            var resultList = result.ToList();
            Assert.Contains(obj1, result);
            Assert.Contains(obj2, result);
        }

        [Fact]
        public void SetBateau_SerializesAndWritesToFile()
        {
            var obj1 = new Bateau("Bateau 1", "", 0, 0, "", "", "");
            var obj2 = new Bateau("Bateau 2", "", 0, 0, "", "", "");
            var listeBateau = new List<Bateau>
            {
              obj1,
              obj2,
            };

            serializer.SetBateau(listeBateau);

            string xmlFilePath = Path.Combine(serializer.Chemin, "bateau.xml");
            Assert.True(File.Exists(xmlFilePath));

            using (Stream stream = File.OpenRead(xmlFilePath))
            {
                var deserializer = new DataContractSerializer(typeof(List<Bateau>));
                var result = deserializer.ReadObject(stream) as List<Bateau>;


                Assert.NotNull(result);
                Assert.Contains(obj1, result);
                Assert.Contains(obj2, result);
            }
        }

        [Fact]
        public void GetBateau_ReadsFromFileAndDeserializes()
        {
            var obj1 = new Bateau("Bateau 1", "", 0, 0, "", "", "");
            var obj2 = new Bateau("Bateau 2", "", 0, 0, "", "", "");
            var listeBateau = new List<Bateau>
            {
              obj1,
              obj2,
            };
            string xmlFilePath = Path.Combine(serializer.Chemin, "bateau.xml");
            using (Stream stream = File.Create(xmlFilePath))
            {
                var xmlSerializer = new DataContractSerializer(typeof(List<Bateau>));
                xmlSerializer.WriteObject(stream, listeBateau);
            }

            var result = serializer.GetBateaux();

            Assert.NotNull(result);
            var resultList = result.ToList();
            Assert.Contains(obj1, result);
            Assert.Contains(obj2, result);
        }

        [Fact]
        public void SetIle_SerializesAndWritesToFile()
        {
            var obj1 = new Ile("Ile 1", "","", 0, 0, "", "");
            var obj2 = new Ile("Ile 2", "", "",0, 0, "", ""); 
            var listeIle = new List<Ile>
            {
              obj1,
              obj2,
            };

            serializer.SetIle(listeIle);

            string xmlFilePath = Path.Combine(serializer.Chemin, "ile.xml");
            Assert.True(File.Exists(xmlFilePath));

            using (Stream stream = File.OpenRead(xmlFilePath))
            {
                var deserializer = new DataContractSerializer(typeof(List<Ile>));
                var result = deserializer.ReadObject(stream) as List<Ile>;


                Assert.NotNull(result);
                Assert.Contains(obj1, result);
                Assert.Contains(obj2, result);
            }
        }

        [Fact]
        public void GetIle_ReadsFromFileAndDeserializes()
        {
            var obj1 = new Ile("Ile 1", "", "", 0, 0, "", "");
            var obj2 = new Ile("Ile 2", "", "", 0, 0, "", "");
            var listeIle = new List<Ile>
            {
              obj1,
              obj2,
            };
            string xmlFilePath = Path.Combine(serializer.Chemin, "ile.xml");
            using (Stream stream = File.Create(xmlFilePath))
            {
                var xmlSerializer = new DataContractSerializer(typeof(List<Ile>));
                xmlSerializer.WriteObject(stream, listeIle);
            }

            var result = serializer.GetIles();

            Assert.NotNull(result);
            var resultList = result.ToList();
            Assert.Contains(obj1, result);
            Assert.Contains(obj2, result);
        }
    }
}