//            Copyright Keysight Technologies 2012-2019
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, you can obtain one at http://mozilla.org/MPL/2.0/.
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;

namespace OpenTap
{
    /// <remarks>
    /// Only works on properties, not fields. The functionality is implemented primarily with a GUI in mind.
    /// </remarks>
    /// <summary>
    /// Runtime property value error-checking system. 
    /// Can be used to validate an object before run or to display messages through a GUI.
    /// </summary>
    public abstract class ValidatingObject : IDataErrorInfo, INotifyPropertyChanged, IValidatingObject
    {
        /// <summary>
        /// All the validation rules. Add new rules to this in order to get runtime value validation.
        /// </summary>
        [AnnotationIgnore]
        [SettingsIgnore]
        public ValidationRuleCollection Rules
        {
            get
            {
                if (rules == null) rules = new ValidationRuleCollection();
                return rules;
            }
        }
        private ValidationRuleCollection rules;

        // thread static to avoid locking everything and having a HashSet on each ValidationObject
        [ThreadStatic]
        static HashSet<object> traversed = null;

        class DynamicRule : DelegateValidationRule
        {

            public DynamicRule(IsValidDelegateDefinition isValid, string propertyName, CustomErrorDelegateDefinition errorDelegate) : base(isValid, propertyName, errorDelegate)
            {
            }
        }
        
        void UpdateEmbeddedAndDynamicRules()
        {
            // Only update if the key has been changed (dynamic members added or removed).
            var updateKey = DynamicMember.GetTypeDataKey(this);
            if (Rules.UpdateKey == updateKey) return;
            lock (Rules)
            {
                if (Rules.UpdateKey == updateKey) return;
                Rules.UpdateKey = updateKey;
                rules?.RemoveIf(x => x is DynamicRule);
                var td = TypeData.GetTypeData(this);
                {
                    foreach (var member in td.GetMembers())
                    {
                        if (member.TypeDescriptor.DescendsTo(typeof(IValidatingObject)))
                        {
                            var rule = new DynamicRule(() =>
                            {
                                if (member.GetValue(this) is IValidatingObject value)
                                {
                                    return string.IsNullOrEmpty(value.Error);
                                }
                                return true;
                            }, member.Name, () =>
                            {
                                if (member.GetValue(this) is IValidatingObject value)
                                {
                                    return value.Error;
                                }
                                return null;
                            });
                            Rules.Add(rule);
                        }
                    }
                }
                {
                    if (td is EmbeddedTypeData)
                    {
                        foreach (var member in td.GetMembers().OfType<EmbeddedMemberData>())
                        {
                            if (member.OwnerMember.TypeDescriptor.DescendsTo(typeof(IValidatingObject)))
                            {
                                var rule = new DynamicRule(() =>
                                {
                                    var src = (IValidatingObject)member.OwnerMember.GetValue(this);
                                    if (src == null) return false;
                                    var err = src[member.InnerMember.Name];
                                    return string.IsNullOrEmpty(err);
                                }, member.Name, () =>
                                {
                                    var src = (IValidatingObject)member.OwnerMember.GetValue(this);
                                    if (src == null) return "Instance is null";
                                    return src[member.InnerMember.Name];
                                });
                                Rules.Add(rule);

                            }
                        }
                    }
                }
            }
        }
        
        /// <summary>
        /// Return the error for a given property
        /// </summary>
        protected virtual string GetError(string propertyName = null)
        {
            UpdateEmbeddedAndDynamicRules();
            
            List<string> errors = null;
            void pushError(string error)
            {
                if (errors == null) errors = new List<string>();
                if (!errors.Contains(error))
                    errors.Add(error);
            }

            foreach (var rule in Rules)
            {
                try
                {
                    if (propertyName != null && rule.PropertyName != propertyName) continue;
                    if (rule.IsValid()) continue;
                    var error = rule.ErrorMessage;
                    if (string.IsNullOrEmpty(error)) continue;
                    pushError(error);
                } catch(Exception ex)
                {
                    pushError(ex.Message);
                }
            }
            foreach (var fwd in Rules.ForwardedRules)
            {
                if (propertyName != null && fwd.Name != propertyName) continue;
                var obj = fwd.GetValue(this) as IValidatingObject;
                if (obj == null) continue;
                if (traversed == null)
                {
                    traversed = new HashSet<object>();
                }
                else if (traversed.Contains(obj)) continue;
                traversed.Add(obj);
                traversed.Add(this);

                try
                {
                    var err = obj.Error;
                    
                    if (string.IsNullOrWhiteSpace(err)) continue;
                    pushError(err.TrimEnd());
                }
                finally
                {
                    traversed.Remove(obj);
                }
            }
            if (errors == null)
                return "";
            return string.Join(Environment.NewLine, errors).TrimEnd();
        }

