using System;
using System.IO;

namespace Framework.Storage.Containers {

  /// <summary>XML-backed persistent state container</summary>
  /// <typeparam name="TState">Type of state the persistent container stores</typeparam>
  internal class XmlBackedContainer<TState, TInterface> :
    IVerifiedPersistentContainer<TInterface>
    where TState : class, TInterface, new()
    where TInterface : class {

#if false
    /// <summary>Triggered when the settings should be reapplied</summary>
    /// <remarks>
    ///   <para>
    ///     Typically, you don't want to tightly integrate all your character controllers
    ///     and other game logic with the persistent state saving system and instead
    ///     create 'glue' objects which take the settings from a persistent container
    ///     and apply them at will.
    ///   </para>
    ///   <para>
    ///     This event can be used to signal to those 'glue' objects that they should
    ///     apply the current settings to the game's controllers again.
    ///   </para>
    ///   <para>
    ///     One danger of this event is that dead objects may keep hanging on to it.
    ///     Any 'glue' component needs to cleanly unsubscribe when it is being destroyed!
    ///   </para>
    /// </remarks>
    public event Action Apply;
#endif

    /// <summary>Initializes a new XML-backed persistent state container</summary>
    /// <param name="directory">Directory in which state file will be stored</param>
    /// <param name="defaultFilename">Default name of the state file</param>
    public XmlBackedContainer(string directory, string defaultFilename) {
      this.state = new TState();
      this.directory = directory;
      this.defaultFilename = defaultFilename;
      this.isGenuine = true;
    }

    /// <summary>Accesses the informations stored in the state</summary>
    public TInterface Access() {
      return this.state;
    }

    /// <summary>Accesses the game-specific state</summary>
    /// <typeparam name="TSpecificState">
    ///   Game-specific type of state the game is storing
    /// </typeparam>
    /// <returns>The game-specific state</returns>
    public TSpecificState Access<TSpecificState>() where TSpecificState : TInterface {
      object stateAsObject = (object)this.state;
      return (TSpecificState)stateAsObject;
      // return default(TSpecificState); // This should work. Cast unknown class X to Y...
    }

    /// <summary>Optional custom serializer for the state, null to use default</summary>
    public IPersistentStateSerializer<TState> CustomSerializer {
      get { return this.customSerializer; }
      set { this.customSerializer = value; }
    }

    /// <summary>Loads the saved state of the container from disk</summary>
    public void Load() {

      // If we don't do this and a future version of the game adds new attributes
      // or properties, the player could mix things up by playing a save with
      // the desired attributes, then loading an old-version save (leaving those
      // attributes in their previous states).
      Reset();

      if(this.customSerializer == null) {
        loadUsingDefaultSerializer();
        this.isGenuine = true;
      } else {
        this.isGenuine = loadUsingCustomSerializer();
      }

    }

    /// <summary>Saves the current state of the container to disk</summary>
    public void Save() {
      if(this.customSerializer == null) {
        saveUsingDefaultSerializer();
      } else {
        saveUsingCustomSerializer();
      }
    }

    /// <summary>Resets the container to its default settings</summary>
    public void Reset() {

      // Would like to replace this with create-instance-and-copy-into-existing
      this.state = new TState();
    }

    /// <summary>Whether the container's state is tamper-free</summary>
    /// <remarks>>
    ///   If the user tries to edit the save file, a verified container will
    ///   detect this and report its state as non-genuine.
    /// </remarks>
    public bool IsGenuine { get { return this.isGenuine; } }

    /// <summary>Updates the Directory in which the XML file will be stored</summary>
    /// <param name="newDirectory">New directory to use for the XML file</param>
    public void ChangeDirectory(string newDirectory) {
      this.directory = newDirectory;
    }

    /// <summary>Loads the state using a custom serializer</summary>
    private bool loadUsingCustomSerializer() {
      string path = this.customSerializer.DefaultFilename;
      if(string.IsNullOrEmpty(path)) {
        path = Path.Combine(this.directory, this.defaultFilename);
      } else {
        path = Path.Combine(this.directory, path);
      }

      if(File.Exists(path)) {
        return this.customSerializer.Load(this.state, path);
      } else {
        Reset();
        return true;
      }
    }

    /// <summary>Loads the state using the default XML serializer</summary>
    private void loadUsingDefaultSerializer() {
      if(!Directory.Exists(this.directory)) {
        Directory.CreateDirectory(this.directory);
      }

      string path = Path.Combine(this.directory, this.defaultFilename);
      if(File.Exists(path)) {
        SimpleXmlSerializer.Load(this.state, path);
      } else {
        Reset();
      }
    }

    /// <summary>Saves the state using a custom serializer</summary>
    private void saveUsingCustomSerializer() {
      if(!Directory.Exists(this.directory)) {
        Directory.CreateDirectory(this.directory);
      }

      string path = this.customSerializer.DefaultFilename;
      if(string.IsNullOrEmpty(path)) {
        path = Path.Combine(this.directory, this.defaultFilename);
      } else {
        path = Path.Combine(this.directory, path);
      }

      this.customSerializer.Save(this.state, path);
    }

    /// <summary>Saves the state using the default XML serializer</summary>
    private void saveUsingDefaultSerializer() {
      if(!Directory.Exists(this.directory)) {
        Directory.CreateDirectory(this.directory);
      }

      string path = Path.Combine(this.directory, this.defaultFilename);
      SimpleXmlSerializer.Save(this.state, path);
    }

    /// <summary>Custom serializer that will be used to persist the container</summary>
    private IPersistentStateSerializer<TState> customSerializer;
    /// <summary>Informations stored in this container</summary>
    private TState state;
    /// <summary>Directory in which the state file will be saved</summary>
    private string directory;
    /// <summary>Default filename that will be used for the state file</summary>
    /// <remarks>
    ///   This can be overriden if a custom serializer is assigned
    /// </remarks>
    private string defaultFilename;
    /// <summary>Whether the current state is tamper-free</summary>
    private bool isGenuine;

  }

} // namespace Framework.Storage.Containers