using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;


namespace ExtendedBaseTypes
{
    /// <summary>
    /// 
    /// </summary>
    [Serializable]
    public class NewItemEventArgs : EventArgs
    {
        #region Declarations
        private int m_nIndex = -1;
        private object m_oValue = null;
        #endregion Declarations

        #region Properties
        public int Index
        {
            get { return this.m_nIndex; }
            set { this.m_nIndex = value; }
        }

        public object Value
        {
            get { return this.m_oValue; }
            set { this.m_oValue = value; }
        }
        #endregion Properties

        #region Constructors
        public NewItemEventArgs(int _nIndex,object _oValue)
        {
            this.m_nIndex = _nIndex;
            this.m_oValue = _oValue;
        }
        #endregion Constructors
    }

    [Serializable]
    public class ItemEventArgs : EventArgs
    {
        #region Declarations
        private object m_oObject = null;
        private int m_nIndex = -1;
        #endregion Declarations

        #region Properties
        public object Item
        {
            get { return this.m_oObject; }
            set { this.m_oObject = value; }
        }

        public int Index
        {
            get { return this.m_nIndex; }
            set { this.m_nIndex = value; }
        }
        #endregion Properties

        #region Constructors
        public ItemEventArgs(object _oObject)
        {
            this.m_oObject = _oObject;
        }

        public ItemEventArgs(int _nIndex,object _oObject)
        {
            this.m_nIndex = _nIndex;
            this.m_oObject = _oObject;
        }

        public ItemEventArgs(int _nIndex)
        {
            this.m_nIndex = _nIndex;
            this.m_oObject = null;
        }
        #endregion Constructors
    }

	/// <summary>
	/// This custom list is needed to be informed about actual changes.
	/// </summary>
	/// <typeparam name="T"></typeparam>
	[Serializable]
	public class CCustomList<T> : List<T>, ICloneable
	{
		#region Declarations
		public delegate void ItemAddEventHandler(object sender, ItemEventArgs e);
		public delegate void ItemAddedEventHandler(object sender, ItemEventArgs e);
		public delegate void ItemInsertedEventHandler(object sender, ItemEventArgs e);
		public delegate void ItemsClearEventHandler(object sender, ItemEventArgs e);
		public delegate void ItemsClearCompleteEventHandler(object sender, ItemEventArgs e);
		public delegate void ItemSetEventHandler(object sender, ItemEventArgs e);
		public delegate void ItemSetCompleteEventHandler(object sender, ItemEventArgs e);
		public delegate void ItemValidateEventHandler(object sender, ItemEventArgs e);
		public delegate void ItemInsertEventHandler(object sender, NewItemEventArgs e);

		public delegate void ItemRemoveEventHandler(object sender, ItemEventArgs e);
		public delegate void ItemRemoveCompleteEventHandler(object sender, ItemEventArgs e);

		public event ItemInsertedEventHandler m_ItemInsertedEventHandler;
		public event ItemsClearEventHandler m_ItemClearEventHandler;
		public event ItemsClearCompleteEventHandler m_ItemClearCompleteEventHandler;
		public event ItemSetEventHandler m_ItemSetEventHandler;
		public event ItemSetCompleteEventHandler m_ItemSetCompleteEventHandler;
		public event ItemValidateEventHandler m_ItemValidateEventHandler;
		public event ItemInsertEventHandler m_ItemInsertEventHandler;

		public event ItemRemoveEventHandler m_ItemRemoveEventHandler;
		public event ItemRemoveCompleteEventHandler m_ItemRemoveCompleteEventHandler;
		#endregion Declarations

		#region Constructors
		public CCustomList()
		{
		}
		#endregion Constructors

		/// <summary>
		/// Adds the specified item of type T
		/// </summary>
		/// <param name="_tItem">The _t item.</param>
		public new virtual void Add(T _tItem)
		{
			OnInsert(this.Count - 1, _tItem);
			this.List.Add(_tItem);
			OnInsertComplete(this.IndexOf(_tItem), _tItem);
		}

