using System;
using System.Collections.Generic;

using UnityEngine;

namespace Framework.Input {

  /// <summary>Action that combines any number of input devices</summary>
  internal class Action :
    IAction,
    ObservableUniqueCollection<KeyCode>.IObserver,
    ObservableUniqueCollection<JoystickAxis>.IObserver {

    #region interface IBindingObserver

    /// <summary>Interface through which the action notifies its observers of changes</summary>
    public interface IBindingObserver {

      /// <summary>Called when all bindings are about to be removed from the action</summary>
      /// <param name="action">Action from which all bindings are being removed</param>
      void RemovingAllBindings(Action action);

      /// <summary>Called when a key or joystick button has been bound</summary>
      /// <param name="action">Action to which the key or button has been bound</param>
      /// <param name="keyCode">Key or button that has been bound</param>
      void KeyBindingAdded(Action action, KeyCode keyCode);

      /// <summary>Called when a key or joystick button binding has been removed</summary>
      /// <param name="action">Action from which the key or button has been removed</param>
      /// <param name="keyCode">Key or button that is no longer bound</param>
      void KeyBindingRemoved(Action action, KeyCode keyCode);

      /// <summary>Called when a joystick axis has been bound</summary>
      /// <param name="action">Action to which the joystick axis has been bound</param>
      /// <param name="axis">Joystick axis that has been bound</param>
      void axisAdded(Action action, JoystickAxis axis);

      /// <summary>Called when a joystick axis binding has been removed</summary>
      /// <param name="action">Action from which the joystick axis has been removed</param>
      /// <param name="axis">Joystick axis that is no longer bound</param>
      void axisRemoved(Action action, JoystickAxis axis);

    }

    #endregion // interface IBindingObserver

    /// <summary>Initializes a new action</summary>
    /// <param name="name">Name that uniquely identifies the action</param>
    /// <param name="description">Describes what the action is used for</param>
    public Action(string name, string description) {
      this.name = name;
      this.description = description;

      this.observers = new List<IBindingObserver>();
      this.keyBindings = new ObservableUniqueCollection<KeyCode>();
      this.keyBindings.AddObserver(this);
      this.axisBindings = new ObservableUniqueCollection<JoystickAxis>();
      this.axisBindings.AddObserver(this);
    }

    /// <summary>Adds a binding observer to the action</summary>
    /// <param name="observer">Observer that will get notified of binding changes</param>
    public void AddObserver(IBindingObserver observer) {
      this.observers.Add(observer);
    }

    /// <summary>Removes a binding observer from the action</summary>
    /// <param name="observer">Observer that will no longer get notified</param>
    public void RemoveObserver(IBindingObserver observer) {
      this.observers.Remove(observer);
    }

    /// <summary>Unique name of the action</summary>
    public string Name {
      get { return this.name; }
    }

    /// <summary>Describes what purpose the action serves</summary>
    /// <remarks>
    ///   Can be displayed to the user in the key binding screen, for example,
    ///   to explain what the action does.
    /// </remarks>
    public string Description {
      get { return this.description; }
    }

    /// <summary>Keys and buttons that have been bound to this action</summary>
    /// <remarks>
    ///   Simply adding a key or button to this collection will bind it.
    /// </remarks>
    public ICollection<KeyCode> BoundKeys {
      get { return this.keyBindings; }
    }

    /// <summary>Joystick axes that have been bound to this action</summary>
    /// <remarks>
    ///   Simply adding a joystick axis to this collection will bind it.
    /// </remarks>
    public ICollection<JoystickAxis> BoundJoystickAxes {
      get { return this.axisBindings; }
    }

    /// <summary>Whether the action is currently active</summary>
    /// <remarks>
    ///   If joystick axes are bound to this action, it becomes active when the axis
    ///   goes over 67% and inactive when the axis goes under 33%.  This prevents
    ///   flickering of the input between active/inactive if the axis has noise.
    /// </remarks>
    public bool IsActive {
      get { return this.isActive; }
      set { this.isActive = value; }
    }

    /// <summary>Whether the action has become active since it was last checked</summary>
    /// <remarks>
    ///   This goes high as soon as the action becomes active and is only reset
    ///   in the next update phase after it has been queried at least once.
    /// </remarks>
    public bool WasTriggered {
      get {
        this.WasChecked = true;
        return this.wasTriggered;
      }
      set { this.wasTriggered = value; }
    }

    /// <summary>Analogue state of the action</summary>
    /// <remarks>
    ///   If keys or buttons are bound to the action, these will immediately result
    ///   in a value of 1.0. Analogue axes will result in v
    /// </remarks>
    public float State {
      get { return this.state; }
      set { this.state = value; }
    }

    /// <summary>Removes all bound keys, buttons and axes from the action</summary>
    public void RemoveAllBindings() {
      for(int index = 0; index < this.observers.Count; ++index) {
        this.observers[index].RemovingAllBindings(this);
      }

      this.keyBindings.ClearWithoutNotification();
      this.axisBindings.ClearWithoutNotification();
    }

    /// <summary>Whether the action is no longer part of the input mapper</summary>
    public bool IsAbandoned {
      get { return (this.observers.Count == 0); }
    }

    /// <summary>Called when a key or button is added to the bound keys</summary>
    /// <param name="key">Key or button that has been bound to this action</param>
    void ObservableUniqueCollection<KeyCode>.IObserver.ItemAdded(KeyCode key) {
      for(int index = 0; index < this.observers.Count; ++index) {
        this.observers[index].KeyBindingAdded(this, key);
      }
    }

    /// <summary>Called when a key or button is removed from the bound keys</summary>
    /// <param name="key">Key or button that has been unbound from this action</param>
    void ObservableUniqueCollection<KeyCode>.IObserver.ItemRemoved(KeyCode key) {
      for(int index = 0; index < this.observers.Count; ++index) {
        this.observers[index].KeyBindingRemoved(this, key);
      }
    }

    /// <summary>Called when a joystick axis is added to the bound axes</summary>
    /// <param name="axis">Joystick axis that has been bound to this action</param>
    void ObservableUniqueCollection<JoystickAxis>.IObserver.ItemAdded(JoystickAxis axis) {
      for(int index = 0; index < this.observers.Count; ++index) {
        this.observers[index].axisAdded(this, axis);
      }
    }

    /// <summary>Called when a joystick axis is removed from the bound axes</summary>
    /// <param name="axis">Joystick axis that has been unbound from this action</param>
    void ObservableUniqueCollection<JoystickAxis>.IObserver.ItemRemoved(JoystickAxis axis) {
      for(int index = 0; index < this.observers.Count; ++index) {
        this.observers[index].axisRemoved(this, axis);
      }
    }

    /// <summary>
    ///   Whether the action's triggered state has been checked this update cycle
    /// </summary>
    public bool WasChecked;

    /// <summary>Unique name of the action</summary>
    private string name;
    /// <summary>Describes what purpose the action serves</summary>
    private string description;
    /// <summary>Whether the action is currently active (pressed/moved)</summary>
    private bool isActive;
    /// <summary>Whether the action has been active since it was last checked</summary>
    private bool wasTriggered;
    /// <summary>Current analogue state of the action</summary>
    private float state;

    /// <summary>Keys that have been bound to the action</summary>
    private ObservableUniqueCollection<KeyCode> keyBindings;
    /// <summary>Joystick axes that have been bound to the action</summary>
    private ObservableUniqueCollection<JoystickAxis> axisBindings;

    /// <summary>Observers that receive notifications to binding changes</summary>
    private IList<IBindingObserver> observers;

  }

} // namespace Framework.Input