        /// <summary>
        /// Gets the error messages for each invalid rule and joins them with a newline.
        /// </summary>
        public string Error => GetError(null);

        /// <summary>
        /// Gets the error(s) for a given property as a concatenated string.
        /// </summary>
        /// <param name="propertyName"></param>
        /// <returns>string concatenated errors.</returns>
        string IDataErrorInfo.this[string propertyName] => GetError(propertyName);

        /// <summary>
        /// Checks all validation rules on this object (<see cref="Rules"/>) and throws an AggregateException on errors.
        /// </summary>
        /// <param name="ignoreDisabledProperties">If true, ignores <see cref="Rules"/> related to properties that are disabled or hidden as a result of <see cref="EnabledIfAttribute"/> or <see cref="Enabled{T}"/>.</param>
        /// <exception cref="AggregateException">Thrown when any <see cref="Rules"/> on this object are invalid. This exception contains an ArgumentException for each invalid setting.</exception>
        protected void ThrowOnValidationError(bool ignoreDisabledProperties)
        {
            var propertyNames = new HashSet<string>();
            TestStepExtensions.GetObjectSettings(this, ignoreDisabledProperties, 
                (object o, IMemberData pi) => pi.Name, propertyNames);
            foreach (ValidationRule rule in Rules)
            {
                if (!rule.IsValid() && propertyNames.Contains(rule.PropertyName))
                {
                    throw new Exception($"The Property [{rule.PropertyName}] is invalid. Details: {rule.ErrorMessage}");
                }
            }
        }

        #region OnPropertyChanged
        /// <summary>
        /// Standard PropertyChanged event object.
        /// </summary>
        public event PropertyChangedEventHandler PropertyChanged;
        
        /// <summary>
        /// Triggers the PropertyChanged event.
        /// </summary>
        /// <param name="propertyName">string name of which property has been changed.</param>
        public void OnPropertyChanged(string propertyName)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
            UserInput.NotifyChanged(this, propertyName);
        }