		public new void Clear()
		{
			OnClear();
			base.Clear();
			OnClearComplete();
		}
		/// <summary>
		/// Removes the specified item of type T
		/// </summary>
		/// <param name="_item">The _item.</param>
		public new virtual void Remove(T _item)
		{
			int _nIndex = this.IndexOf(_item);
			OnRemove(_nIndex, _item);
			this.List.Remove(_item);
			OnRemoveComplete(_nIndex, _item);
		}

		public new virtual void RemoveRange(int _nIndex, int _nCount)
		{
			base.RemoveRange(_nIndex, _nCount);
		}

		/// <summary>
		/// Gets the range.
		/// </summary>
		/// <param name="_nIndex">Index of the _n.</param>
		/// <param name="_nCount">The _n count.</param>
		/// <returns></returns>
		public new virtual List<T> GetRange(int _nIndex, int _nCount)
		{
			List<T> tempList = new List<T>();
			for (int i = _nIndex; i < this.Count; i++)
			{
				tempList.Add(this[i]);
			}
			return tempList;
		}

		/// <summary>
		/// Adds the range.
		/// </summary>
		/// <param name="aItem">A item.</param>
		public virtual void AddRange(T[] aItem)
		{
			for (int i = 0; i < aItem.Length; i++)
			{
				this.Add(aItem[i]);
			}
		}

		/// <summary>
		/// Returns index of Element of Type t
		/// </summary>
		/// <param name="_tT">The _t T.</param>
		/// <returns></returns>
		public new int IndexOf(T _tT)
		{
			return this.List.IndexOf(_tT);
		}

		/// <summary>
		/// Gets the <see cref="T"/> with the specified index _nIndex
		/// </summary>
		/// <value></value>
		public new virtual T this[int _nIndex]
		{
			get { return (T)this.List[_nIndex]; }
			set
			{
				OnSet(_nIndex, base[_nIndex], value);
				this.List[_nIndex] = value;
				OnSetComplete(_nIndex, base[_nIndex], value);
			}
		}

		/// <summary>
		/// Called when [insert complete].
		/// </summary>
		/// <param name="_nIndex">Index of the _n.</param>
		/// <param name="_oValue">The _o value.</param>
		protected virtual void OnInsertComplete(int _nIndex, object _oValue)
		{
			if (this.m_ItemInsertedEventHandler != null)
			{
				this.m_ItemInsertedEventHandler(this, new ItemEventArgs(_nIndex, _oValue));
			}
		}

		/// <summary>
		/// Ruft eine <see cref="T:System.Collections.IList"></see> mit der Liste der Elemente in der <see cref="T:System.Collections.CollectionBase"></see>-Instanz ab.
		/// </summary>
		/// <value></value>
		/// <returns>Eine <see cref="T:System.Collections.IList"></see>, die die <see cref="T:System.Collections.CollectionBase"></see>-Instanz selbst darstellt.</returns>
		public IList List
		{
			get
			{
				return this;
			}
		}

		/// <summary>
		/// Determines whether [contains] [the specified _o value].
		/// </summary>
		/// <param name="_oValue">The _o value.</param>
		/// <returns>
		/// 	<c>true</c> if [contains] [the specified _o value]; otherwise, <c>false</c>.
		/// </returns>
		public bool Contains(object _oValue)
		{
			return this.List.Contains(_oValue);
		}

		/// <summary>
		/// Called when [clear].
		/// </summary>
		protected virtual void OnClear()
		{
			if (this.m_ItemClearEventHandler != null)
			{
				this.m_ItemClearEventHandler(this, null);
			}
		}

		/// <summary>
		/// executes after clearing contents of <see cref="T:System.Collections.CollectionBase"></see>-Instanz additional userdefined processes.
		/// </summary>
		protected virtual void OnClearComplete()
		{
			if (this.m_ItemClearCompleteEventHandler != null)
			{
				this.m_ItemClearCompleteEventHandler(this, null);
			}
		}

