using System;
using System.Collections.Generic;

using UnityEngine;

using Framework.Services;

using UnityInput = UnityEngine.Input;

namespace Framework.Input {

  /// <summary>Maps input from any number of devices to actions</summary>
  /// <remarks>
  ///   <para>
  ///     Actions need to be created through the <see cref="CreateAction" /> method
  ///     before they can be used. It is a good idea to assign default key bindings
  ///     at the start of your game (even if loading the player's settings overwrites
  ///     these bindings again) to ensure the game never ends up in a state where
  ///     the player has no usable controls.
  ///   </para>
  ///   <para>
  ///     Consider adding another layer between your code and the input mapper instead
  ///     of querying inputs directory in order to allow for unit testing with simulated
  ///     inputs. The <see cref="InputManager" /> can collect input and package it in
  ///     arbitrary state structures that you could mock in your tests.
  ///   </para>
  ///   <para>
  ///     Basic usage example:
  ///   </para>
  ///   <para>
  ///     <example>
  ///       <code>
  ///         IAction fireAction = this.myInputManager.CreateAction("Fire");
  ///         fireAction.BoundKeys.Add(KeyCode.Mouse0);
  ///         fireAction.BoundKeys.Add(KeyCode.Joystick1Button);
  ///
  ///         IAction forwardAction = this.myInputManager.CreateAction("Forward");
  ///         forwardAction.BoundKeys.Add(KeyCode.W);
  ///         forwardAction.BoundJoystickAxes.Add("Joystick1_Axis1");
  ///
  ///         if(fireAction.IsActive) {
  ///           fireWeapon();
  ///         }
  ///
  ///         transform.Translate(0.0f, 0.0f, forwardAction.State, Space.Self);
  ///       </code>
  ///     </example>
  ///   </para>
  /// </remarks>
  [ServiceScope(Scope.Global)]
  public class InputMapper : Service, IInputMapper, Action.IBindingObserver {

    #region class KeyMapping

    /// <summary>Stores the actions a key or button has been mapped to</summary>
    private class KeyMapping {

      /// <summary>Initializes a new key or button mapping</summary>
      public KeyMapping() {
        this.Actions = new List<Action>();
      }

      /// <summary>Key or button that has been mapped</summary>
      public KeyCode Key;
      /// <summary>Actions the key or button has been mapped to</summary>
      public IList<Action> Actions;

    }

    #endregion // class KeyMapping

    #region class AxisMapping

    /// <summary>Stores the actions a joystick axis has been mapped to</summary>
    private class AxisMapping {

      /// <summary>Initializes a new joystick axis mapping</summary>
      public AxisMapping() {
        this.Actions = new List<Action>();
      }

      /// <summary>Joystick axis that has been mapped</summary>
      public JoystickAxis Axis;
      /// <summary>Actions the joystick axis has been mapped to</summary>
      public IList<Action> Actions;
    }

    #endregion // class AxisMapping

    #region class ReferenceCountedAction

    /// <summary>Stores an action and the number of references to it</summary>
    private class ReferenceCountedAction {

      /// <summary>
      ///   Initializes a new reference counted action starting with a reference count of 1
      /// </summary>
      /// <param name="action">Action that will be reference counted</param>
      public ReferenceCountedAction(Action action) {
        this.ReferenceCount = 1;
        this.Action = action;
      }

      /// <summary>Number of references that exist to this action</summary>
      public int ReferenceCount;
      /// <summary>Action that needs to be update</summary>
      public Action Action;

    }

    #endregion // class ReferenceCountedAction

    /// <summary>Initializes a new input mapper</summary>
    public InputMapper() {
      this.keyMappings = new List<KeyMapping>();
      this.axisMappings = new List<AxisMapping>();
      this.actionsToUpdate = new List<ReferenceCountedAction>();
      this.actions = new ActionCollection();
      this.actions.ActionsCleared += actionsCleared;
      this.actions.ActionRemoved += actionRemoved;
    }

    /// <summary>Actions that have been set up for binding inputs</summary>
    public IActionCollection Actions {
      get { return this.actions; }
    }

    /// <summary>Creates a new input action ready for binding</summary>
    /// <param name="name">Name of the action that will be created</param>
    /// <returns>The newly created action</returns>
    /// <remarks>
    ///   If an action with the same name already exists, the existing action will
    ///   be returned.
    /// </remarks>
    public IAction CreateAction(string name) {
      return CreateAction(name, null);
    }

    /// <summary>Creates a new input action ready for binding</summary>
    /// <param name="name">Name of the action that will be created</param>
    /// <returns>The newly created action</returns>
    /// <remarks>
    ///   If an action with the same name already exists, the existing action will
    ///   be returned.
    /// </remarks>
    public IAction CreateAction(string name, string description) {
      IAction action;
      if(this.actions.TryGet(name, out action)) {
        return action;
      } else {
        var actionImplementation = new Action(name, description);
        actionImplementation.AddObserver(this);
        this.actions.InternalAdd(actionImplementation);
        return actionImplementation;
      }
    }

