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

namespace Framework.Input {

  /// <summary>Collection with change notifications and a no-duplicates policy</summary>
  /// <typeparam name="TItem">Type of items the collection will manage</typeparam>
  public class ObservableUniqueCollection<TItem> : Collection<TItem> {

    #region interface IObserver

    /// <summary>Interface through which the collection sends change notifications</summary>
    public interface IObserver {

      /// <summary>Called when an item is removed from the collection</summary>
      /// <param name="item">Item that has been removed from the collection</param>
      void ItemAdded(TItem item);

      /// <summary>Called when an item is added to the collection</summary>
      /// <param name="item">Item that has been added to the collection</param>
      void ItemRemoved(TItem item);

    }

    #endregion // interface IObserver

    /// <summary>Initializes a new observable unique collection</summary>
    public ObservableUniqueCollection() {
      this.observers = new List<IObserver>();
    }

    /// <summary>Adds an observer that will be notified of changes to the collection</summary>
    /// <param name="observer">Observer that will receive change notifications</param>
    public void AddObserver(IObserver observer) {
      this.observers.Add(observer);
    }

    /// <summary>Removes an observer from the collection</summary>
    /// <param name="observer">Observer that will no longer receive change notifications</param>
    public void RemoveObserver(IObserver observer) {
      this.observers.Remove(observer);
    }

    /// <summary>Removes all items from the collection without notifying observers</summary>
    public void ClearWithoutNotification() {
      Items.Clear();
    }

    /// <summary>Called when all items in the collection should be removed</summary>
    protected override void ClearItems() {
      for(int itemIndex = 0; itemIndex < Items.Count; ++itemIndex) {
        TItem item = Items[itemIndex];
        for(int index = 0; index < this.observers.Count; ++index) {
          this.observers[index].ItemRemoved(item);
        }
      }
      
      Items.Clear();
    }

    /// <summary>Called when an item should be removed from the collection</summary>
    /// <param name="index">Index of the item that should be removed</param>
    protected override void RemoveItem(int index) {
      TItem item = Items[index];
      Items.RemoveAt(index);

      for(index = 0; index < this.observers.Count; ++index) {
        this.observers[index].ItemRemoved(item);
      }
    }

    /// <summary>Called when an item should be added to the collection</summary>
    /// <param name="index">Index at which the item should be inserted</param>
    /// <param name="item">Item that should be inserted into the collection</param>
    protected override void InsertItem(int index, TItem item) {
      if(Items.Contains(item)) {
        return;
      }

      Items.Insert(index, item);

      for(index = 0; index < this.observers.Count; ++index) {
        this.observers[index].ItemAdded(item);
      }
    }

    /// <summary>Called when an item in the collection gets replaced</summary>
    /// <param name="index">Index of the item that will be replaced</param>
    /// <param name="item">Item that will replace the existing item</param>
    protected override void SetItem(int index, TItem item) {
      int existingIndex = base.IndexOf(item);
      if(existingIndex == -1) {
        TItem removedITem = Items[existingIndex];
        for(existingIndex = 0; existingIndex < this.observers.Count; ++existingIndex) {
          this.observers[existingIndex].ItemRemoved(removedITem);
        }

        Items[index] = item;

        for(index = 0; index < this.observers.Count; ++index) {
          this.observers[index].ItemAdded(item);
        }
      } else if(existingIndex != index) {
        TItem removedItem = Items[index];
        Items.RemoveAt(index);
        for(index = 0; index < this.observers.Count; ++index) {
          this.observers[index].ItemRemoved(removedItem);
        }
      }
    }

    /// <summary>Stores the observers that have registered for this collection</summary>
    private IList<IObserver> observers;

  }

} // namespace Framework.Input