		/// <summary>
		/// executes additional processes before inserting of a new element in <see cref="T:System.Collections.CollectionBase"></see>-instance.
		/// </summary>
		/// <param name="index">Der nullbasierte Index, an dem value eingefügt werden soll.</param>
		/// <param name="value">Der neue Wert des Elements an index.</param>
		protected virtual void OnInsert(int index, object value)
		{
			if (this.m_ItemInsertEventHandler != null)
			{
				this.m_ItemInsertEventHandler(this, new NewItemEventArgs(index, value));
			}
		}

		/// <summary>
		/// calls additional userdefined processes by inserting into in <see cref="T:System.Collections.CollectionBase"></see>-Instanz aus.
		/// </summary>
		/// <param name="index">Der nullbasierte Index, an dem sich value befindet.</param>
		/// <param name="value">Der Wert des Elements, das an index entfernt wird.</param>
		protected virtual void OnRemove(int index, object value)
		{
			if (this.m_ItemRemoveEventHandler != null)
			{
				this.m_ItemRemoveEventHandler(this, new ItemEventArgs(index, value));
			}
		}

		/// <summary>
		/// Führt zusätzliche benutzerdefinierte Prozesse nach dem Entfernen eines Elements aus der <see cref="T:System.Collections.CollectionBase"></see>-Instanz aus.
		/// </summary>
		/// <param name="index">Der nullbasierte Index, an dem sich value befindet.</param>
		/// <param name="value">Der Wert des Elements, das an index entfernt wird.</param>
		protected virtual void OnRemoveComplete(int index, object value)
		{
			if (this.m_ItemRemoveCompleteEventHandler != null)
			{
				this.m_ItemRemoveCompleteEventHandler(this, new ItemEventArgs(index, value));
			}
		}

		/// <summary>
		/// Führt zusätzliche benutzerdefinierte Prozesse vor dem Festlegen eines Werts in der <see cref="T:System.Collections.CollectionBase"></see>-Instanz aus.
		/// </summary>
		/// <param name="index">Der nullbasierte Index, an dem sich oldValue befindet.</param>
		/// <param name="oldValue">Der Wert, der durch newValue ersetzt werden soll.</param>
		/// <param name="newValue">Der neue Wert des Elements an index.</param>
		protected virtual void OnSet(int index, object oldValue, object newValue)
		{
			if (this.m_ItemSetEventHandler != null)
			{
				this.m_ItemSetEventHandler(this, new ItemEventArgs(index));
			}
		}

		/// <summary>
		/// Führt zusätzliche benutzerdefinierte Prozesse nach dem Festlegen eines Werts in der <see cref="T:System.Collections.CollectionBase"></see>-Instanz aus.
		/// </summary>
		/// <param name="index">Der nullbasierte Index, an dem sich oldValue befindet.</param>
		/// <param name="oldValue">Der Wert, der durch newValue ersetzt werden soll.</param>
		/// <param name="newValue">Der neue Wert des Elements an index.</param>
		protected virtual void OnSetComplete(int index, object oldValue, object newValue)
		{
			if (this.m_ItemSetCompleteEventHandler != null)
			{
				this.m_ItemSetCompleteEventHandler(this, new ItemEventArgs(index));
			}
		}

		/// <summary>
		/// Führt zusätzliche benutzerdefinierte Prozesse beim Prüfen der Gültigkeit eines Werts aus.
		/// </summary>
		/// <param name="value">Das Objekt, dessen Gültigkeit geprüft werden soll.</param>
		protected virtual void OnValidate(object value)
		{
			if (this.m_ItemValidateEventHandler != null)
			{
				this.m_ItemValidateEventHandler(this, new ItemEventArgs(value));
			}
		}

		/// <summary>
		/// Creates a new object, representing a copy of the actual instance.
		/// </summary>
		/// <returns>
		/// new object representing copy of actual instance.
		/// </returns>
		public object Clone()
		{
			CCustomList<T> aList = new CCustomList<T>();
			foreach (object obj in this)
			{
				if (obj is ICloneable)
				{
					aList.Add((T)((ICloneable)obj).Clone());
				}
			}
			return aList;
		}
	}
}