    /// <summary>Updates the states of all inputs in Unity if needed</summary>
    /// <remarks>
    ///   <para>
    ///     Writing an input manager that relies on Update() or FixedUpdate() always runs
    ///     the risk that it will update somewhere between other game objects (as the update
    ///     order is undefined). If the game object carrying the InputMapper ends up near
    ///     the beginning of the update queue, input will be fresh. If it's near the end
    ///     of the udpate queue, input will already be one frame old when it's checked.
    ///   </para>
    ///   <para>
    ///     To avoid any lag, you can call this method before processing any input to
    ///     ensure that the input update for the current frame is performed before querying
    ///     any inputs.
    ///   </para>
    /// </remarks>
    public void UpdateIfNeeded() {
      float time = Time.time;
      if((time > this.lastUpdateTime) || (!this.currentFrameUpdateDone)) {

        // Always reset the triggered flags, so that even if the user is handling inputs
        // from within FixedUpdate(), the WasTriggered flags will be cleared again.
        resetTriggeredFlags();

        // Only re-query the actual inputs if we're being called from Update(). There's no
        // point in doing this from FixedUpdate() because Unity only updated its inputs once
        // per visual frame.
        if(!this.currentFrameUpdateDone) {
          resetActionStates();
          collectKeyInputs();
          collectAxisInputs();
          applyCollectedInputs();

          this.currentFrameUpdateDone = true;
        }

        this.lastUpdateTime = time;
      }
    }

    /// <summary>Called once per visual frame to update the scene</summary>
    protected void Update() {
      UpdateIfNeeded();
    }

    /// <summary>Called once per physics frame</summary>
    protected void FixedUpdate() {
      UpdateIfNeeded();
    }

    /// <summary>Called after all normal update functions have finished</summary>
    protected void LateUpdate() {
      this.currentFrameUpdateDone = false;
    }

    /// <summary>Called when all bindings have been removed from an action</summary>
    /// <param name="action">Action from which all bindings are being removed</param>
    void Action.IBindingObserver.RemovingAllBindings(Action action) {
      removeKeyMappingsForAction(action);
      removeAxisMappingsForAction(action);

      // We can skip reference counting here because we know the reference count
      // will be 0 after all mappings have been removed!
      int actionIndex = getActionToUpdateIndex(action);
      if(actionIndex != -1) {
        clearAction(this.actionsToUpdate[actionIndex].Action);
        this.actionsToUpdate.RemoveAt(actionIndex);
      }
    }

    /// <summary>Called when a key or button binding was added to an action</summary>
    /// <param name="action">Action the key or button binding was added to</param>
    /// <param name="key">Key or button that was bound to the action</param>
    void Action.IBindingObserver.KeyBindingAdded(Action action, KeyCode key) {
      int keyMappingIndex = getKeyMappingIndex(key);

      KeyMapping keyMapping;
      if(keyMappingIndex == -1) {
        keyMapping = new KeyMapping() {
          Key = key,
          Actions = new List<Action>()
        };
        this.keyMappings.Add(keyMapping);
      } else {
        keyMapping = this.keyMappings[keyMappingIndex];
      }

      keyMapping.Actions.Add(action);
      addToUpdateList(action);
    }

    /// <summary>Called when a key or button binding is removed from an action</summary>
    /// <param name="action">Action the key or button binding was removed from</param>
    /// <param name="key">Key or button that was removed from the action</param>
    void Action.IBindingObserver.KeyBindingRemoved(Action action, KeyCode key) {
      int keyMappingIndex = getKeyMappingIndex(key);
      if(keyMappingIndex == -1) {
        Debug.LogWarning(
          "Internal inconsistency: tried to remove key binding '" + key.ToString() + "' " +
          "from the mappings when it wasn't in it."
        );
      } else {
        this.keyMappings[keyMappingIndex].Actions.Remove(action);
        if(this.keyMappings[keyMappingIndex].Actions.Count == 0) {
          this.keyMappings.RemoveAt(keyMappingIndex);
        }

        removeFromUpdateList(action);
      }
    }

    /// <summary>Called when a joystick axis binding was added to an action</summary>
    /// <param name="action">Action the joystick axis binding was added to</param>
    /// <param name="axis">Joystick axis that was bound to the action</param>
    void Action.IBindingObserver.axisAdded(Action action, JoystickAxis axis) {
      int axisMappingIndex = getAxisMappingIndex(axis);

      AxisMapping axisMapping;
      if(axisMappingIndex == -1) {
        axisMapping = new AxisMapping() {
          Axis = axis,
          Actions = new List<Action>()
        };
        this.axisMappings.Add(axisMapping);
      } else {
        axisMapping = this.axisMappings[axisMappingIndex];
      }

      axisMapping.Actions.Add(action);
      addToUpdateList(action);
    }

