using System;

using System.Collections;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Diagnostics;

using BLToolkit.EditableObjects;
using BLToolkit.Reflection;

namespace BLToolkit.ComponentModel
{
	public class BindingListImpl: IBindingListView, ICancelAddNew, INotifyCollectionChanged
	{
		#region Init

		public BindingListImpl(IList list, Type itemType)
		{
			if (list     == null) throw new ArgumentNullException("list");
			if (itemType == null) throw new ArgumentNullException("itemType");

			_list     = list;
			_itemType = itemType;

			AddInternal(_list);
		}

		#endregion

		#region Protected Members

		private readonly IList _list;
		private readonly Type  _itemType;

		private void ApplySort(IComparer comparer)
		{
			if (_list is ISortable)
				((ISortable)_list).Sort(0, _list.Count, comparer);
			else if (_list is ArrayList)
				((ArrayList)_list).Sort(0, _list.Count, comparer);
			else if (_list is Array)
				Array.Sort((Array)_list, comparer);
			else
			{
				object[] items = new object[_list.Count];

				_list.CopyTo(items, 0);
				Array.Sort(items, comparer);

				for (int i = 0; i < _list.Count; i++)
					_list[i] = items[i];
			}

			_isSorted = true;
		}

		#endregion

		#region IBindingList Members

			#region Command

		private int               _newItemIndex = -1;
		private INotifyObjectEdit _newObject;

		public object AddNew()
		{
			if (AllowNew == false)
				throw new NotSupportedException();

			EndNew();

			object   o = TypeAccessor.CreateInstanceEx(_itemType);
			_newObject = o as INotifyObjectEdit;

			if (_newObject != null)
				_newObject.ObjectEdit += NewObject_ObjectEdit;

			_newItemIndex = _list.Add(o);
			OnAddItem(o, _newItemIndex);

			Debug.WriteLine(string.Format("AddNew - ({0})", o.GetType().Name));

			return o;
		}

		void NewObject_ObjectEdit(object sender, ObjectEditEventArgs args)
		{
			if (sender == _newObject)
			{
				switch (args.EditType)
				{
					case ObjectEditType.End:    EndNew();                 break;
					case ObjectEditType.Cancel: CancelNew(_newItemIndex); break;
					default:                    return;
				}
			}
		}

		public bool AllowNew
		{
			get { return !_list.IsFixedSize; }
		}

		public bool AllowEdit
		{
			get { return !_list.IsReadOnly; }
		}

		public bool AllowRemove
		{
			get { return !_list.IsFixedSize; }
		}

			#endregion

			#region Change Notification

		private bool _notifyChanges = true;
		public  bool  NotifyChanges
		{
			get { return _notifyChanges; }
			set { _notifyChanges = value; }
		}

		public bool SupportsChangeNotification
		{
			get { return true; }
		}

		public event ListChangedEventHandler ListChanged;

		private void FireListChangedEvent(object sender, ListChangedEventArgs e)
		{
			if (_notifyChanges && ListChanged != null)
				ListChanged(sender, e);
		}

		protected virtual void OnListChanged(EditableListChangedEventArgs e)
		{
			FireListChangedEvent(this, e);
		}

		protected void OnListChanged(ListChangedType listChangedType, int index)
		{
			OnListChanged(new EditableListChangedEventArgs(listChangedType, index));
		}

		private void ItemPropertyChanged(object sender, PropertyChangedEventArgs e)
		{
			if (_notifyChanges && sender != null)
			{
				int indexOfSender = _list.IndexOf(sender);

				if (indexOfSender >= 0)
				{
					MemberAccessor ma = TypeAccessor.GetAccessor(sender.GetType())[e.PropertyName];

					if (ma != null)
						OnListChanged(new EditableListChangedEventArgs(indexOfSender, ma.PropertyDescriptor));
					else
						OnListChanged(new EditableListChangedEventArgs(ListChangedType.ItemChanged, indexOfSender));

					// Do not fire an event for OnCollectionChanged here.

					if (_isSorted && _list.Count > 1)
					{
						int newIndex = GetItemSortedPosition(indexOfSender, sender);

						if (newIndex != indexOfSender)
						{
							_list.RemoveAt(indexOfSender);
							_list.Insert(newIndex, sender);

							OnMoveItem(sender, indexOfSender, newIndex);
						}
					}
				}
			}
		}

