using System;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Xml.Serialization;
using ChadSoft;
using NUnit.Framework;

namespace Common.Tests
{
    [TestFixture]
    public class SerializerTests
    {
        private const string TEST_XML_STRING = @"Test <XML\> string serializatiN!\ \\";

        #region Serialize

        #region To XML

        #region File
        // TODO: Serialize string to File
        // TODO: Serialize DateTime to File
        #endregion

        #region String
        // TODO: Serialize null string to XML string
        // TODO: Serialize string to XML string
        // TODO: Serialize DateTime to XML string
        #endregion

        #region Stream
        [Test]
        public void SerializeNullStringToXMLStream()
        {
            string expectedValue = null,
                actualValue;

            using (MemoryStream stream = new MemoryStream())
            {
                // Serialize to the stream
                Serializer.Serialize(SerializationMethod.XML, expectedValue, stream);
                stream.Seek(0, SeekOrigin.Begin);

                // Now try to deserialize it using an Xml Serializer
                XmlSerializer serializer = new XmlSerializer(typeof(string));
                actualValue = serializer.Deserialize(stream) as string;
            }

            Assert.AreEqual(expectedValue, actualValue);
        }
        [Test]
        public void SerializeStringToXMLStream()
        {
            string expectedValue = TEST_XML_STRING,
                actualValue;

            using (MemoryStream stream = new MemoryStream())
            {
                // Serialize to the stream
                Serializer.Serialize(SerializationMethod.XML, expectedValue, stream);
                stream.Seek(0, SeekOrigin.Begin);

                // Now try to deserialize it using an Xml Serializer
                XmlSerializer serializer = new XmlSerializer(typeof(string));
                actualValue = serializer.Deserialize(stream) as string;
            }

            Assert.AreEqual(expectedValue, actualValue);
        }

        [Test]
        public void SerializeDateTimeToXMLStream()
        {
            DateTime expectedValue = DateTime.Now,
                actualValue;

            using (MemoryStream stream = new MemoryStream())
            {
                // Serialize to the stream
                Serializer.Serialize(SerializationMethod.XML, expectedValue, stream);
                stream.Seek(0, SeekOrigin.Begin);

                // Now try to deserialize it using an Xml Serializer
                XmlSerializer serializer = new XmlSerializer(typeof(DateTime));
                actualValue = (DateTime)serializer.Deserialize(stream);
            }

            Assert.AreEqual(expectedValue, actualValue);
        }
        #endregion

        #endregion

        #region To Binary
        [Test]
        [ExpectedException(typeof(ArgumentNullException))]
        public void SerializeNullStringToBinaryStream()
        {
            using (MemoryStream stream = new MemoryStream())
            {
                // Serialize to the stream
                Serializer.Serialize<String>(SerializationMethod.Binary, null, stream);
            }
        }
        [Test]
        public void SerializeStringToBinaryStream()
        {
            string expectedValue = @"Test <XML\> string serializatiN!\ \\",
                actualValue;

            using (MemoryStream stream = new MemoryStream())
            {
                // Serialize to the stream
                Serializer.Serialize(SerializationMethod.Binary, expectedValue, stream);
                stream.Seek(0, SeekOrigin.Begin);

                // Now try to deserialize it using an Xml Serializer
                BinaryFormatter serializer = new BinaryFormatter();
                actualValue = serializer.Deserialize(stream) as string;
            }

            Assert.AreEqual(expectedValue, actualValue);
        }

        [Test]
        public void SerializeDateTimeToBinaryStream()
        {
            DateTime expectedValue = DateTime.Now,
                actualValue;

            using (MemoryStream stream = new MemoryStream())
            {
                // Serialize to the stream
                Serializer.Serialize(SerializationMethod.Binary, expectedValue, stream);
                stream.Seek(0, SeekOrigin.Begin);

                // Now try to deserialize it using an Xml Serializer
                BinaryFormatter serializer = new BinaryFormatter();
                actualValue = (DateTime)serializer.Deserialize(stream);
            }

            Assert.AreEqual(expectedValue, actualValue);
        }
        #endregion

        #endregion

        #region Deserialize

        // TODO: Deserialize null string from XML file
        // TODO: Deserialize string from XML file
        // TODO: Deserialize DateTime from XML file

        #region From String
//        [Test]
//        public void DeserializeFromNullXmlString()
//        {
//            // TODO: Deserialize null XML string
//        }
        [Test]
        public void DeserializeToStringFromXmlString()
        {
            string expectedValue = TEST_XML_STRING,
                actualValue;

            // Serialize the test string to pass in
            StringBuilder builder = new StringBuilder();
            TextWriter writer = new StringWriter(builder);
            XmlSerializer serializer = new XmlSerializer(typeof(string));
            serializer.Serialize(writer, TEST_XML_STRING);

            actualValue = Serializer.Deserialize<String>(
                SerializationMethod.XML, 
                builder.ToString());
            
            Assert.AreEqual(expectedValue, actualValue);
        }

        // TODO: Deserialize DateTime from XML string
        #endregion

        // TODO: Deserialize DateTime from XML stream
        // TODO: Deserialize null string from XML stream
        // TODO: Deserialize string from XML stream
        
        // TODO: Deserialize null string from Binary file
        // TODO: Deserialize string from Binary file
        // TODO: Deserialize DateTime from Binary file

        // TODO: Deserialize null string from Binary stream
        // TODO: Deserialize string from Binary stream
        // TODO: Deserialize DateTime from Binary stream

        #endregion

    }
}