using System;
using System.Collections.Generic;
using System.ComponentModel;

namespace CSharpVitamins.PropertyChangeFilter
{
	public class PropertyChangeFilter : INotifyPropertyChanged
	{
		#region Private Fields

		bool _hasChanged;
		bool _trackChanges = false;
		StringComparison _comparisonType = StringComparison.Ordinal;
		string[] _properties;
		INotifyPropertyChanged _target;
		List<string> _changes;

		#endregion

		#region Constructors

		/// <summary>
		/// 
		/// </summary>
		public PropertyChangeFilter()
		{ }

		/// <summary>
		/// 
		/// </summary>
		/// <param name="target">The object to listen for property changes on.</param>
		public PropertyChangeFilter(INotifyPropertyChanged target)
			: this(target, null)
		{ }

		/// <summary>
		/// 
		/// </summary>
		/// <param name="names">The list of property names to filter changes for</param>
		public PropertyChangeFilter(params string[] names)
			: this(null, names)
		{
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="target">The object to listen for property changes on.</param>
		/// <param name="names">The list of property names to filter changes for</param>
		public PropertyChangeFilter(INotifyPropertyChanged target, params string[] names)
		{
			Properties = names;
			Target = target;
		}

		#endregion

		#region Properties

		/// <summary>
		/// Gets whether the PropertyChanged event has passed through 
		/// the filters. This is marked as changed ofter the first sucessful 
		/// pass through.
		/// </summary>
		public bool HasChanged
		{
			get { return _hasChanged; }
		}

		/// <summary>
		/// Gets/Sets whether a list of the property changes is kept.
		/// </summary>
		/// <remarks>Only the property names are stored.</remarks>
		public bool TrackChanges
		{
			get { return _trackChanges; }
			set { _trackChanges = value; }
		}

		/// <summary>
		/// Gets a list of the property names that have passed the change filter
		/// </summary>
		/// <remarks>TrackChanges must be true for the change list to be populated.</remarks>
		public List<string> Changes
		{
			get { return _changes ?? (_changes = new List<string>()); }
		}

		/// <summary>
		/// Gets/Sets the comparison type to use when listening for 
		/// property names i.e. case sensitive / insensitive
		/// </summary>
		public StringComparison ComparisonType
		{
			get { return _comparisonType; }
			set { _comparisonType = value; }
		}

		/// <summary>
		/// Gets/Sets the list of property names to filter changes for
		/// </summary>
		/// <remarks>
		/// If Properties is null or zero length, all properties will 
		/// sucessfully pass through the filter.
		/// 
		/// Use the ComparisonType property to configure filtering for 
		/// case-insensitive names.
		/// </remarks>
		public string[] Properties
		{
			get { return _properties; }
			set { _properties = value; }
		}

		/// <summary>
		/// Gets/Sets the object to listen for property changes on
		/// </summary>
		public INotifyPropertyChanged Target
		{
			get { return _target; }
			set
			{
				if (_target != value)
				{
					// remove old listener
					if (null != _target)
					{
						_target.PropertyChanged -= filter;
					}

					Reset();
					_target = value;

					// add new listener
					if (null != _target)
					{
						_target.PropertyChanged += filter;
					}
				}

			}
		}

		#endregion

		#region Methods

		/// <summary>
		/// Resets the IsChanged and and tracked changes to default values.
		/// </summary>
		public void Reset()
		{
			_hasChanged = false;
			_changes = null;
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="sender"></param>
		/// <param name="e"></param>
		void filter(object sender, PropertyChangedEventArgs e)
		{
			if (null != _properties && _properties.Length > 0)
			{
				/// Create a predicate that has a closure to our property name 
				/// in the EventArgs for searching our property names array
				Predicate<string> match = delegate(string name)
				{
					return name.Equals(e.PropertyName, _comparisonType);
				};

				if (!Array.Exists<string>(_properties, match))
				{
					/// don't pass event on, just return
					return;
				}
			}

			/// at this point our filters have been passed and the 
			/// event can be passed through to our other subscribers.
			trackChange(e.PropertyName);

			/// NB: The original object is passed through, not the actual 
			/// filter instance
			OnPropertyChanged(sender, e);
		}

		/// <summary>
		/// Sets the IsChanged flag to true and if enabled, adds an entry for the 
		/// property name to the changes collections.
		/// </summary>
		/// <param name="name"></param>
		void trackChange(string name)
		{
			_hasChanged = true;
			if (_trackChanges)
			{
				Changes.Add(name);
			}
		}

		#endregion

		#region Events

		/// <summary>
		/// Occurs when a property is changed
		/// </summary>
		public event PropertyChangedEventHandler PropertyChanged;

		/// <summary>
		/// Raises the PropertyChanged event
		/// </summary>
		/// <param name="e"></param>
		protected void OnPropertyChanged(object sender, PropertyChangedEventArgs e)
		{
			PropertyChangedEventHandler handler = PropertyChanged;
			if (null != handler)
			{
				handler(sender, e);
			}
		}

		#endregion

	}
}