using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Xml;

using UnityEngine;

namespace Framework.Input {

  /// <summary>Saves input mappings into streams and restores them again</summary>
  public class XmlSaver {

    /// <summary>Name of the root element in the saved input mappings</summary>
    private const string RootElementName = "InputMappings";

    /// <summary>Loads input mappings from a stream</summary>
    /// <param name="inputMapper">Input mapper the mappings will be restored to</param>
    /// <param name="stream">Stream the mappings will be loaded from</param>
    public static void Load(InputMapper inputMapper, Stream stream) {
      XmlReader reader = XmlReader.Create(stream, ReaderSettings);

      XmlNodeType nodeType = reader.MoveToContent();
      if(nodeType != XmlNodeType.Element) {
        throw new XmlException("XML document does not start with an element");
      }

      ReadRootInstance(inputMapper, reader);
    }

    /// <summary>Loads input mappings from a stream</summary>
    /// <param name="inputMapper">Input mapper the mappings will be restored to</param>
    /// <param name="path">Path of a file from which the input mappings will be loaded</param>
    public static void Load(InputMapper inputMapper, string path) {
      using(XmlReader reader = XmlReader.Create(path, ReaderSettings)) {
        XmlNodeType nodeType = reader.MoveToContent();
        if(nodeType != XmlNodeType.Element) {
          throw new XmlException("XML document does not start with an element");
        }

        ReadRootInstance(inputMapper, reader);
      }
    }

    /// <summary>Saves the input mappings into a stream</summary>
    /// <param name="inputMapper">Input mapper whose mappings will be saved</param>
    /// <param name="stream">Stream into which the input mappings that will be saved</param>
    public static void Save(InputMapper inputMapper, Stream stream) {
      XmlWriter writer = XmlWriter.Create(stream, WriterSettings);
      WriteRootInstance(inputMapper, writer);
      writer.Flush();
    }

    /// <summary>Saves the input mappings into a stream</summary>
    /// <param name="inputMapper">Input mapper whose mappings will be saved</param>
    /// <param name="path">Path of a file the input mappings will be saved to</param>
    public static void Save(InputMapper inputMapper, string path) {
      using(XmlWriter writer = XmlWriter.Create(path, WriterSettings)) {
        WriteRootInstance(inputMapper, writer);
        writer.Flush();
      }
    }

    /// <summary>Loads the input mapping from an XML document</summary>
    /// <param name="inputMapper">Input mapper whose bindings will be loaded</param>
    /// <param name="reader">Reader from which the bindings will be loaded</param>
    public static void ReadRootInstance(InputMapper inputMapper, XmlReader reader) {

      // 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");
      }

      readActions(inputMapper, reader);

    }

    /// <summary>Writes the input mapping into an XML document</summary>
    /// <param name="inputMapper">Input mapper whose bindings will be saved</param>
    /// <param name="writer">Writer into which the bindings will be saved</param>
    public static void WriteRootInstance(InputMapper inputMapper, XmlWriter writer) {
      writer.WriteStartElement(RootElementName);
      writeActions(inputMapper, writer);
      writer.WriteEndElement();
    }

    /// <summary>Reads the actions layers of an input mapper from an XML reader</summary>
    /// <param name="inputMapper">Input mapper whose actions will be read</param>
    /// <param name="reader">XML reader the actions will be read from</param>
    private static void readActions(InputMapper inputMapper, XmlReader reader) {
      IList<IAction> loadedActions = new List<IAction>();

      while(reader.Read()) {
        if(reader.IsStartElement()) {
          if(reader.Name == "Action") {
            string nameString = reader.GetAttribute("Name");
            string descriptionString = reader.GetAttribute("Description");

            if(string.IsNullOrEmpty(nameString)) {
              throw new XmlException("Actions needs to provide a Name attribute");
            }

            IAction action = inputMapper.CreateAction(nameString, descriptionString);
            action.RemoveAllBindings(); // In case the action already existed
            readBindings(action, reader);
            loadedActions.Add(action);
          } else {
            throw new XmlException("Only Actions may appear in the input mappings");
          }
        } else {
          break;
        }
      }

      // Remove all actions that weren't loaded
      for(int index = 0; index < inputMapper.Actions.Count;) {
        if(loadedActions.Contains(inputMapper.Actions[index])) {
          ++index;
        } else {
          inputMapper.Actions.Remove(inputMapper.Actions[index]);
        }
      }
    }

    /// <summary>Writes the actions of an input mapper into an XML writer</summary>
    /// <param name="inputMapper">Input mapper whose actions will be written</param>
    /// <param name="writer">XML writer the actions will be written into</param>
    private static void writeActions(InputMapper inputMapper, XmlWriter writer) {
      for(int actionIndex = 0; actionIndex < inputMapper.Actions.Count; ++actionIndex) {
        IAction action = inputMapper.Actions[actionIndex];

        writer.WriteStartElement("Action");
        writer.WriteAttributeString("Name", action.Name);
        if(!string.IsNullOrEmpty(action.Description)) {
          writer.WriteAttributeString("Description", action.Description);
        }
        writeBindings(action, writer);
        writer.WriteEndElement();
      }
    }

    /// <summary>Reads an action's bindings from an XML reader</summary>
    /// <param name="action">Actions whose bindings will be read</param>
    /// <param name="reader">XML reader the bindings will be read from</param>
    private static void readBindings(IAction action, XmlReader reader) {
      while(reader.Read()) {
        if(reader.IsStartElement()) {
          if(reader.Name == "KeyBinding") {
            string keyCodeString = reader.GetAttribute("KeyCode");
            if(string.IsNullOrEmpty(keyCodeString)) {
              throw new XmlException("KeyBinding needs to provide the KeyCode attribute");
            }

            var keyCode = (KeyCode)Enum.Parse(typeof(KeyCode), keyCodeString);
            action.BoundKeys.Add(keyCode);
          } else if(reader.Name == "AxisBinding") {
            string axisNameString = reader.GetAttribute("AxisName");
            string isNegativeString = reader.GetAttribute("IsNegative");

            bool attributesMissing =
              string.IsNullOrEmpty(axisNameString) ||
              string.IsNullOrEmpty(isNegativeString);

            if(attributesMissing) {
              throw new XmlException(
                "AxisBinding needs to provide AxisName and IsNegative attributes"
              );
            }

            bool isNegative = bool.Parse(isNegativeString);
            action.BoundJoystickAxes.Add(new JoystickAxis(axisNameString, isNegative));
          } else {
            throw new XmlException(
              "Only KeyBindings or AxisBindings may appear under an Action"
            );
          }
        } else {
          break;
        }
      }
    }

    /// <summary>Writes an action's bindings into an XML writer</summary>
    /// <param name="action">Action whose bindings will be written</param>
    /// <param name="writer">XML writer the bindings will be written into</param>
    private static void writeBindings(IAction action, XmlWriter writer) {
      foreach(KeyCode boundKey in action.BoundKeys) {
        writer.WriteStartElement("KeyBinding");
        writer.WriteAttributeString("KeyCode", boundKey.ToString());
        writer.WriteEndElement();
      }
      foreach(JoystickAxis boundAxis in action.BoundJoystickAxes) {
        writer.WriteStartElement("AxisBinding");
        writer.WriteAttributeString("AxisName", boundAxis.AxisName);
        writer.WriteAttributeString("IsNegative", boundAxis.IsNegative.ToString());
        writer.WriteEndElement();
      }
    }

    /// <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.Input