using System;

using UnityEngine;

using Framework.Services;

namespace Framework.Actors {

  /// <summary>Combines multiple head controllers to a single point of access</summary>
  public class HeadControllerCombiner : ScriptComponent, IHeadController {

    /// <summary>Fired to pass on head rotation that was clamped</summary>
    public event Action<Quaternion> ExcessHeadRotation;

    /// <summary>Head controllers the combiner will combine</summary>
    /// <remarks>
    ///   If this is null, the list of head controllers will be queried
    ///   from the component hosting the <see cref="HeadControllerCombiner" />
    ///   at runtime.
    /// </remarks>
    public IHeadController[] CombinedHeadControllers;

    /// <summary>Head controller the combiner is currently forwarding to</summary>
    public IHeadController ActiveHeadController {
      get {
        if(this.activeHeadControllerIndex == -1) {
          return null;
        } else {
          return this.CombinedHeadControllers[this.activeHeadControllerIndex];
        }
      }
    }

    /// <summary>Called once when the component is loaded into a game object</summary>
    protected override void Awake() {
      base.Awake();

      this.onExcessHeadRotationDelegate = new Action<Quaternion>(OnExcessHeadRotation);

      // Create a list of head controllers present in the hierarchy excluding this one.
      {
        IHeadController[] headControllers = GetComponentsInChildren<IHeadController>();
        int headControllerCount = headControllers.Length;

        // We make the assumption that 'this' is always present in the list returned
        // by GetComponentsInChildren(), to the point were we'd crash if it wasn't.
        this.CombinedHeadControllers = new IHeadController[headControllerCount - 1];

        // Copy all head controllers that are not 'this' into 'CombinedHeadControllers'
        int targetIndex = 0;
        for(int index = 0; index < headControllerCount; ++index) {
          if(!ReferenceEquals(this, headControllers[index])) {
            this.CombinedHeadControllers[targetIndex] = headControllers[index];
            ++targetIndex;
          }
        }
      }

      this.activeHeadControllerIndex = -1;
    }

    /// <summary>Handles clamped-off head rotation from the current controller</summary>
    /// <param name="excessRotation">Head rotation the controller has clamped off</param>
    protected virtual void OnExcessHeadRotation(Quaternion excessRotation) {
      if(this.ExcessHeadRotation != null) {
        this.ExcessHeadRotation(excessRotation);
      }
    }

    /// <summary>Called when the component is removed from its game object</summary>
    protected virtual void OnDestroy() {
      IHeadController activeHeadController = ActiveHeadController;
      if(activeHeadController != null) {
        activeHeadController.ExcessHeadRotation -= this.onExcessHeadRotationDelegate;
      }
    }

    /// <summary>Called once per visual update (before a rendered frame)</summary>
    protected virtual void Update() {

      // If there is no current active head controller, look for one that became active
      if(this.activeHeadControllerIndex == -1) {
        this.activeHeadControllerIndex = findActiveHeadController();
        if(this.activeHeadControllerIndex != -1) {
          switchHeadController(
            null, this.CombinedHeadControllers[this.activeHeadControllerIndex]
          );
        }
      } else { // Otherwise, check if the active one is still active

        bool isActive = (
          this.CombinedHeadControllers[this.activeHeadControllerIndex].IsActive
        );
        if(!isActive) {
          int previousIndex = this.activeHeadControllerIndex;
          this.activeHeadControllerIndex = findActiveHeadController();

          if(this.activeHeadControllerIndex == -1) {
            switchHeadController(this.CombinedHeadControllers[previousIndex], null);
          } else {
            switchHeadController(
              this.CombinedHeadControllers[previousIndex],
              this.CombinedHeadControllers[this.activeHeadControllerIndex]
            );
          }
        }
      }
    }