		#endregion

			#region Sorting

		public bool SupportsSorting
		{
			get { return true; }
		}

		[NonSerialized]
		private bool _isSorted;
		public  bool  IsSorted
		{
			get { return _isSorted; }
		}

		[NonSerialized]
		private PropertyDescriptor _sortProperty;
		public  PropertyDescriptor  SortProperty
		{
			get { return _sortProperty; }
		}

		[NonSerialized]
		private ListSortDirection _sortDirection;
		public  ListSortDirection  SortDirection
		{
			get { return _sortDirection; }
		}

		public void ApplySort(PropertyDescriptor property, ListSortDirection direction)
		{
			Debug.WriteLine(string.Format("Begin ApplySort(\"{0}\", {1})", property.Name, direction));

			_sortProperty  = property;
			_sortDirection = direction;
			_sortDescriptions = null;

			ApplySort(GetSortComparer(_sortProperty, _sortDirection));

			if (_list.Count > 0)
				OnReset();

			Debug.WriteLine(string.Format("End   ApplySort(\"{0}\", {1})", property.Name, direction));
		}

		public void RemoveSort()
		{
			_isSorted     = false;
			_sortProperty = null;
			_sortDescriptions = null;

			OnReset();
		}

			#endregion

			#region Searching

		public bool SupportsSearching
		{
			get { return true; }
		}

		public int Find(PropertyDescriptor property, object key)
		{
			if (property == null) throw new ArgumentException("property");

			if (key != null)
				for (int i = 0; i < _list.Count; i++)
					if (key.Equals(property.GetValue(_list[i])))
						return i;

			return -1;
		}

			#endregion

			#region Indexes

		public void AddIndex(PropertyDescriptor property)
		{
		}

		public void RemoveIndex(PropertyDescriptor property)
		{
		}

			#endregion

		#endregion

		#region ICancelAddNew Members

		public void CancelNew(int itemIndex)
		{
			if (itemIndex >= 0 && itemIndex == _newItemIndex)
			{
				_list.RemoveAt(itemIndex);
				OnRemoveItem(_newObject, itemIndex);
				EndNew();
			}
		}

		public void EndNew(int itemIndex)
		{
			if (itemIndex == _newItemIndex)
				EndNew();
		}

		public void EndNew()
		{
			_newItemIndex = -1;

			if (_newObject != null)
				_newObject.ObjectEdit -= NewObject_ObjectEdit;

			_newObject = null;
		}

		#endregion

		#region IList Members

		public int Add(object value)
		{
			int index;
			
			if (!_isSorted)
				index = _list.Add(value);
			else
			{
				index = GetSortedInsertIndex(value);
				_list.Insert(index, value);
			}

			AddInternal(value);
			OnAddItem(value, index);

			return index;
		}

		public void Clear()
		{
			if (_list.Count > 0)
			{
				RemoveInternal(_list);

				_list.Clear();
				OnReset();
			}
		}

		public bool Contains(object value)
		{
			return _list.Contains(value);
		}

		public int IndexOf(object value)
		{
			return _list.IndexOf(value);
		}

		public void Insert(int index, object value)
		{
			if (_isSorted)
				index = GetSortedInsertIndex(value);
			
			_list.Insert(index, value);
			AddInternal(value);

			OnAddItem(value, index);
		}

		public bool IsFixedSize
		{
			get { return _list.IsFixedSize; }
		}

		public bool IsReadOnly
		{
			get { return _list.IsReadOnly; }
		}

		public void Remove(object value)
		{
			int index = IndexOf(value);
			
			if (index >= 0)
				RemoveInternal(value);

			_list.Remove(value);

			if (index >= 0)
				OnRemoveItem(value, index);
		}