        #endregion
    }
    /// <summary>
    /// Delegate for checking validation rule.
    /// </summary>
    /// <returns>True if valid, false if not.</returns>
    public delegate bool IsValidDelegateDefinition();
    /// <summary>
    /// Delegate for returning a custom error message from a validation rule.
    /// </summary>
    /// <returns></returns>
    public delegate string CustomErrorDelegateDefinition();

    /// <summary>
    /// Validates settings at runtime. A validation rule is attached to an object of type <see cref="ValidatingObject"/> and is used to validate the property value of that object. 
    /// Also see <see cref="ValidatingObject.Rules"/>
    /// </summary>
    public class ValidationRule
    {
        /// <summary>
        /// Name of the property affected by this rule.
        /// </summary>
        public string PropertyName { get; set; }
        /// <summary>
        /// Error message to use if the property does not follow the rule.  
        /// </summary>
        public virtual string ErrorMessage { get; set; }

        /// <summary>
        /// Rule function following the signature () -> bool.  
        /// </summary>
        public IsValidDelegateDefinition IsValid { get; set; }

        /// <summary>
        /// </summary>
        /// <param name="isValid">Property IsValid</param>
        /// <param name="errorMessage">Property ErrorMessage-</param>
        /// <param name="propertyName">Property PropertyName</param>
        public ValidationRule(IsValidDelegateDefinition isValid, string errorMessage, string propertyName)
        {
            ErrorMessage = errorMessage;
            PropertyName = propertyName;
            IsValid = isValid;
        }
    }

    /// <summary>
    /// Validation rule that takes a delegate as an argument.  Used for writing error messages.
    /// </summary>
    public class DelegateValidationRule : ValidationRule
    {
        static readonly TraceSource log =  OpenTap.Log.CreateSource("Validation");
        /// <summary>
        /// The error calculated from ErrorDelegate.
        /// </summary>
        public override string ErrorMessage
        {
            get
            {
                try
                {
                    return ErrorDelegate();
                }
                catch (Exception e)
                {
                    log.Error("Exception caught from error handling function.");
                    log.Debug(e);
                    return "Exception caught from error handling function.";
                }
            }
            set
            {

            }
        }

        /// <summary>
        /// The delegate producing the error message.
        /// </summary>
        public CustomErrorDelegateDefinition ErrorDelegate;

        /// <summary>
        /// Constructor for DelegateValidationRule.
        /// </summary>
        /// <param name="isValid">Validation delegate.</param>
        /// <param name="propertyName">Target property.</param>
        /// <param name="errorDelegate">Function creating the error message.</param>
        public DelegateValidationRule(IsValidDelegateDefinition isValid, string propertyName, CustomErrorDelegateDefinition errorDelegate) : base(isValid, "", propertyName)
        {
            ErrorDelegate = errorDelegate;
        }

    }
    /// <summary>
    /// Collection of validation rules.
    /// Simplifies adding new rules by abstracting the use of ValidationRule objects.
    /// </summary>
    public class ValidationRuleCollection : Collection<ValidationRule>
    {
        internal int UpdateKey;
        /// <summary>
        /// Add a new rule to the collection.
        /// </summary>
        /// <param name="isValid">Rule checking function.</param>
        /// <param name="errorMessage"> Error if rule checking function returns false.</param>
        /// <param name="propertyName">Name of the property it affects.</param>
        public void Add(IsValidDelegateDefinition isValid, string errorMessage, string propertyName)
        {
            this.Add(new ValidationRule(isValid, errorMessage, propertyName));
        }
        
        /// <summary>
        /// This overload of ValidationRuleCollection.Add should not be used. This placeholder method is added to provide a warning.
        /// </summary>
        /// <param name="isValid">Rule checking function.</param>
        /// <param name="errorMessage"> Error if rule checking function returns false.</param>
        [Obsolete("No property names are specified for this validation rule. Please specify which properties are affected by this rule or explicitly add Array.Empty<string>()")]
        [EditorBrowsable(EditorBrowsableState.Never)]
        public void Add(IsValidDelegateDefinition isValid, string errorMessage)
        {
            
        }

        internal readonly List<IMemberData> ForwardedRules = new List<IMemberData>(); 

        /// <summary>
        /// Dynamically adds a sub-objects rules to the collection of rules.
        /// </summary>
        /// <param name="member"></param>
        internal void Forward(IMemberData member) => ForwardedRules.Add(member);
        
        /// <summary>
        /// Adds a new rule to the collection.
        /// </summary>
        /// <param name="isValid"></param>
        /// <param name="errorDelegate"></param>
        /// <param name="propertyName"></param>
        public void Add(IsValidDelegateDefinition isValid, CustomErrorDelegateDefinition errorDelegate, string propertyName)
        {
            this.Add(new DelegateValidationRule(isValid, propertyName, errorDelegate));
        }

        /// <summary>
        /// Add a new rule to the collection for multiple properties. 
        /// Internally a new rule is created for each property.
        /// </summary>
        /// <param name="isValid">Rule checking function.</param>
        /// <param name="errorMessage"> Error if rule checking function returns false.</param>
        /// <param name="propertyNames">Names of the properties it affects.</param>
        public void Add(IsValidDelegateDefinition isValid, string errorMessage, params string[] propertyNames)
        {
            if (propertyNames == null)
                throw new ArgumentNullException(nameof(propertyNames));
            foreach (string propertyName in propertyNames)
            {
                this.Add(isValid, errorMessage, propertyName);
            }
        }

        /// <summary>
        /// Adds a new rule to the collection.
        /// </summary>
        /// <param name="isValid"></param>
        /// <param name="errorDelegate"></param>
        /// <param name="propertyNames">Names of the properties it affects.</param>
        public void Add(IsValidDelegateDefinition isValid, CustomErrorDelegateDefinition errorDelegate, params string[] propertyNames)
        {
            if (propertyNames == null)
                throw new ArgumentNullException(nameof(propertyNames));
            foreach (string propertyName in propertyNames)
            {
                this.Add(isValid, errorDelegate, propertyName);
            }
        }
    }
}