using System;

using UnityEngine;

using Framework.Support;

namespace Framework.Services {

  /// <summary>Manages and provides access to a game object holding the services</summary>
  public static class ServiceContainer {

    /// <summary>Name of the game object for game-wide services</summary>
    public const string GlobalServicesGameObjectName = "Global";
    /// <summary>Name of the game object for services limited to the scenes</summary>
    public const string SessionServicesGameObjectName = "Session";
    /// <summary>Name of the game object for services in the current scene</summary>
    public const string SceneServicesGameObjectName = "Scene";

    /// <summary>Retrieves or creates the service of the specified type</summary>
    /// <typeparam name="TComponent">Component that will be created</typeparam>
    /// <param name="scope">Scope in which the service will be created</param>
    /// <returns>The requested component</returns>
    public static TComponent GetOrCreateComponent<TComponent>(Scope scope)
      where TComponent : MonoBehaviour {
      GameObject container = GetOrCreate(scope);

      TComponent component = container.GetComponent<TComponent>();
      if(component == null) {
        component = container.AddComponent<TComponent>();
      }

      return component;
    }

    /// <summary>Retrieves the services root for the specified scope</summary>
    /// <param name="scope">Scope for which the services root will be retrieved</param>
    /// <returns>The services root for the specified scope</returns>
    public static GameObject GetOrCreate(Scope scope) {
      switch(scope) {
        case Scope.Scene: {
          bool needDestroyer = GameObjectHelper.IsNullOrDestroyed(sceneServicesGameObject);
          GameObject gameObject = getOrCreate(
            SceneServicesGameObjectName, ref sceneServicesGameObject
          );
          if(needDestroyer) {
            gameObject.AddComponent<OnSceneLoadKiller>();
          }
          return gameObject;
        }
        case Scope.Session: {
          return getOrCreate(SessionServicesGameObjectName, ref sessionServicesGameObject);
        }
        case Scope.Global: {
          return getOrCreate(GlobalServicesGameObjectName, ref globalServicesGameObject);
        }
        default: {
          throw new ArgumentException("Unsupported scope", "scope");
        }
      }
    }

    /// <summary>Kills all components in the specified scope</summary>
    /// <param name="scope">Scope in which components will be killed</param>
    public static void Kill(Scope scope) {
      switch(scope) {
        case Scope.Scene: {
          kill(SceneServicesGameObjectName, ref sceneServicesGameObject);
          break;
        }
        case Scope.Session: {
          kill(SessionServicesGameObjectName, ref sessionServicesGameObject);
          break;
        }
        case Scope.Global: {
          kill(GlobalServicesGameObjectName, ref globalServicesGameObject);
          break;
        }
        default: {
          throw new ArgumentException("Unsupported scope", "scope");
        }
      }
    }

    /// <summary>Kills the specified service container</summary>
    /// <param name="name">Name of the service container that will be killed</param>
    /// <param name="cached">Field holding the cached service container</param>
    private static void kill(string name, ref GameObject cached) {
      if(GameObjectHelper.IsNullOrDestroyed(cached)) {
        GameObject servicesRoot = ServicesRoot.Get();
        if(GameObjectHelper.IsNullOrDestroyed(servicesRoot)) {
          return;
        }

        cached = GameObjectHelper.GetChildByName(servicesRoot, name);
        if(GameObjectHelper.IsNullOrDestroyed(cached)) {
          return;
        }
      }

      GameObject.Destroy(cached);
      cached = null;
    }

    /// <summary>Retrieves or creates a game object under the service root</summary>
    /// <returns>The game object with the specified name</returns>
    private static GameObject getOrCreate(string name, ref GameObject cached) {
      if(GameObjectHelper.IsNullOrDestroyed(cached)) {
        GameObject servicesRoot = ServicesRoot.GetOrCreate();

        cached = GameObjectHelper.GetChildByName(servicesRoot, name);
        if(GameObjectHelper.IsNullOrDestroyed(cached)) {
          cached = new GameObject(name);
          GameObjectHelper.SetAsChild(servicesRoot, cached);
        }
      }

      return cached;
    }

    /// <summary>Game object in which scene-scoped services will be stored</summary>
    private static GameObject sceneServicesGameObject;
    /// <summary>Game object in which session-scoped services will be stored</summary>
    private static GameObject sessionServicesGameObject;
    /// <summary>Game object in which global services will be stored</summary>
    private static GameObject globalServicesGameObject;

  }

} // namespace Framework.Services