		public void RemoveAt(int index)
		{
			object value = this[index];

			RemoveInternal(value);

			_list.RemoveAt(index);

			OnRemoveItem(value, index);
		}

		public object this[int index]
		{
			get { return _list[index]; }
			set 
			{
				object o = _list[index];

				if (o != value)
				{
					RemoveInternal(o);
					
					_list[index] = value;

					AddInternal(value);

					OnChangeItem(o, value, index);

					if (_isSorted)
					{
						int newIndex = GetItemSortedPosition(index, value);
						
						if (newIndex != index)
						{
							_list.RemoveAt(index);
							_list.Insert(newIndex, value);
						}

						OnMoveItem(value, index, newIndex);
					}
				}
			}
		}

		#endregion

		#region ICollection Members

		public void CopyTo(Array array, int index)
		{
			_list.CopyTo(array, index);
		}

		public int Count
		{
			get { return _list.Count; }
		}

		public bool IsSynchronized
		{
			get { return _list.IsSynchronized; }
		}

		public object SyncRoot
		{
			get { return _list.SyncRoot; }
		}

		#endregion

		#region IEnumerable Members

		public IEnumerator GetEnumerator()
		{
			return _list.GetEnumerator();
		}

		#endregion

		#region SortPropertyComparer

		class SortPropertyComparer : IComparer
		{
			readonly PropertyDescriptor _property;
			readonly ListSortDirection  _direction;

			public SortPropertyComparer(PropertyDescriptor property, ListSortDirection direction)
			{
				_property  = property;
				_direction = direction;
			}

			public int Compare(object x, object y)
			{
				object a = _property.GetValue(x);
				object b = _property.GetValue(y);

				int n = Comparer.Default.Compare(a, b);

				return _direction == ListSortDirection.Ascending? n: -n;
			}
		}

		#endregion

		#region IComparer Accessor
		
		public IComparer GetSortComparer()
		{
			if (_isSorted)
			{
				if (_sortDescriptions != null)
					return GetSortComparer(_sortDescriptions);

				return GetSortComparer(_sortProperty, _sortDirection);
			}

			return null;
		}
		
		private IComparer GetSortComparer(PropertyDescriptor sortProperty, ListSortDirection sortDirection)
		{
			if (_sortSubstitutions.ContainsKey(sortProperty.Name))
				sortProperty = ((SortSubstitutionPair)_sortSubstitutions[sortProperty.Name]).Substitute;

			return new SortPropertyComparer(sortProperty, sortDirection);
		}

		private IComparer GetSortComparer(ListSortDescriptionCollection sortDescriptions)
		{
			bool needSubstitution = false;

			if (_sortSubstitutions.Count > 0)
			{
				foreach (ListSortDescription sortDescription in sortDescriptions)
				{
					if (_sortSubstitutions.ContainsKey(sortDescription.PropertyDescriptor.Name))
					{
						needSubstitution = true;
						break;
					}
				}

				if (needSubstitution)
				{
					ListSortDescription[] sorts = new ListSortDescription[sortDescriptions.Count];
					sortDescriptions.CopyTo(sorts, 0);

					for (int i = 0; i < sorts.Length; i++)
						if (_sortSubstitutions.ContainsKey(sorts[i].PropertyDescriptor.Name))
							sorts[i] = new ListSortDescription(((SortSubstitutionPair)_sortSubstitutions[sorts[i].PropertyDescriptor.Name]).Substitute, 
								                               sorts[i].SortDirection);

					sortDescriptions = new ListSortDescriptionCollection(sorts);
				}
			}

			return new SortListPropertyComparer(sortDescriptions);
		}
		
		#endregion

		#region IBindingListView Members

		public bool SupportsAdvancedSorting
		{
			get { return true; }
		}

		public void ApplySort(ListSortDescriptionCollection sorts)
		{
			_sortDescriptions = sorts;

			_isSorted = true;
			_sortProperty = null;
			
			ApplySort(GetSortComparer(sorts));

			if (_list.Count > 0)
				OnReset();
		}

