using System;
using System.Collections.Generic;

using UnityEngine;

using Framework.Services;
using Framework.Storage.Containers;

namespace Framework.Storage {

  /// <summary>Manages all persistent data of the game</summary>
  /// <remarks>
  ///   <para>
  ///     This service remain in existence for as long as the game runs and manages
  ///     settings that apply to the whole game. Before accessing it for the first
  ///     time, the specific classes used to store the game's settings need to be
  ///     made known to the service by calling the <see cref="Initialize" /> method.
  ///   </para>
  ///   <para>
  ///     It is recommended that you access the service through a game-specific
  ///     wrapper which makes sure that the <see cref="Initialize" /> method is
  ///     always called before accessing the settings, even when a scene is started
  ///     inside the editor, skipping the startup, main menu and other scenes.
  ///   </para>
  ///   <para>
  ///     Shared modules which do not have access to the game specific classes used
  ///     to store settings can wait for the game to initialize the settings manager
  ///     by subscribing to the <see cref="Initialized" /> event. If the settings
  ///     manager has already been initialized at the time of subscription,
  ///     the event handler will be called while subscribing.
  ///   </para>
  /// </remarks>
  [
    ServiceScope(Scope.Global)
  ]
  public class PersistentSettingsManager : Service, IPersistentSettingsStore {

    /// <summary>Filename for the machine settings file</summary>
    public static readonly string MachineSettingsFilename = "Settings.xml";

    /// <summary>Filename for the user settings file</summary>
    public static readonly string UserSettingsFilename = "UserSettings.xml";

    /// <summary>Filename for the achievements and global unlocks file</summary>
    public static readonly string AchievementsFilename = "Achievements.xml";

    /// <summary>Called when the persistent state store has been initialized</summary>
    public event Action Initialized {
      add {
        if(IsInitialized) {
          value();
        } else {
          if(this.initializedEventSubscribers == null) {
            this.initializedEventSubscribers = new List<Action>();
            this.initializedEventSubscribers.Add(value);
          } else if(!this.initializedEventSubscribers.Contains(value)) {
            this.initializedEventSubscribers.Add(value);
          }
        }
      }
      remove {
        this.initializedEventSubscribers.Remove(value);
      }
    }

    /// <summary>Initializes the types that will be used by the persistent data store</summary>
    /// <typeparam name="TUserSettings">
    ///   Type that will be used to store user-specific settings such as key bindings,
    ///   mouse speed or language.
    /// </typeparam>
    /// <typeparam name="TMachineSettings">
    ///   Type that will be used to store machine-specific settings such as resolution,
    ///   monitor and detail levels.
    /// </typeparam>
    /// <typeparam name="TAchievements">
    ///   Type that will be used to store global unlocks and achievements
    /// </typeparam>
    /// <remarks>
    ///   The default implementation of the persistent store requires this method to be called
    ///   before any of the other properties and methods of the persistent store will work.
    ///   It will load the game's current settings from their default locations if available
    ///   and create new default instances of no saved settings exist.
    /// </remarks>
    public void Initialize<
      TMachineSettings,
      TUserSettings,
      TAchievements
    >(
      IPersistentStateSerializer<TMachineSettings> machineSettingsSerializer = null,
      IPersistentStateSerializer<TUserSettings> userSettingsSerializer = null,
      IPersistentStateSerializer<TAchievements> achievementSerializer = null
    )
      where TMachineSettings : class, IMachineSettings, new()
      where TUserSettings : class, IUserSettings, new()
      where TAchievements : class, IAchievements, new() {

      if(IsInitialized) {
        Debug.LogError("Persistent data manager was initialized a second time.");
        return;
      }

      {
        var machineSettingsContainer = new XmlBackedContainer<TMachineSettings, IMachineSettings>(
          StandardDirectories.UserDataPath, MachineSettingsFilename
        );
        machineSettingsContainer.CustomSerializer = machineSettingsSerializer;
        this.machineSettings = machineSettingsContainer;
      }

      {
        var userSettingsContainer = new XmlBackedContainer<TUserSettings, IUserSettings>(
          StandardDirectories.UserDataPath, UserSettingsFilename
        );
        userSettingsContainer.CustomSerializer = userSettingsSerializer;
        this.userSettings = userSettingsContainer;
      }

      {
        var achievementContainer = new XmlBackedContainer<TAchievements, IAchievements>(
          StandardDirectories.UserDataPath, AchievementsFilename
        );
        achievementContainer.CustomSerializer = achievementSerializer;
        this.achievements = achievementContainer;
      }

      Debug.Log("Persistent settings manager initialized");

      OnInitialized();
    }

    /// <summary>Whether the persistent data store has been initialized already</summary>
    public bool IsInitialized {
      get {
        return (
          (this.userSettings != null) &&
          (this.machineSettings != null) &&
          (this.achievements != null)
        );
      }
    }

    /// <summary>Container for machine-specific settings such as display parameters</summary>
    public IPersistentContainer<IMachineSettings> MachineSettings {
      get {
        if(!IsInitialized) {
          throw new InvalidOperationException(
            "Can't access machine settings; persistent settings manager not initialized uet"
          );
        }

        return this.machineSettings;
      }
    }

    /// <summary>Container for user-specific settings such as key bindings</summary>
    public IPersistentContainer<IUserSettings> UserSettings {
      get {
        if(!IsInitialized) {
          throw new InvalidOperationException(
            "Can't access user settings; persistent settings manager not initialized uet"
          );
        }

        return this.userSettings;
      }
    }

    /// <summary>Container for global unlocks and achievements</summary>
    public IVerifiedPersistentContainer<IAchievements> Achievements {
      get {
        if(!IsInitialized) {
          throw new InvalidOperationException(
            "Can't access achievements; persistent settings manager not initialized uet"
          );
        }

        return this.achievements;
      }
    }

    /// <summary>Loads all persistent settings from the current serialized state</summary>
    public void LoadAllSettings() {
      if(!IsInitialized) {
        throw new InvalidOperationException(
          "Can't load settings; persistent game state manager not initialized uet"
        );
      }

      this.machineSettings.Load();
      this.userSettings.Load();
    }

    /// <summary>Saves all persistent settings into their respective files</summary>
    public void SaveAllSettings() {
      if(!IsInitialized) {
        throw new InvalidOperationException(
          "Can't save settings; persistent game state manager not initialized uet"
        );
      }

      this.machineSettings.Save();
      this.userSettings.Save();
    }

    /// <summary>Fires the OnInitialized() event</summary>
    /// <remarks>>
    ///   We auto-clear the subscribers after firing since the event is supposed to
    ///   only happen once per game and we don't want to keep a bunch of objects hanging
    ///   by their subscription to the event list.
    /// </remarks>
    protected virtual void OnInitialized() {
      if(this.initializedEventSubscribers != null) {
        IList<Action> subscribers = this.initializedEventSubscribers;
        this.initializedEventSubscribers = null;

        int subscriberCount = subscribers.Count;
        for(int index = 0; index < subscriberCount; ++index) {
          subscribers[index]();
        }
      }
    }

    /// <summary>Container for machine-specific settings such as display parameters</summary>
    private IPersistentContainer<IMachineSettings> machineSettings;
    /// <summary>Container for user-specific settings such as key bindings</summary>
    private IPersistentContainer<IUserSettings> userSettings;
    /// <summary>Container for global unlocks and achievements</summary>
    private IVerifiedPersistentContainer<IAchievements> achievements;
    /// <summary>List of subscribers for the <see cref="Initialized" /> event</summary>
    private IList<Action> initializedEventSubscribers;

  }

} // namespace Framework.Storage