using System;
using System.IO;
using System.Reflection;
using System.Text;
using System.Xml;

namespace Framework.Storage {

  /// <summary>Very simple XML serializer that outputs only basic XML</summary>
  public static class SimpleXmlSerializer {

    /// <summary>Loads the state of an object from a file</summary>
    /// <typeparam name="T">Type of object that will be loaded</typeparam>
    /// <param name="instance">Instance into which the state will be loaded</param>
    /// <param name="path">File from which the state will be loaded</param>
    public static void Load<T>(T instance, string path) {
      Load(instance, path, typeof(T).Name);
    }

    /// <summary>Loads the state of an object from a file</summary>
    /// <typeparam name="T">Type of object that will be loaded</typeparam>
    /// <param name="instance">Instance into which the state will be loaded</param>
    /// <param name="path">File from which the state will be loaded</param>
    /// <param name="rootElementName">Expected name of the root element</param>
    public static void Load<T>(T instance, string path, string rootElementName) {
      using(XmlReader reader = XmlReader.Create(path, ReaderSettings)) {
        readRootInstance(instance, reader, rootElementName);
      }
    }

    /// <summary>Loads the state of an object from a file</summary>
    /// <typeparam name="T">Type of object that will be loaded</typeparam>
    /// <param name="instance">Instance into which the state will be loaded</param>
    /// <param name="stream">Stream from which the state will be loaded</param>
    public static void Load<T>(T instance, Stream stream) {
      Load(instance, stream, typeof(T).Name);
    }

    /// <summary>Loads the state of an object from a file</summary>
    /// <typeparam name="T">Type of object that will be loaded</typeparam>
    /// <param name="instance">Instance into which the state will be loaded</param>
    /// <param name="stream">Stream from which the state will be loaded</param>
    /// <param name="rootElementName">Expected name of the root element</param>
    public static void Load<T>(T instance, Stream stream, string rootElementName) {
      XmlReader reader = XmlReader.Create(stream);
      readRootInstance(instance, reader, rootElementName);
    }

    /// <summary>Saves the state of an object into a file</summary>
    /// <typeparam name="T">Type of object that will be saved</typeparam>
    /// <param name="instance">Instance whose state will be saved</param>
    /// <param name="path">File into which the state will be saved</param>
    public static void Save<T>(T instance, string path) {
      Save(instance, path, typeof(T).Name);
    }

    /// <summary>Saves the state of an object into a file</summary>
    /// <typeparam name="T">Type of object that will be saved</typeparam>
    /// <param name="instance">Instance whose state will be saved</param>
    /// <param name="path">File into which the state will be saved</param>
    /// <param name="rootElementName">Name that will be given to the root element</param>
    public static void Save<T>(T instance, string path, string rootElementName) {
      using(XmlWriter writer = XmlWriter.Create(path, WriterSettings)) {
        writer.WriteStartDocument();

        writeRootInstance(instance, writer, rootElementName);

        writer.WriteEndDocument();
        writer.Flush();
      }
    }

    /// <summary>Saves the state of an object into a file</summary>
    /// <typeparam name="T">Type of object that will be saved</typeparam>
    /// <param name="instance">Instance whose state will be saved</param>
    /// <param name="stream">Stream into which the state will be saved</param>
    public static void Save<T>(T instance, Stream stream) {
      Save(instance, stream, typeof(T).Name);
    }

    /// <summary>Saves the state of an object into a file</summary>
    /// <typeparam name="T">Type of object that will be saved</typeparam>
    /// <param name="instance">Instance whose state will be saved</param>
    /// <param name="stream">Stream into which the state will be saved</param>
    /// <param name="rootElementName">Name that will be given to the root element</param>
    public static void Save<T>(T instance, Stream stream, string rootElementName) {
      XmlWriter writer = XmlWriter.Create(stream, WriterSettings);
      writer.WriteStartDocument();

      writeRootInstance(instance, writer, rootElementName);

      writer.WriteEndDocument();
      writer.Flush();
    }

    /// <summary>Loads the root object from an XML document</summary>
    /// <typeparam name="T">Type of root object that will be loaded</typeparam>
    /// <param name="instance">Instance into which the state will be loaded</param>
    /// <param name="reader">Reader from which the state will be loaded</param>
    /// <param name="rootElementName">Expected name of the root element</param>
    private static void readRootInstance<T>(
      T instance, XmlReader reader, string rootElementName
    ) {
      XmlNodeType nodeType = reader.MoveToContent();
      if(nodeType != XmlNodeType.Element) {
        throw new XmlException("XML document does not start with an element");
      }

      // Whoever designed the XmlReader should a) look up 'consistency' on Wikipedia
      // and b) cut down on psychedelic drugs or whatever else guides his thoughts.
      if(reader.Name != rootElementName) {
        throw new XmlException("XML document contains the wrong type of object");
      }

      readFields(instance, reader);
    }

