using System.Diagnostics.CodeAnalysis;

namespace System.Activities.Presentation.PropertyEditing
{
    using System.ComponentModel;
    using System.Collections;
    using System;
    using System.Diagnostics;
    using System.Activities.Presentation;

    /// <summary>
    /// The PropertyEntry class provides additional, mostly type-specific data for a property.
    /// </summary>
    public abstract class PropertyEntry : INotifyPropertyChanged, IPropertyFilterTarget {

        private PropertyValue _parentValue;
        private bool _matchesFilter = true;
        private PropertyValue _value;

        /// <summary>
        /// Creates a PropertyEntry.  For host infrastructure derived classes.
        /// </summary>
        protected PropertyEntry() : this(null) { }

        /// <summary>
        /// Creates a PropertyEntry that acts as a sub-property of the specified PropertyValue.
        /// For host infrastructure derived classes.
        /// </summary>
        /// <param name="parentValue">The parent PropertyValue.
        /// Root properties do not have a parent PropertyValue.</param>
        protected PropertyEntry(PropertyValue parentValue) {
            _parentValue = parentValue;
        }

        /// <summary>
        /// Gets the name of the encapsulated property.
        /// </summary>
        public abstract string PropertyName { get; }

        /// <summary>
        /// Gets the DisplayName for the property. By default, it is the
        /// PropertyName.
        /// </summary>
        public virtual string DisplayName { get { return this.PropertyName; } }

        /// <summary>
        /// Gets the Type of the encapsulated property.
        /// </summary>
        public abstract Type PropertyType { get; }

        /// <summary>
        /// Gets the name of the category that this property resides in.
        /// </summary>
        public abstract string CategoryName { get; }

        /// <summary>
        /// Gets the description of the encapsulated property.
        /// </summary>
        public abstract string Description { get; }

        /// <summary>
        /// Returns true if there are standard values for this property.
        /// The default implementation checks if the StandardValues property
        /// returns a non-null collection with a count > 0.
        /// </summary>
        protected virtual bool HasStandardValues {
            get {
                ICollection values = StandardValues;
                return values != null && values.Count > 0;
            }
        }

        /// <summary>
        /// Accessor because we use this property in the property container.
        /// </summary>
        internal bool HasStandardValuesInternal {
            get { return HasStandardValues; }
        }

        /// <summary>
        /// Gets the read-only attribute of the encapsulated property.
        /// </summary>
        public abstract bool IsReadOnly { get; }

        /// <summary>
        /// Gets a flag indicating whether the encapsulated property is an advanced property.
        /// </summary>
        public abstract bool IsAdvanced { get; }

        /// <summary>
        /// Gets any StandardValues that the encapsulated property supports.
        /// </summary>
        public abstract ICollection StandardValues { get; }

        /// <summary>
        /// Gets to PropertyValueEditor to be used for editing of this PropertyEntry.
        /// May be null.  PropertyContainer listens to changes made to this property.
        /// If the value changes, it's the responsibility of the deriving class to fire the
        /// appropriate PropertyChanged event.
        /// </summary>
        public abstract PropertyValueEditor PropertyValueEditor { get; }

        /// <summary>
        /// Gets the parent PropertyValue.  This is only used for sub-properties and,
        /// hence, its balue may be null.
        /// </summary>
        public PropertyValue ParentValue {
            get {
                return _parentValue;
            }
        }

        /// <summary>
        /// Gets the PropertyValue (data model) for this PropertyEntry.
        /// </summary>
        public PropertyValue PropertyValue {
            get {
                if (_value == null)
                    _value = CreatePropertyValueInstance();

                return _value;
            }
        }

        /// <summary>
        /// Used by the host infrastructure to create a new host-specific PropertyValue instance.
        /// </summary>
        /// <returns>new PropertyValue</returns>
        protected abstract PropertyValue CreatePropertyValueInstance();

        // IPropertyFilterTarget Members

        /// <summary>
        /// IPropertyFilterTarget event
        /// </summary>
        public event EventHandler<PropertyFilterAppliedEventArgs> FilterApplied;

        /// <summary>
        /// IPropertyFilterTarget method. PropertyContainer listens to changes made to this property.
        /// </summary>
        public bool MatchesFilter {
            get {
                return _matchesFilter;
            }
            protected set {
                if (value != _matchesFilter) {
                    _matchesFilter = value;
                    OnPropertyChanged("MatchesFilter");
                }
            }
        }

        /// <summary>
        /// IPropertyFilterTarget method
        /// </summary>
        /// <param name="predicate">the predicate to match against</param>
        /// <returns>true if there is a match</returns>
        public virtual bool MatchesPredicate(PropertyFilterPredicate predicate) {
            return predicate == null ?
                false :
                predicate.Match(this.DisplayName) || predicate.Match(this.PropertyType.Name);
        }

        /// <summary>
        /// IPropertyFilterTarget method
        /// </summary>
        /// <param name="filter">the PropertyFilter to apply</param>
        public virtual void ApplyFilter(PropertyFilter filter) {
            this.MatchesFilter = filter == null ? true : filter.Match(this);
            OnFilterApplied(filter);
        }

        /// <summary>
        /// Used to raise the IPropertyFilterTarget FilterApplied event
        /// </summary>
        /// <param name="filter"></param>
        protected virtual void OnFilterApplied(PropertyFilter filter) {
            if (FilterApplied != null)
                FilterApplied(this, new PropertyFilterAppliedEventArgs(filter));
        }


        // INotifyPropertyChanged

        /// <summary>
        /// INotifyPropertyChanged event
        /// </summary>
        public event PropertyChangedEventHandler PropertyChanged;

        /// <summary>
        /// Used to raise the INotifyPropertyChanged PropertyChanged event
        /// </summary>
        /// <param name="e">EventArgs for this event</param>
        protected virtual void OnPropertyChanged(PropertyChangedEventArgs e) {
            if (e == null)
                throw FxTrace.Exception.ArgumentNull("e");

            if (this.PropertyChanged != null)
                this.PropertyChanged(this, e);
        }

        /// <summary>
        /// Used to raise the INotifyPropertyChanged event
        /// </summary>
        /// <param name="propertyName"></param>
        /// <exception cref="ArgumentNullException">When propertyName is null</exception>
        protected virtual void OnPropertyChanged(string propertyName) {
            if (propertyName == null)
                throw FxTrace.Exception.ArgumentNull("propertyName");

            if (this.PropertyChanged != null)
                this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
        }

    }
}