using System;
using System.Collections.Generic;
using System.Reflection;

using UnityEngine;

using Framework.Support;

using ConditionalAttribute = System.Diagnostics.ConditionalAttribute;

namespace Framework.Services {

  /// <summary>Declares the scope in which a service will exist</summary>
  public static class ServiceInjector {

    /// <summary>Default scope for services missing the ServiceScope attribute</summary>
    private const Scope DefaultScope = Scope.Session;

    #region interface IBinding

    /// <summary>Describes a service binding</summary>
    public interface IBinding {

      /// <summary>Component that is providing the service</summary>
      Type ProviderType { get; }

      /// <summary>Scope in which the service exists</summary>
      Scope Scope { get; }

      /// <summary>Returns the existing instance or creates a new one</summary>
      /// <returns>An instance of the bound service provider</returns>
      object GetOrCreate();

    }

    #endregion // interface IBinding

    #region class ComponentBinding

    /// <summary>Binding of a service to a Unity component (MonoBehaviour)</summary>
    private class ComponentBinding : IBinding {

      /// <summary>Provider that is implementing the service</summary>
      public Type ProviderType;
      /// <summary>Current instance of the sevice provider</summary>
      /// <remarks>
      ///   This may cease to exist when the scene unloads or session ends.
      ///   In this case, Unity will will do some horribad trickery to make
      ///   the object compare as equal to null even though it still exists
      ///   (in an unusable state, not anchored in the hierarchy).
      /// </remarks>
      public object ProviderInstance;
      /// <summary>Scope in which the provider exists</summary>
      public Scope Scope;

      /// <summary>Component that is providing the service</summary>
      Type IBinding.ProviderType {
        get { return this.ProviderType; }
      }

      /// <summary>Scope in which the service exists</summary>
      Scope IBinding.Scope {
        get { return this.Scope; }
      }

      /// <summary>Returns the existing instance or creates a new one</summary>
      /// <returns>An instance of the bound service provider</returns>
      object IBinding.GetOrCreate() {
        if(this.ProviderInstance == null) {
          GameObject container = ServiceContainer.GetOrCreate(this.Scope);

          this.ProviderInstance = container.GetComponent(this.ProviderType);
          if(this.ProviderInstance == null) {
            this.ProviderInstance = container.AddComponent(this.ProviderType);
            // Inject will be called by the component's Awake() method!
            // Do we need circular dependency detection?
          }
        }

        return this.ProviderInstance;
      }

    }

    #endregion // class ComponentBinding

    #region class MethodBinding

    // TODO

    #endregion // class MethodBinding

#if false
    /// <summary>Manually looks up or creates a service provided by the injector</summary>
    /// <typeparam name="T">Type of sevice that will be looked up or created</typeparam>
    /// <returns>An instance of the requested service</returns>
    public static T Get<T>() {
      //return (T)getOrCreateComponent(typeof())
    }
#endif

    /// <summary>
    ///   Calls the Inject() method on the specified object, creating all dependencies
    /// </summary>
    /// <param name="target">Object on which the Inject() method will be called</param>
    /// <remarks>
    ///   This is incompatible with IL2CPP and probably the iOS platform, most likely
    ///   due to <see cref="System.Type.MakeGenericType" />.
    /// </remarks>
    public static void InjectDependencies(object target) {
#if UNITY_EDITOR // No need for this check outside the editor
      if(!Application.isPlaying) {
        Debug.LogWarning(
          "InjectDependencies() on " + target.GetType().ToString() + "' called in editor. " +
          "This would instantiate runtime services as permanent scene hierarchy objects. " +
          "Dependencies not injected."
        );
        return;
      }
#endif

      // See if this type has an Inject() method that we can call
      MethodInfo[] injectMethods = target.GetType().GetMethods(
        BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic
      );
      if((injectMethods == null) || (injectMethods.Length == 0)) {
        return;
      }

      // Call all Inject() methods exposed by the type
      for(int index = 0; index < injectMethods.Length; ++index) {
        if(injectMethods[index].Name == "Inject") {
          callInjectMethod(target, injectMethods[index]);
        }
      }
    }

    /// <summary>
    ///   Retrieves the scope assigned to the specified type via the ServiceScope attribute
    /// </summary>
    /// <param name="type">Type whose desired scope will be retrieved</param>
    /// <returns>The scope of the desired type, boxed in an object</returns>
    public static Scope? GetScope(Type type) {
      object[] attributes = type.GetCustomAttributes(typeof(ServiceScopeAttribute), true);
      if(attributes != null) {
        if(attributes.Length > 0) {
          return ((ServiceScopeAttribute)attributes[0]).Scope;
        }
      }

      return null;
    }

    /// <summary>Calls the Inject() method on the specified target</summary>
    /// <param name="target">Target the Inject() method will be called on</param>
    /// <param name="injectMethod">Inject method that will be called</param>
    private static void callInjectMethod(object target, MethodInfo injectMethod) {
      ParameterInfo[] parameterInfos = injectMethod.GetParameters();
      verifyScopes(target.GetType(), parameterInfos);

      // Fill the parameters of the Inject() method, also recursively injecting any
      // dependencies that are newly constructed
      object[] parameters = new object[parameterInfos.Length];
      for(int index = 0; index < parameterInfos.Length; ++index) {
        Type parameterType = parameterInfos[index].ParameterType;

        // If no explicit binding has been made for this service,
        // we need to figure it out by ourselves (default case!)
        IBinding binding;
        if(!bindings.TryGetValue(parameterType, out binding)) {
          binding = deduceBinding(parameterInfos[index]);
          bindings.Add(parameterType, binding);
        }

        // Create the provider (may result in further calls to this method!)
        parameters[index] = binding.GetOrCreate();
      }

      injectMethod.Invoke(target, parameters);
    }