    /// <summary>Called when a joystick axis binding was removed from an action</summary>
    /// <param name="action">Action the joystick axis binding was removed from</param>
    /// <param name="axis">Joystick axis that was removed from the action</param>
    void Action.IBindingObserver.axisRemoved(Action action, JoystickAxis axis) {
      int axisMappingIndex = getAxisMappingIndex(axis);
      if(axisMappingIndex == -1) {
        Debug.LogWarning(
          "Internal inconsistency: tried to remove axis binding '" + axis.ToString() + "' " +
          "from the mappings when it wasn't in it."
        );
      } else {
        this.axisMappings[axisMappingIndex].Actions.Remove(action);
        if(this.axisMappings[axisMappingIndex].Actions.Count == 0) {
          this.axisMappings.RemoveAt(axisMappingIndex);
        }

        removeFromUpdateList(action);
      }
    }

    /// <summary>Resets the states of all actions to prepare for an update</summary>
    private void resetActionStates() {
      for(int index = 0; index < this.actionsToUpdate.Count; ++index) {
        this.actionsToUpdate[index].Action.State = 0.0f;
      }
    }

    /// <summary>
    ///   Collects inputs for keys on the keyboard and buttons on the joysticks
    /// </summary>
    private void collectKeyInputs() {
      for(int index = 0; index < this.keyMappings.Count; ++index) {
        if(UnityInput.GetKey(this.keyMappings[index].Key)) {
          IList<Action> actionList = this.keyMappings[index].Actions;
          for(int actionIndex = 0; actionIndex < actionList.Count; ++actionIndex) {
            actionList[actionIndex].State = 1.0f;
          }
        }
      }
    }

    /// <summary>Collects inputs for the joystick axes</summary>
    private void collectAxisInputs() {
      for(int index = 0; index < this.axisMappings.Count; ++index) {
        float state = UnityInput.GetAxisRaw(this.axisMappings[index].Axis.AxisName);
        if(this.axisMappings[index].Axis.IsNegative) {
          state = -state;
        }

        IList<Action> actionList = this.axisMappings[index].Actions;
        for(int actionIndex = 0; actionIndex < actionList.Count; ++actionIndex) {
          if(actionList[actionIndex].State < state) {
            actionList[actionIndex].State = state;
          }
        }
      }
    }

    /// <summary>Applies the collected input states to the actions</summary>
    private void applyCollectedInputs() {
      for(int index = 0; index < this.actionsToUpdate.Count; ++index) {
        Action action = this.actionsToUpdate[index].Action;
        if(action.State > 0.667f) {
          if(!action.IsActive) {
            action.IsActive = true;
            action.WasTriggered = true;
          }
        } else if(action.State < 0.333f) {
          action.IsActive = false;
        }
      }
    }

    /// <summary>
    ///   Resets the triggered flags for all actions the user has checked
    /// </summary>
    private void resetTriggeredFlags() {
      for(int index = 0; index < this.actionsToUpdate.Count; ++index) {
        if(this.actionsToUpdate[index].Action.WasChecked) {
          this.actionsToUpdate[index].Action.WasTriggered = false;
          this.actionsToUpdate[index].Action.WasChecked = false;
        }
      }
    }

    /// <summary>Called when an action has been removed from the action collection</summary>
    /// <param name="sender">Action collection from which the action was removed</param>
    /// <param name="action">Action that has been removed from the collection</param>
    private void actionRemoved(ActionCollection sender, IAction action) {
      removeKeyMappingsForAction(action);
      removeAxisMappingsForAction(action);

      int actionIndex = getActionToUpdateIndex(action);
      if(actionIndex != -1) {
        this.actionsToUpdate.RemoveAt(actionIndex);
      }

      Action actionImplementation = action as Action;
      if(actionImplementation != null) {
        actionImplementation.RemoveObserver(this);
        clearAction(actionImplementation);
      }
    }

    /// <summary>Removes the specified action from all key mappings</summary>
    /// <param name="action">Action that will be removed from all key mappings</param>
    /// <returns>From how many mappings the action was removed</returns>
    private void removeKeyMappingsForAction(IAction action) {
      for(int index = 0; index < this.keyMappings.Count; ) {
        IList<Action> actionList = this.keyMappings[index].Actions;
        for(int actionIndex = 0; actionIndex < actionList.Count; ++actionIndex) {
          if(ReferenceEquals(actionList[actionIndex], action)) {
            actionList.RemoveAt(actionIndex);
            break;
          }
        }
        if(actionList.Count == 0) {
          this.keyMappings.RemoveAt(index);
        } else {
          ++index;
        }
      }
    }