		[NonSerialized]
		private ListSortDescriptionCollection _sortDescriptions;
		public  ListSortDescriptionCollection  SortDescriptions
		{
			get { return _sortDescriptions; }
		}

		public bool SupportsFiltering
		{
			get { return false; }
		}

		public string Filter
		{
			get { throw new NotImplementedException("The method 'BindingListImpl.get_Filter' is not implemented."); }
			set { throw new NotImplementedException("The method 'BindingListImpl.set_Filter' is not implemented."); }
		}

		public void RemoveFilter()
		{
			throw new NotImplementedException("The method 'BindingListImpl.RemoveFilter()' is not implemented.");
		}

		#endregion

		#region SortListPropertyComparer

		class SortListPropertyComparer : IComparer
		{
			readonly ListSortDescriptionCollection _sorts;

			public SortListPropertyComparer(ListSortDescriptionCollection sorts)
			{
				_sorts = sorts;
			}

			public int Compare(object x, object y)
			{
				for (int i = 0; i < _sorts.Count; i++)
				{
					PropertyDescriptor property = _sorts[i].PropertyDescriptor;

					object a = property.GetValue(x);
					object b = property.GetValue(y);

					int n = Comparer.Default.Compare(a, b);

					if (n != 0)
						return _sorts[i].SortDirection == ListSortDirection.Ascending? n: -n;
				}

				return 0;
			}
		}

		#endregion

		#region Sorting enhancement

		private readonly Hashtable _sortSubstitutions = new Hashtable();

		private class SortSubstitutionPair
		{
			public SortSubstitutionPair(PropertyDescriptor original, PropertyDescriptor substitute)
			{
				Original   = original;
				Substitute = substitute;
			}

			public readonly PropertyDescriptor Original;
			public readonly PropertyDescriptor Substitute;
		}

		public void CreateSortSubstitution(string originalProperty, string substituteProperty)
		{
			TypeAccessor typeAccessor = TypeAccessor.GetAccessor(_itemType);

			PropertyDescriptor originalDescriptor = typeAccessor.PropertyDescriptors[originalProperty];
			PropertyDescriptor substituteDescriptor = typeAccessor.PropertyDescriptors[substituteProperty];

			if (originalDescriptor == null)   throw new InvalidOperationException("Can not retrieve PropertyDescriptor for original property: " + originalProperty);
			if (substituteDescriptor == null) throw new InvalidOperationException("Can not retrieve PropertyDescriptor for substitute property: " + substituteProperty);

			_sortSubstitutions[originalProperty] = new SortSubstitutionPair(originalDescriptor, substituteDescriptor);
		}

		public void RemoveSortSubstitution(string originalProperty)
		{
			_sortSubstitutions.Remove(originalProperty);
		}

		#endregion

		#region Sort enforcement

		public int GetItemSortedPosition(int index, object sender)
		{
			IComparer comparer = GetSortComparer();

			if (comparer == null)
				return index;

			if ((index > 0 && comparer.Compare(_list[index - 1], sender) > 0) ||
				(index < _list.Count - 1 && comparer.Compare(_list[index + 1], sender) < 0))
			{
				for (int i = 0; i < _list.Count; i++)
				{
					if (i != index && comparer.Compare(_list[i], sender) > 0)
					{
						if (i > index)
							return i - 1;

						return i;
					}
				}

				return _list.Count - 1;
			}

			return index;
		}

		public int GetSortedInsertIndex(object value)
		{
			IComparer comparer = GetSortComparer();

			if (comparer == null)
				return -1;

			for (int i = 0; i < _list.Count; i++)
				if (comparer.Compare(_list[i], value) > 0)
					return i;

			return _list.Count;
		}

		#endregion

		#region Misc/Range Operations
		