    /// <summary>Attempts to deduce the provider bound to a service</summary>
    /// <param name="parameterInfo">Service whose provider will be deduced</param>
    /// <returns>A binding for the specified service</returns>
    private static IBinding deduceBinding(ParameterInfo parameterInfo) {

      // The ServiceScope attribute should be on the service (interface).
      // It would be invite inconsistency and chaos if we looked at the provider
      // instead. We could check the provider to prevent user error, though.
      Scope? parameterScope = GetScope(parameterInfo.ParameterType);
      if(!parameterScope.HasValue) {
        parameterScope = DefaultScope;
        UnityEngine.Debug.LogWarning(
          "Type '" + parameterInfo.ParameterType.Name + "' " +
          "is missing the ServiceScope attribute"
        );
      }

      Type binding = getDefaultBinding(parameterInfo);
      if(binding == null) {
        if(parameterInfo.ParameterType.IsAbstract) {
          UnityEngine.Debug.LogError(
            "Service '" + parameterInfo.ParameterType.Name + "' " +
            "is abstract and no binding could be deduced for it."
          );
          throw new Exception(
            "No provider for service '" + parameterInfo.ParameterType.Name + "' "
          );
        }

        // No default binding specified but service is also the provider
        // (other component specified instead of interface), so use it.
        binding = parameterInfo.ParameterType;
      }

      return new ComponentBinding() {
        Scope = parameterScope.Value,
        ProviderType = binding
      };

    }

    /// <summary>
    ///   Verifies that no service depends on a shorter-lived service than itself
    /// </summary>
    /// <param name="serviceType">Type of service that will be verified</param>
    /// <param name="parameterInfos">Dependencies of the service</param>
    [Conditional("DEBUG")]
    private static void verifyScopes(Type serviceType, ParameterInfo[] parameterInfos) {
      if(!Application.isEditor) {
        return;
      }

      Scope? serviceScope = GetScope(serviceType);
      if(serviceScope == null) {
        return;
      }

      for(int index = 0; index < parameterInfos.Length; ++index) {
        Scope dependencyScope = GetScope(parameterInfos[index].ParameterType) ?? DefaultScope;
        if(dependencyScope < serviceScope) {
          UnityEngine.Debug.LogError(
            "Service '" + serviceType.Name + "' has a dependency on " +
            "'" + parameterInfos[index].ParameterType.Name + "' which exists in " +
            "a shorter lived scope. This WILL cause problems when scenes are loaded."
          );
        }
      }
    }
#if false
    /// <summary>
    ///   Looks up or creates the specified component, also injecting its dependencies
    /// </summary>
    /// <param name="componentType">Type of component that will be created</param>
    /// <param name="scope">Scope in which the component will be created</param>
    /// <returns>The existing or newly created component of the specified type</returns>
    private static object getOrCreateComponent(Type componentType, Scope scope) {
      GameObject container = ServiceContainer.GetOrCreate(scope);

      Component component = container.GetComponent(componentType);
      if(component == null) {
        component = container.AddComponent(componentType);
        // Inject will be called by the component's Awake() method!
      }

      return component;
    }
#endif
    /// <summary>Retrieves the default provider bound to the requested service</summary>
    /// <param name="parameterInfo">Injected parameter whose default service is needed</param>
    /// <returns>The default service for the injected parameter, if specified</returns>
    private static Type getDefaultBinding(ParameterInfo parameterInfo) {

      // Undecided:
      // - All this is to support zero configuration DI
      // - Putting DefaultBinding on service interface would promote consistency
      //   (no mismatching bindings depending on who first asks for a service)
      // - But would be a problem if you wanted to put the interface separately
      //   from the implementation (is class library usage a common use case in Unity?)

      // Priority 1 is the default provider directly specified for the parameter
      object[] attributes = parameterInfo.GetCustomAttributes(
        typeof(DefaultBindingAttribute), false
      );
      if(attributes != null) {
        if(attributes.Length > 0) {
          return ((DefaultBindingAttribute)attributes[0]).ServiceImplementationType;
        }
      }

      // Priority 2 is the default provider specified by the service interface
      attributes = parameterInfo.ParameterType.GetCustomAttributes(
        typeof(DefaultBindingAttribute), false
      );
      if(attributes != null) {
        if(attributes.Length > 0) {
          return ((DefaultBindingAttribute)attributes[0]).ServiceImplementationType;
        }
      }

      return null;
    }

    /// <summary>
    ///   Reflection informations for the getOrCreateAndInjectComponent() method
    /// </summary>
    //private static MethodInfo getOrCreateAndInjectComponentMethod;

    /// <summary>Bindings that have been set up for services</summary>
    /// <remarks>
    ///   Under the (safe) assumption that the bindings will not change
    ///   at runtime, we cache most information in which services have been bound.
    ///   This saves us a costly attribute query (calling
    ///   <see cref="ParameterInfo.GetCustomAttributes(bool)" /> would construct
    ///   attribute instances and produce garbage for each Inject() use),
    ///   component lookup in the scene hierarchy and such.
    /// </remarks>
    private static IDictionary<Type, IBinding> bindings = new Dictionary<Type, IBinding>();

  }

} // namespace Framework.Services