    /// <summary>Switches delegation to another head controller</summary>
    /// <param name="previousController">
    ///   Head controller the component delegated to previously
    /// </param>
    /// <param name="currentController">
    ///   Head controller the component will delegate to from now on
    /// </param>
    private void switchHeadController(
      IHeadController previousController, IHeadController currentController
    ) {
#if UNITY_EDITOR
      DebugLogControllerChange(previousController, currentController);
#endif

      // If there was a previous head controller, unsubscribe from its events
      if(previousController != null) {
        previousController.ExcessHeadRotation -= this.onExcessHeadRotationDelegate;
      }

      // If a new head controller became active, subscribe to its events
      if(currentController != null) {
        currentController.ExcessHeadRotation += this.onExcessHeadRotationDelegate;
      }

      // If a different head controller become active, apply the previous
      // head orientation to the new controller
      if((previousController != null) && (currentController != null)) {
        currentController.SetGlobalLookDirection(
          previousController.GetGlobalLookDirection()
        );
      }

    }

#if UNITY_EDITOR
    /// <summary>Does debug logging when the active head controller is changed</summary>
    /// <param name="previousController">Head controller that was active previously</param>
    /// <param name="currentController">Head controller that has now become active</param>
    private void DebugLogControllerChange(
      IHeadController previousController, IHeadController currentController
    ) {

      // Figure out a descriptive name for the previous head controller
      string previousControllerName;
      if(previousController == null) {
        previousControllerName = "<none>";
      } else {
        previousControllerName = previousController.GetType().Name;
      }

      // Figure out a descriptive name for the new head controller
      string currentControllerName;
      if(currentController == null) {
        currentControllerName = "<none>";
      } else {
        currentControllerName = currentController.GetType().Name;
      }

      Debug.Log(
        gameObject.name + " switched head controller from '" + previousControllerName + "'" +
        " to '" + currentControllerName + "'"
      );
    }
#endif // UNITY_EDITOR

    /// <summary>Looks for the currently active head controller</summary>
    /// <returns>The index of the active head controller, -1 if none are active</returns>
    private int findActiveHeadController() {
      int headControllerCount = this.CombinedHeadControllers.Length;
      for(int index = 0; index < headControllerCount; ++index) {
        if(this.CombinedHeadControllers[index].IsActive) {
          return index;
        }
      }

      return -1;
    }

    /// <summary>Transform to which the virtual reality camera is parented</summary>
    Transform IHeadController.VirtualRealityCameraRoot {
      get {
        IHeadController activeHeadController = ActiveHeadController;
        if(activeHeadController == null) {
          return null;
        } else {
          return activeHeadController.VirtualRealityCameraRoot;
        }
      }
    }

    /// <summary>Base transform in which the player controls the look direction</summary>
    Quaternion IHeadController.HeadBaseOrientation {
      get {
        IHeadController activeHeadController = ActiveHeadController;
        if(activeHeadController == null) {
          return Quaternion.identity;
        } else {
          return activeHeadController.HeadBaseOrientation;
        }
      }
    }

    /// <summary>Where the player is looking within the head's coordinate space</summary>
    Quaternion IHeadController.LocalHeadOrientation {
      get {
        IHeadController activeHeadController = ActiveHeadController;
        if(activeHeadController == null) {
          return Quaternion.identity;
        } else {
          return activeHeadController.LocalHeadOrientation;
        }
      }
      set {
        IHeadController activeHeadController = ActiveHeadController;
        if(activeHeadController != null) {
          activeHeadController.LocalHeadOrientation = value;
        }
      }
    }

    /// <summary>Whether this look handler is part of the active input profile</summary>
    bool IHeadController.IsActive {
      get { return true; } // This one is always active
    }

    /// <summary>Index of the currently active head controller</summary>
    private int activeHeadControllerIndex;
    /// <summary>Delegate for the <see cref="OnExcessHeadRotation" /> method</summary>
    private Action<Quaternion> onExcessHeadRotationDelegate;

  }

} // namespace Framework.Actors