		public void Move(int newIndex, int oldIndex)
		{
			if (oldIndex != newIndex)
			{
				EndNew();

				object o = _list[oldIndex];

				_list.RemoveAt(oldIndex);
				if (!_isSorted)
					_list.Insert(newIndex, o);
				else
					_list.Insert(newIndex = GetSortedInsertIndex(o), o);

				OnMoveItem(o, oldIndex, newIndex);
			}
		}
		
		public void AddRange(ICollection c)
		{
			foreach (object o in c)
			{
				if (!_isSorted)
					_list.Add(o);
				else
					_list.Insert(GetSortedInsertIndex(o), o);
			}

			AddInternal(c);

			OnReset();
		}
		
		public void InsertRange(int index, ICollection c)
		{
			if (c.Count == 0)
				return;
			
			foreach (object o in c)
			{
				if (!_isSorted)
					_list.Insert(index++, o);
				else
					_list.Insert(GetSortedInsertIndex(o), o);
			}

			AddInternal(c);

			OnReset();
		}
		
		public void RemoveRange(int index, int count)
		{
			object[] toRemove = new object[count];

			for (int i = index; i < _list.Count && i < index + count; i++)
				toRemove[i - index] = _list[i];
			
			RemoveInternal(toRemove);

			foreach (object o in toRemove)
				_list.Remove(o);

			OnReset();
		}
		
		public void SetRange(int index, ICollection c)
		{
			int cCount = c.Count;
			
			if (index < 0 || index >= _list.Count - cCount)
				throw new ArgumentOutOfRangeException("index");

			bool oldNotifyChanges = _notifyChanges;
			_notifyChanges = false;

			int i = index;
			foreach (object newObject in c)
			{
				RemoveInternal(_list[i + index]);
				_list[i + index] = newObject;
			}
			
			AddInternal(c);
			
			if (_isSorted)
				ApplySort(GetSortComparer());

			_notifyChanges = oldNotifyChanges;
			OnReset();
		}

		#endregion

		#region Add/Remove Internal

		private void AddInternal(object value)
		{
			EndNew();

			if (value is INotifyPropertyChanged)
				((INotifyPropertyChanged)value).PropertyChanged += 
					ItemPropertyChanged;
		}

		private void RemoveInternal(object value)
		{
			EndNew();

			if (value is INotifyPropertyChanged)
				((INotifyPropertyChanged)value).PropertyChanged -=
					ItemPropertyChanged;
		}

		private void AddInternal(IEnumerable e)
		{
			foreach (object o in e)
				AddInternal(o);
		}

		private void RemoveInternal(IEnumerable e)
		{
			foreach (object o in e)
				RemoveInternal(o);
		}

		private void OnAddItem(object item, int index)
		{
			OnListChanged(new EditableListChangedEventArgs(ListChangedType.ItemAdded, index));
			OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, item, index));
		}

		private void OnRemoveItem(object item, int index)
		{
			OnListChanged(new EditableListChangedEventArgs(ListChangedType.ItemDeleted, index));
			OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, item, index));
		}

		private void OnMoveItem(object item, int oldIndex, int newIndex)
		{
			OnListChanged(new EditableListChangedEventArgs(newIndex, oldIndex));
			OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Move, item, newIndex, oldIndex));
		}

		private void OnChangeItem(object oldValue, object newValue, int index)
		{
			OnListChanged(new EditableListChangedEventArgs(ListChangedType.ItemChanged, index));
			OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace, oldValue, newValue, index));
		}

		private void OnReset()
		{
			OnListChanged(new EditableListChangedEventArgs(ListChangedType.Reset));
			OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
		}

		#endregion

		#region INotifyCollectionChanged Members

		public event NotifyCollectionChangedEventHandler CollectionChanged;

		private void FireCollectionChangedEvent(object sender, NotifyCollectionChangedEventArgs ea)
		{
			if (_notifyChanges && CollectionChanged != null)
				CollectionChanged(sender, ea);
		}

		protected virtual void OnCollectionChanged(NotifyCollectionChangedEventArgs ea)
		{
			FireCollectionChangedEvent(this, ea);
		}

		#endregion
	}
}