    /// <summary>Removes the specified action from all axis mappings</summary>
    /// <param name="action">Action that will be removed from all axis mappings</param>
    private void removeAxisMappingsForAction(IAction action) {
      for(int index = 0; index < this.axisMappings.Count; ) {
        IList<Action> actionList = this.axisMappings[index].Actions;
        for(int actionIndex = 0; actionIndex < actionList.Count; ++actionIndex) {
          if(ReferenceEquals(actionList[actionIndex], action)) {
            actionList.RemoveAt(actionIndex);
            break;
          }
        }
        if(actionList.Count == 0) {
          this.axisMappings.RemoveAt(index);
        } else {
          ++index;
        }
      }
    }

    /// <summary>Called when the action collection has been cleared of its contents</summary>
    /// <param name="sender">Action collection that has been cleared</param>
    private void actionsCleared(ActionCollection sender) {
      for(int index = 0; index < this.actionsToUpdate.Count; ++index) {
        clearAction(this.actionsToUpdate[index].Action);
      }

      this.keyMappings.Clear();
      this.axisMappings.Clear();
      this.actionsToUpdate.Clear();
    }

    /// <summary>Looks up the index of the mapping for the specified key</summary>
    /// <param name="key">Key for which the mapping will be looked up</param>
    /// <returns>The index of the mapping for the specified key or -1 if not found</returns>
    private int getKeyMappingIndex(KeyCode key) {
      for(int index = 0; index < this.keyMappings.Count; ++index) {
        if(this.keyMappings[index].Key == key) {
          return index;
        }
      }

      return -1;
    }

    /// <summary>Looks up the index of the mapping for the specified axis</summary>
    /// <param name="axis">Axis for which the mapping will be looked up</param>
    /// <returns>The index of the mapping for the specified axis or -1 if not found</returns>
    private int getAxisMappingIndex(JoystickAxis axis) {
      for(int index = 0; index < this.axisMappings.Count; ++index) {
        if(this.axisMappings[index].Axis == axis) {
          return index;
        }
      }

      return -1;
    }

    /// <summary>Adds an action to the update list</summary>
    /// <param name="action">Action that will be added to the update list</param>
    /// <remarks>
    ///   Should be called when an input binding was made to the action. An action
    ///   counts the number of references that exist to it, so adding it to the update
    ///   list twice means it has to be removed twice, too.
    /// </remarks>
    private void addToUpdateList(Action action) {
      int actionIndex = getActionToUpdateIndex(action);
      if(actionIndex == -1) {
        this.actionsToUpdate.Add(new ReferenceCountedAction(action));
      } else {
        ++this.actionsToUpdate[actionIndex].ReferenceCount;
      }
    }

    /// <summary>Removes the specified action from the update list</summary>
    /// <param name="action">Action that will be removed from the update list</param>
    private void removeFromUpdateList(Action action) {
      int actionIndex = getActionToUpdateIndex(action);
      if(actionIndex == -1) {
        Debug.LogWarning(
          "Internal inconsistency: tried to remove action '" + action.Name + "' from " +
          "the update list when it wasn't in it."
        );
      } else {
        --this.actionsToUpdate[actionIndex].ReferenceCount;
        if(this.actionsToUpdate[actionIndex].ReferenceCount == 0) {
          clearAction(this.actionsToUpdate[actionIndex].Action);
        }
      }
    }

    /// <summary>Looks up the index of an action in the actions-to-update list</summary>
    /// <param name="action">Action whose index will be looked up</param>
    /// <returns>The index of the action in the list if found, -1 otherwise</returns>
    private int getActionToUpdateIndex(IAction action) {
      for(int index = 0; index < this.actionsToUpdate.Count; ++index) {
        if(ReferenceEquals(this.actionsToUpdate[index].Action, action)) {
          return index;
        }
      }

      return -1;
    }

    /// <summary>Disconnects an action from the input mapper</summary>
    /// <param name="action">Action that will be disconnected</param>
    private void clearAction(Action action) {
      action.IsActive = false;
      action.WasTriggered = false;
      action.WasChecked = false;
      action.State = 0.0f;
    }

    /// <summary>Actions that have been set up</summary>
    private ActionCollection actions;

    /// <summary>Keys or buttons and the actions they have been mapped to</summary>
    private IList<KeyMapping> keyMappings;
    /// <summary>Joystick axes and the actions they have been mapped to</summary>
    private IList<AxisMapping> axisMappings;
    /// <summary>Actions that have inputs mapped to them</summary>
    private IList<ReferenceCountedAction> actionsToUpdate;

    /// <summary>Time at which the input mapper last updated its inputs</summary>
    private float lastUpdateTime;
    /// <summary>Whether the input mapper update for the current frame is already done</summary>
    private bool currentFrameUpdateDone;

  }

} // namespace Framework.Input