using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;

namespace Framework.Input {
  
  /// <summary>Stores the input actions set up for a game</summary>
  internal class ActionCollection : Collection<IAction>, IActionCollection {

    /// <summary>Called before all actions are removed from the collection</summary>
    public event Action<ActionCollection> ActionsCleared;
    /// <summary>Called after a single action has been removed from the collection</summary>
    public event Action<ActionCollection, IAction> ActionRemoved;

    /// <summary>Accesses an action by its name</summary>
    /// <param name="actionName">Name of the action that will be accessed</param>
    /// <returns>The action with the specified name</returns>
    public IAction this[string actionName] {
      get {
        int index = IndexOf(actionName);
        if(index == -1) {
          throw new ArgumentException(
            "An action with the specified name does not exist", "actionName"
          );
        } else {
          return Items[index];
        }
      }
    }

    /// <summary>Tries to look up an action by its name</summary>
    /// <param name="actionName">Name of the action that will be looked up</param>
    /// <param name="action">Receives the action, if found</param>
    /// <returns>True if the action was found, false otherwise</returns>
    public bool TryGet(string actionName, out IAction action) {
      int index = IndexOf(actionName);
      if(index == -1) {
        action = null;
        return false;
      } else {
        action = Items[index];
        return true;
      }
    }

    /// <summary>Removes an action by its name</summary>
    /// <param name="actionName">Name of the action that will be removed</param>
    /// <returns>True if an action with the specified name was found and removed</returns>
    public bool Remove(string actionName) {
      int index = IndexOf(actionName);
      if(index == -1) {
        return false;
      } else {
        base.RemoveAt(index);
        return true;
      }
    }

    /// <summary>Checks whether the collection contains the specified action</summary>
    /// <param name="actionName">Action for which the collection will be checked</param>
    /// <returns>True if the collection contains an action with the specified name</returns>
    public bool Contains(string actionName) {
      return (IndexOf(actionName) != -1);
    }

    /// <summary>Adds an action to the collection from the input mapper</summary>
    /// <param name="action">Action that will be added</param>
    /// <remarks>
    ///   This circumvents the tampering check that prevents the user from re-adding
    ///   removed actions or some custom IAction implementation into the collection.
    /// </remarks>
    public void InternalAdd(Action action) {
      Items.Add(action);
    }

    /// <summary>Called when the user tries to replace an action with another</summary>
    /// <param name="index">Index of the action that should be overwritten</param>
    /// <param name="action">Action that should replace the existing one</param>
    protected override void SetItem(int index, IAction action) {
      throw new InvalidOperationException(
        "You cannot replace actions in this collection"
      );
    }

    /// <summary>Called when the user tries to insert an action into the collection</summary>
    /// <param name="index">Index at which the action should be inserted</param>
    /// <param name="action">Action that should be inserted</param>
    protected override void InsertItem(int index, IAction action) {
      throw new InvalidOperationException(
        "You cannot insert your own actions into this collection"
      );
    }

    /// <summary>Called when the user has removed all actions from the collection</summary>
    protected override void ClearItems() {
      base.ClearItems();

      if(this.ActionsCleared != null) {
        this.ActionsCleared(this);
      }
    }

    /// <summary>Called when the user has removed a single action from the collection</summary>
    /// <param name="index">Index of the item that wil be removed</param>
    protected override void RemoveItem(int index) {
      if(this.ActionRemoved != null) {
        this.ActionRemoved(this, Items[index]);
      }

      base.RemoveItem(index);
    }

    /// <summary>Returns the index of the specified action</summary>
    /// <param name="actionName">Name of the action whose index will be determined</param>
    /// <returns>The index of the specified action or -1 if not found</returns>
    protected int IndexOf(string actionName) {
      bool ignoreCase = true;

      IList<IAction> items = Items;
      for(int index = 0; index < items.Count; ++index) {
        if(string.Compare(items[index].Name, actionName, ignoreCase) == 0) {
          return index;
        }
      }

      return -1;
    }

  }

} // namespace Framework.Input