    /// <summary>Writes the root object into an XML document</summary>
    /// <typeparam name="T">Type of root object that will be written</typeparam>
    /// <param name="instance">Instance whose state will be saved</param>
    /// <param name="writer">Writer into which the state will be written</param>
    /// <param name="rootElementName">Name that will be given to the root element</param>
    private static void writeRootInstance<T>(
      T instance, XmlWriter writer, string rootElementName
    ) {
      writer.WriteStartElement(rootElementName);
      writeFields(instance, writer);
      writer.WriteEndElement();
    }

    /// <summary>Recursively reads the fields of an object from an XML document</summary>
    /// <param name="instance">Instance into which the fields will be loaded</param>
    /// <param name="reader">Reader from which the fields will be loaded</param>
    private static void readFields(object instance, XmlReader reader) {
      Type instanceType = instance.GetType();
      FieldInfo[] fieldInfos = instanceType.GetFields(
        BindingFlags.Public | BindingFlags.Instance
      );

      while(reader.Read()) {
        if(reader.IsStartElement()) {
          FieldInfo fieldInfo = getFieldInfoByName(fieldInfos, reader.Name);
          if(fieldInfo == null) {
            throw new XmlException(
              "Element '" + reader.Name + "' on '" + instance.GetType().Name + "' not recognized"
            );
          }
          if(fieldInfo.FieldType == typeof(TimeSpan)) {
            string valueAsString = reader.ReadString();
            fieldInfo.SetValue(instance, XmlConvert.ToTimeSpan(valueAsString));
          } else if(isSimpleType(fieldInfo.FieldType)) {
            object valueAsObject = reader.ReadElementContentAs(fieldInfo.FieldType, null);
            fieldInfo.SetValue(instance, valueAsObject);
          } else {
            object valueAsObject = fieldInfo.GetValue(instance);
            readFields(valueAsObject, reader);
            fieldInfo.SetValue(instance, valueAsObject);
          }
        } else {
          break;
        }
      }
    }

    /// <summary>Looks up a field info by its name</summary>
    /// <param name="fieldInfos">Field infos in which to search</param>
    /// <param name="name">Name that will be searched for</param>
    /// <returns>The field info with the specified name or null if not found</returns>
    private static FieldInfo getFieldInfoByName(FieldInfo[] fieldInfos, string name) {
      for(int index = 0; index < fieldInfos.Length; ++index) {
        if(fieldInfos[index].Name == name) {
          return fieldInfos[index];
        }
      }

      return null;
    }

    /// <summary>Recursively saves the fields of an object into an XML writer</summary>
    /// <param name="instance">Object whose fields will be saved</param>
    /// <param name="writer">XML writer into which the fields will be saved</param>
    private static void writeFields(object instance, XmlWriter writer) {
      Type instanceType = instance.GetType();
      FieldInfo[] fieldInfos = instanceType.GetFields(
        BindingFlags.Public | BindingFlags.Instance
      );

      // Save simple fields	first so they're easier to associate with the header
      for(int index = 0; index < fieldInfos.Length; ++index) {
        FieldInfo fieldInfo = fieldInfos[index];

        if(isSimpleType(fieldInfo.FieldType)) {
          writer.WriteStartElement(fieldInfo.Name);
          object value = fieldInfo.GetValue(instance);
          if((value != null) && !value.Equals(string.Empty)) {
            writer.WriteValue(fieldInfo.GetValue(instance));
          }
          writer.WriteEndElement();
        }
      }

      // Write complex fields after the simple ones
      for(int index = 0; index < fieldInfos.Length; ++index) {
        FieldInfo fieldInfo = fieldInfos[index];

        if(!isSimpleType(fieldInfo.FieldType)) {
          writer.WriteStartElement(fieldInfo.Name);
          writeFields(fieldInfo.GetValue(instance), writer);
          writer.WriteEndElement();
        }
      }
    }

    /// <summary>Determines whether a type is simple (i.e. not a complex type)</summary>
    /// <param name="type">Type that will be checked</param>
    /// <returns>True if the type is a simple type</returns>
    /// <remarks>
    ///   Complex types are usually understood to be types consisting of other types.
    ///   Thus we labelled non-complex types "simple types," which are all of .NET's
    ///   primitive types plus strings.
    /// </remarks>
    private static bool isSimpleType(Type type) {
      return
        type.IsPrimitive ||
        (type == typeof(string)) ||
        (type == typeof(DateTime)) ||
        (type == typeof(TimeSpan));
    }

    /// <summary>Default settings for the XML reader</summary>
    private static XmlReaderSettings ReaderSettings {
      get {
        return new XmlReaderSettings() {
          IgnoreComments = true,
          CloseInput = true
        };
      }
    }

    /// <summary>Default settings for the XML writer</summary>
    private static XmlWriterSettings WriterSettings {
      get {
        return new XmlWriterSettings() {
          Encoding = Encoding.UTF8,
          Indent = true,
          NewLineOnAttributes = true,
          NewLineHandling = NewLineHandling.Replace,
          CloseOutput = true
        };
      }
    }

  }

} // namespace Framework.Storage