using System;

using UnityEngine;

namespace Framework.Services {

  /// <summary>Configures the service graph at runtime</summary>
  public class RuntimeServiceModel {

#if false

    #region interface IScopingContext

    /// <summary>Allows a service's scope to be specified</summary>
    public interface IScopingContext {

      /// <summary>Keeps the service alive until the game terminates</summary>
      void InGlobalScope();

      /// <summary>Destroys the service when the player quits the gameplay session</summary>
      void InSessionScope();

      /// <summary>Service will only keep alive until another scene is loaded</summary>
      void InSceneScope();

      /// <summary>Each consumer will get a different copy of the service</summary>
      void InTransientScope();

    }

    #endregion // interface IScopingContext

    #region class BindingScopingContext

    /// <summary>Scoping context that modifies a service binding</summary>
    private class BindingScopingContext : IScopingContext {

      /// <summary>Initializes a new scoping context for service bindings</summary>
      /// <param name="binding"></param>
      public BindingScopingContext(ServiceInjector.IBinding binding) {
        this.binding = binding;
      }

      /// <summary>Keeps the service alive until the game terminates</summary>
      public void InGlobalScope() {
        this.binding.ChangeScope(Scope.Global);
      }

      /// <summary>Destroys the service when the player quits the gameplay session</summary>
      public void InSessionScope() {
        this.binding.ChangeScope(Scope.Session);
      }

      /// <summary>Service will only keep alive until another scene is loaded</summary>
      public void InSceneScope() {
        this.binding.ChangeScope(Scope.Scene);
      }

      /// <summary>Each consumer will get a different copy of the service</summary>
      public void InTransientScope() {
        throw new NotImplementedException();
      }

    }

    #endregion // class BindingScopingContext

    #region interface IBindingContext<TInterface>

    /// <summary>Allows the implementation of a service to be specified</summary>
    /// <typeparam name="TInterface">Interface to which an implementation will be bound</typeparam>
    public interface IBindingContext<TInterface> where TInterface : class {

      /// <summary>Binds the interface to the specified implementation class</summary>
      /// <typeparam name="TImplementation">
      ///   Implementation class to which the interface will be bound
      /// </typeparam>
      /// <returns>A context by which the service's scope can be modified</returns>
      IScopingContext To<TImplementation>() where TImplementation : MonoBehaviour, TInterface;

      // Problem: We don't know how and where the existing instance was created
      //          and whether its service lifetime can be modified.
      // Solution? Always assume scene lifetime?
#if false
      /// <summary>Binds the interface to the specified factory method</summary>
      /// <param name="factoryMethod">Method that will be called to create the component</param>
      /// <returns>A context by which the service's scope can be modified</returns>
      IScopingContext ToMethod(Func<GameObject, TInterface> factoryMethod);

      /// <summary>Binds the interface to the specified existing instance</summary>
      /// <param name="instance">Instance to which the interface will be bound</param>
      /// <returns>A context by which the service's scope can be modified</returns>
      IScopingContext ToConstant(TInterface instance);
#endif

    }

    #endregion // interface IBindingContext<TInterface>

    #region class ServiceInjectorBindingContext<TInterface>

    /// <summary>Sets up bindings in a service injector</summary>
    /// <typeparam name="TInterface"></typeparam>
    private class ServiceInjectorBindingContext<TInterface> : IBindingContext<TInterface>
      where TInterface : class {

      /// <summary>Binds the interface to the specified implementation class</summary>
      /// <typeparam name="TImplementation">
      ///   Implementation class to which the interface will be bound
      /// </typeparam>
      /// <returns>A context by which the service's scope can be modified</returns>
      public IScopingContext To<TImplementation>()
        where TImplementation : MonoBehaviour, TInterface {

        Type interfaceType = typeof(TInterface);
        Scope scope = ServiceInjector.GetScope(interfaceType).GetValueOrDefault(Scope.Scene);

        ServiceInjector.IBinding = ServiceInjector.AddBinding(
          typeof(TInterface), typeof(TImplementation)
        );


        throw new NotImplementedException();
      }

    }

    #endregion // class ServiceInjectorBindingContext<TInterface>

    /// <summary>Lets you set up a binding for the specified interface</summary>
    /// <typeparam name="TInterface">Interface for which a binding will be set up</typeparam>
    /// <returns>
    ///   A context through which the binding for the specified interface can be set up
    /// </returns>
    public static IBindingContext<TInterface> Bind<TInterface>()
      where TInterface : class {
      return new ServiceInjectorBindingContext<TInterface>();
    }

#endif

  }

} // namespace Framework.Services