using System.IO;
using System.Reflection;
using System.Xml;
using System.Xml.Serialization;
using Developpez.Dotnet.Xml.Serialization;
using NUnit.Framework;

namespace Developpez.Dotnet.Tests.Xml.Serialization
{
    [TestFixture]
    public class XmlSerializationExtensionsTests
    {
        public class Person
        {
            public string FirstName { get; set; }
            public string LastName { get; set; }
        }

        [Test]
        public void Test_ToXml()
        {
            Person person = GetPerson();
            
            XmlSerializer xs = new XmlSerializer(typeof(Person));
            string expected;
            using (StringWriter wr = new StringWriter())
            {
                xs.Serialize(wr, person);
                expected = wr.ToString();
            }

            string actual = person.ToXml();
            Assert.AreEqual(expected, actual);

            XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
            ns.Add("", "");
            using (StringWriter wr = new StringWriter())
            {
                xs.Serialize(wr, person, ns);
                expected = wr.ToString();
            }
            actual = person.ToXml(ns);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void Test_ParseXml()
        {
            Person expected = GetPerson();

            XmlSerializer xs = new XmlSerializer(typeof(Person));
            string xml;
            using (StringWriter wr = new StringWriter())
            {
                xs.Serialize(wr, expected);
                xml = wr.ToString();
            }

            Person actual = xml.ParseXml<Person>();
            Assert.AreEqual(expected.FirstName, actual.FirstName);
            Assert.AreEqual(expected.LastName, actual.LastName);
        }

        [Test]
        public void Test_Write_Read_Xml_Path()
        {
            Person expected = GetPerson();
            string path = MethodBase.GetCurrentMethod().Name + ".xml";
            expected.WriteXml(path);
            Person actual = path.ReadXml<Person>();
            Assert.AreEqual(expected.FirstName, actual.FirstName);
            Assert.AreEqual(expected.LastName, actual.LastName);
        }

        [Test]
        public void Test_Write_Read_Xml_Stream()
        {
            Person expected = GetPerson();
            string path = MethodBase.GetCurrentMethod().Name + ".xml";
            using (Stream stream = File.OpenWrite(path))
            {
                expected.WriteXml(stream);
            }
            using (Stream stream = File.OpenRead(path))
            {
                Person actual = stream.ReadXml<Person>();
                Assert.AreEqual(expected.FirstName, actual.FirstName);
                Assert.AreEqual(expected.LastName, actual.LastName);
            }
        }

        [Test]
        public void Test_Write_Read_Xml_TextWriterReader()
        {
            Person expected = GetPerson();
            string path = MethodBase.GetCurrentMethod().Name + ".xml";
            using (StreamWriter writer = new StreamWriter(path))
            {
                expected.WriteXml(writer);
            }

            using (StreamReader reader = new StreamReader(path))
            {
                Person actual = reader.ReadXml<Person>();
                Assert.AreEqual(expected.FirstName, actual.FirstName);
                Assert.AreEqual(expected.LastName, actual.LastName);
            }
        }

        [Test]
        public void Test_Write_Read_Xml_XmlWriterReader()
        {
            Person expected = GetPerson();
            string path = MethodBase.GetCurrentMethod().Name + ".xml";
            using (XmlWriter writer = XmlWriter.Create(path))
            {
                expected.WriteXml(writer);
            }

            using (XmlReader reader = XmlReader.Create(path))
            {
                Person actual = reader.ReadXml<Person>();
                Assert.AreEqual(expected.FirstName, actual.FirstName);
                Assert.AreEqual(expected.LastName, actual.LastName);
            }
        }

        [Test]
        public void Test_Write_Read_Xml_XmlWriterReader_WithEvents()
        {
            Person expected = GetPerson();
            string path = MethodBase.GetCurrentMethod().Name + ".xml";
            using (XmlWriter writer = XmlWriter.Create(path))
            {
                expected.WriteXml(writer);
            }

            using (XmlReader reader = XmlReader.Create(path))
            {
                XmlDeserializationEvents events = new XmlDeserializationEvents();
                Person actual = reader.ReadXml<Person>(events);
                Assert.AreEqual(expected.FirstName, actual.FirstName);
                Assert.AreEqual(expected.LastName, actual.LastName);
            }
        }

        private static Person GetPerson()
        {
            Person person = new Person
            {
                FirstName = "Georges",
                LastName = "Abitbol"
            };
            return person;
        }
    }
}