//            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.Linq;
using System.Diagnostics;
using System.Runtime.Serialization;
using System.Collections;
using System.Collections.Immutable;
using System.ComponentModel;

namespace OpenTap
{
    /// <summary>
    /// Abstract class forming the basis for all ResultListeners.
    /// </summary>
    public abstract class ResultListener : Resource, IResultListener, IEnabledResource
    {
        bool isEnabled = true;
        ///<summary> Gets or sets if this resource is enabled.</summary>
        [Browsable(false)]
        public bool IsEnabled {

            get => isEnabled;
            set
            {
                var oldValue = isEnabled;
                isEnabled = value;
                onEnabledChanged(oldValue, value);
            }
        }
        
        /// <summary> Called when IsEnabled is changed. </summary>
        /// <param name="oldValue"></param>
        /// <param name="newValue"></param>
        protected virtual void onEnabledChanged(bool oldValue, bool newValue)
        {

        }

        /// <summary>
        /// Called when a test plan starts.
        /// </summary>
        /// <param name="planRun">Test plan run parameters.</param>
        public virtual void OnTestPlanRunStart(TestPlanRun planRun)
        {
        }

        /// <summary>
        /// Called when test plan finishes. At this point no more results will be sent to the result listener from the test plan run.  
        /// </summary>
        /// <param name="planRun">Test plan run parameters.</param>
        /// <param name="logStream">The log file from the test plan run as a stream.</param>
        public virtual void OnTestPlanRunCompleted(TestPlanRun planRun, System.IO.Stream logStream)
        {
        }

        /// <summary>
        /// Called just before a test step is started.
        /// </summary>
        /// <param name="stepRun"></param>
        public virtual void OnTestStepRunStart(TestStepRun stepRun)
        {
        }

        /// <summary>
        /// Called when a test step run is completed.
        /// Result might still be propagated to the result listener after this event.
        /// </summary>
        /// <param name="stepRun">Step run parameters.</param>
        public virtual void OnTestStepRunCompleted(TestStepRun stepRun)
        {
        }

        /// <summary>
        /// Called when a result is received.
        /// </summary>
        /// <param name="stepRunId"> Step run ID.</param>
        /// <param name="result">Result structure.</param>
        public virtual void OnResultPublished(Guid stepRunId, ResultTable result)
        {
        }
        
        // lookup keeping track of which result listeners implements OnResultPublished
        static ImmutableDictionary<Type, bool> implementsOnResultsPublished = ImmutableDictionary<Type, bool>.Empty;
        /// <summary> Returns true if the result listener has implemented OnResultPublished. This is used to optimize performance in situations where they don't. </summary>
        internal static bool ImplementsOnResultsPublished(ResultListener resultListener)
        {
            var resultListenerType = resultListener.GetType();
            if (!implementsOnResultsPublished.TryGetValue(resultListenerType, out bool doesImplement))
            {
                doesImplement = resultListenerType.MethodOverridden(typeof(ResultListener), nameof(OnResultPublished));
                implementsOnResultsPublished = implementsOnResultsPublished.Add(resultListenerType, doesImplement);
            }
            return doesImplement;
        }
    }

    /// <summary>
    /// Instructs the ResultListener not to save the 
    /// public property value as metadata for TestStep results.
    /// </summary>
    [Obsolete("This attribute is no longer in use and will be removed in a later version.")]
    [AttributeUsage(AttributeTargets.Property)]
    public class ResultListenerIgnoreAttribute : Attribute
    {

    }

    /// <summary>
    /// Represents a result parameter.
    /// </summary>
    [DebuggerDisplay("{Group} {Name} = {Value}")]
    [DataContract]
    public class ResultParameter : IParameter
    {
        /// <summary>
        /// Name of parameter.
        /// </summary>
        [DataMember]
        public readonly string Name;
        /// <summary>
        /// Group name of the parameter.
        /// </summary>
        [DataMember]
        public readonly string Group;
        /// <summary>
        /// Value of the parameter. If null, the value is the string "NULL".  
        /// </summary>
        [DataMember]
        public readonly IConvertible Value;
        /// <summary>
        /// Indicates the parameter came from a test step in a parent level above the initial object.  
        /// </summary>
        [DataMember]
        public readonly int ParentLevel;

        internal (string, string) Key => (Name, Group);
        IConvertible IParameter.Value => Value;

        string IAttributedObject.Name => Name;

        string IParameter.Group => Group;

        string IAttributedObject.ObjectType => "Parameter";

        /// <summary> Gets if this result is metadata. </summary>
        public bool IsMetaData { get; }

        /// <summary> null or the macro name representation of the ResultParameter. This will make it possible to insert the parameter value into a string. <see cref="MacroString"/></summary>
        public readonly string MacroName;

        /// <summary> Creates a result parameter with default group.</summary>
        public ResultParameter(string name, IConvertible value)
        {
            Name = name;
            Value = value ?? "NULL";
            Group = "";
            MacroName = null;
        }
        /// <summary>
        /// Initializes a new instance of ResultParameter.
        /// </summary>
        public ResultParameter(string group, string name, IConvertible value, MetaDataAttribute metadata = null, int parentLevel = 0)
        {
            Group = group ?? "";
            Name = name;
            Value = value ?? "NULL";
            ParentLevel = parentLevel;
            if (metadata != null)
            {
                MacroName = metadata.MacroName;
                IsMetaData = true;
            }
            else
            {
                MacroName = null;
            }
        }
        
        /// <summary>  Creates a new ResultParameter. </summary>
        /// <param name="group"></param>
        /// <param name="name"></param>
        /// <param name="value"></param>
        /// <param name="macroName"></param>
        public ResultParameter(string group, string name, IConvertible value, string macroName)
        {
            Group = group;
            Name = name;
            Value = value ?? "NULL";
            
            if (macroName != null)
            {
                IsMetaData = true;
                if (macroName.Length > 0)
                    MacroName = macroName;
                else MacroName = name;
            }
        }

        /// <summary>
        /// Determines whether the specified object is equal to the current object.
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public override bool Equals(object obj)
        {
            var parameter = obj as ResultParameter;
            return parameter != null &&
                   Name == parameter.Name &&
                   Group == parameter.Group &&
                   EqualityComparer<IConvertible>.Default.Equals(Value, parameter.Value) &&
                   ParentLevel == parameter.ParentLevel &&
                   MacroName == parameter.MacroName;
        }

        /// <summary>
        /// Calculates a hash code for the current object.
        /// </summary>
        /// <returns></returns>
        public override int GetHashCode()
        {
            var hashCode = -1808396095;
            hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(Name);
            hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(Group);
            hashCode = hashCode * -1521134295 + EqualityComparer<IConvertible>.Default.GetHashCode(Value);
            hashCode = hashCode * -1521134295 + ParentLevel.GetHashCode();
            hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(MacroName);
            return hashCode;
        }
    }

    // this array can be indexed and resized at the same time.
    class SafeArray<T> : IEnumerable<T>
    {
        T[][] arrays = Array.Empty<T[]>();

        int count;
        public int Count => count;

        public SafeArray(T[] init)
        {
            arrays = new[] {init};
            count = init.Length;
        }

        public SafeArray(SafeArray<T> original)
        {
            count = original.count;
            arrays = new []{new T[count]};
            int offset = 0;
            foreach (var elems in original.arrays)
            {
                elems.CopyTo(arrays[0], offset);
                offset += elems.Length;
            }
        }

        public SafeArray()
        {
            
        }

        readonly object resizeLock = new object(); 
            
        public void Resize(int newSize)
        {
            if(newSize < count)
                throw new InvalidOperationException();
            if (newSize == count) return;
            lock (resizeLock)
            {
                Array.Resize(ref arrays, arrays.Length + 1);
                arrays[arrays.Length - 1] = new T[newSize - count];
                count = newSize;
            }
        }
        
        public ref T this[int index]
        {
            get
            {
                for(int i = 0; i < arrays.Length; i++)
                {
                    var array = arrays[i];
                    if (index < array.Length)
                        return ref array[index];
                    index -= array.Length;
                }
                throw new IndexOutOfRangeException();
            }
        }

        public IEnumerator<T> GetEnumerator() =>  arrays.SelectMany(x => x).GetEnumerator();

        IEnumerator IEnumerable.GetEnumerator() =>  GetEnumerator();
    }

    /// <summary>
    /// A collection of parameters related to the results.
    /// </summary>
    public class ResultParameters : IReadOnlyList<ResultParameter>
    {
        struct resultParameter
        {
            public string Name;
            public IConvertible Value;
            public string Group;
            public string MacroName;
            public ResultParameter ToResultParameter() => new ResultParameter(Group, Name, Value, MacroName);
            public static implicit operator resultParameter(ResultParameter v)
            {
                return new resultParameter
                {
                    Name = v.Name,
                    Value = v.Value,
                    Group = v.Group,
                    MacroName = v.MacroName ?? (v.IsMetaData ? "" : null) 
                };
            }
        }
        SafeArray<resultParameter> data = new SafeArray<resultParameter>();

        /// <summary>
        /// Gets the parameter with the given index.
        /// </summary>
        public ResultParameter this[int index] => data[index].ToResultParameter();

        /// <summary> Gets a ResultParameter by name. </summary>
        public ResultParameter Find(string name) => Find(name, "");
        
        /// <summary> Gets a ResultParameter by name. </summary>
        public ResultParameter Find(string name, string group)
        {
            if (indexByName.TryGetValue((name, group), out var idx) == false)
                return null;
            return this[idx];
        }

        /// <summary> Gets a ResultParameter by name. </summary>
        public ResultParameter Find((string name, string group) key)
        {
            if (indexByName.TryGetValue(key, out var idx) == false)
                return null;
            return this[idx];
        }
        
        int FindIndex((string name, string group) key)
        {
            if (indexByName.TryGetValue(key, out var idx))
                return idx;
            return -1;
        }

        /// <summary> Gets the parameter with the key name. </summary>
        public IConvertible this[string name, string group]
        {
            get => Find(name, group)?.Value;
            set
            {
                int index = -1;
                SetIndexed((name, group), ref index, value);
            }
        }

        /// <summary> Gets a named parameter specifying only name. This assumes that the empty group is being used. So it is the same as calling [name, ""].. </summary>
        public IConvertible this[string name]
        {
            get => this[name, ""];
            set => this[name, ""] = value;
        }

        static void getMetadataFromObject(object res, string nestedName, ICollection<ResultParameter> output)
        {
            GetPropertiesFromObject(res, output, nestedName, true);
        }

        /// <summary>
        /// Returns a <see cref="ResultParameters"/> list with one entry for every property on the inputted 
        /// object decorated with <see cref="MetaDataAttribute"/>.
        /// </summary>
        public static ResultParameters GetMetadataFromObject(object res)
        {
            if (res == null)
                throw new ArgumentNullException(nameof(res));
            var parameters = new List<ResultParameter>();
            getMetadataFromObject(res, "", parameters);
            return new ResultParameters(parameters);
        }

        /// <summary>
        /// Returns a <see cref="ResultParameters"/> list with one entry for every property on every 
        /// <see cref="ComponentSettings"/> implementation decorated with <see cref="MetaDataAttribute"/>. 
        /// </summary>
        public static ResultParameters GetComponentSettingsMetadata(bool expandComponentSettings = false)
        {
            var componentSettings = TypeData.FromType(typeof(ComponentSettings)) //get component settings instances (lazy)
                .DerivedTypes
                .Where(x => x.CanCreateInstance && ParameterCache.GetParametersMap(x, true).Any())
                .Select(td => ComponentSettings.GetCurrent(td.Type))
                .Where(o => o != null)
                .Cast<object>();

            if (expandComponentSettings)
            {
                var componentSettingsLists = TypeData
                    .FromType(typeof(ComponentSettings)) //get component settings instances (lazy)
                    .DerivedTypes
                    .Where(x => x.CanCreateInstance && x.DescendsTo(typeof(IEnumerable)))
                    .Select(td => ComponentSettings.GetCurrent(td.Type))
                    .Where(o => o != null)
                    .Cast<object>();
                
                if (expandComponentSettings)
                    componentSettings = componentSettings.Concat(componentSettingsLists.OfType<IEnumerable>().SelectMany(c => (IEnumerable<object>)c)).Distinct();
            }

            
            return new ResultParameters(componentSettings.ToArray().SelectMany(GetMetadataFromObject).ToArray());// get metadata from each.
        }

        
        /// <summary>
        /// Lazily pull result parameters from component settings. Reduces the number of component settings XML that needs to be deserialized.
        /// </summary>
        /// <param name="includeObjects">If objects in ComponentSettingsLists should be included.</param>
        /// <returns></returns>
        internal static IEnumerable<ResultParameters> GetComponentSettingsMetadataLazy(bool includeObjects)
        {
            TypeData engineSettingsType = TypeData.FromType(typeof(EngineSettings));
            AssemblyData engineAssembly = engineSettingsType.Assembly;

            int orderer(TypeData tp)
            {
                // always start with EngineSettings
                // prefer engine assemblies 
                // then loaded assemblies
                // then everything else.
                if (tp == engineSettingsType)
                    return 3;
                if (tp.Assembly == engineAssembly)
                    return 2;
                if (tp.Assembly.Status == LoadStatus.Loaded)
                    return 1;
                return 0;
            }

            var types = TypeData.FromType(typeof(ComponentSettings))
                .DerivedTypes.OrderByDescending(orderer).ToArray();

            foreach (var tp in types)
            {
                var t = tp.Load();
                if (tp.CanCreateInstance == false) continue;
                if (ParameterCache.GetParametersMap(tp, true).Any() == false)
                    continue;
                var componentSetting = ComponentSettings.GetCurrent(t);
                if (componentSetting != null)
                {
                    yield return GetMetadataFromObject(componentSetting);
                }
            }
            if (includeObjects == false) yield break;
            foreach (var tp in types)
            {
                var t = tp.Load();
                if (tp.CanCreateInstance == false) continue;
                if (tp.DescendsTo(typeof(IEnumerable)) == false) continue;
                var elements = ComponentSettings.GetCurrent(t) as IEnumerable ?? Array.Empty<object>();
                foreach (var elem in elements)
                    yield return GetMetadataFromObject(elem);
            }
        }


        /// <summary>
        /// Adds a new parameter to the resultParams list. if the parameter value is of the type Resource, every parameter from it is added, but not the origin object.
        /// </summary>
        static void GetParams(string group, string name, object value, MetaDataAttribute metadata, ICollection<ResultParameter> output)
        {
            if (value is IResource)
            {
                string resval = value.ToString();

                output.Add(new ResultParameter(group, name, resval, metadata));
                getMetadataFromObject(value, name + "/",output);
                return;
            }

            var parentName = name;

            IConvertible val;
            if (value == null)
                val = null;
            else if (value is IConvertible conv)
                val = conv;
            else if((val = StringConvertProvider.GetString(value)) == null)
                val = value.ToString();

            output.Add( new ResultParameter(group, parentName, val, metadata));
        }
        
        internal class ParameterCache
        {
            class Box
            {
                public ImmutableDictionary<ITypeData, (IMemberData member, string group, string name, MetaDataAttribute metadata)[]> Data = ImmutableDictionary<ITypeData, (IMemberData member, string group, string name, MetaDataAttribute metadata)[]>.Empty;
            }
            
            static readonly ThreadField<Box> cacheField = new ThreadField<Box>();
            public static void LoadCache() => cacheField.Value = new Box();
            public static IEnumerable<(IMemberData member, string group, string name, MetaDataAttribute metadata)> GetParametersMap(ITypeData type, bool metadataOnly)
            {
                if (cacheField.Value?.Data.TryGetValue(type, out var data) == true)
                {
                    if (metadataOnly)
                        return data.Where(x => x.metadata != null);
                    return data;
                }
                
                var value = getParametersMap(type, false);
                if (cacheField.Value is Box box)
                {
                    box.Data = box.Data.SetItem(type, value.ToArray());
                }
                if (metadataOnly)
                    return value.Where(x => x.metadata != null);
                return value;
            }
            static IEnumerable<(IMemberData member, string group, string name, MetaDataAttribute metadata)> getParametersMap(ITypeData type, bool metadataOnly)
            {
            
                foreach (var prop in type.GetMembers())
                {
                    if (!prop.Readable)
                        continue;
                
                    var metadataAttr = prop.GetAttribute<MetaDataAttribute>();
                    if (metadataAttr == null)
                    {
                        if (metadataOnly) continue;
                    
                        // if metadataAttr is specified, all we require is that we can read and write it. 
                        // Otherwise normal rules applies:

                        if (prop.Writable == false)
                            continue; // Don't add Properties with XmlIgnore attribute
                    
                        if (prop.HasAttribute<System.Xml.Serialization.XmlIgnoreAttribute>())
                            continue;

                        if (!prop.IsBrowsable())
                            continue;
                    }
                
                    if (prop.HasAttribute<NonMetaDataAttribute>())
                        continue; // pretty rare case, best to check this after other things for performance.

                    var display = prop.GetDisplayAttribute();

                    if (metadataAttr != null && string.IsNullOrWhiteSpace(metadataAttr.MacroName))
                        metadataAttr = new MetaDataAttribute(metadataAttr.PromptUser, display.Name)
                        {
                            Group = metadataAttr.Group,
                            Name = metadataAttr.Name
                        };

                    var name = display.Name.Trim();
                    string group = "";

                    if (display.Group.Length == 1) group = display.Group[0].Trim();
                    group = metadataAttr?.Group ?? group;
                    name = metadataAttr?.Name ?? name;

                    yield return (prop, group, name, metadataAttr);
                }
            }
        }

        
        
        static void GetPropertiesFromObject(object obj, ICollection<ResultParameter> output, string namePrefix = "", bool metadataOnly = false, ITypeData type = null)
        {
            if (obj == null)
                return;
            type ??= TypeData.GetTypeData(obj);
            foreach (var (prop, group, name, metadata) in ParameterCache.GetParametersMap(type, metadataOnly))
            {
                object value = prop.GetValue(obj);
                if (value == null)
                    continue;
                GetParams(group, namePrefix + name, value, metadata, output);
            }
        }

        internal static void UpdateParams(ResultParameters parameters, object obj, string namePrefix = "", ITypeData type = null)
        {
            if (obj == null)
                return;
            type ??= TypeData.GetTypeData(obj);
            var p = ParameterCache.GetParametersMap(type, false);
            foreach (var (prop, group, _name, metadata) in p)
            {
                if (prop.GetAttribute<MetaDataAttribute>()?.Frozen == true) continue; 
                var name = namePrefix + _name;
                object value = prop.GetValue(obj);
                if (value == null)
                    continue;
                
                if (value is IResource)
                {
                    string resval = value.ToString();
                    parameters.Overwrite(name, resval, group, metadata);
                    UpdateParams(parameters, value, name);
                    continue;
                }
                
                IConvertible val = value as IConvertible ?? StringConvertProvider.GetString(value) ?? value.ToString();
                parameters.Overwrite(name, val, group, metadata);
            }
        }

        internal void Overwrite(string name, IConvertible value, string group, MetaDataAttribute metadata)
        {
           Add(group, name, value, metadata);
        }

        /// <summary>
        /// Returns a <see cref="ResultParameters"/> list with one entry for every setting of the inputted 
        /// TestStep.
        /// </summary>
        internal static ResultParameters GetParams(ITestStep step, ITypeData type = null)
        {
            if (step == null)
                throw new ArgumentNullException(nameof(step));
            var parameters = new List<ResultParameter>(5);
            GetPropertiesFromObject(step, parameters, type: type);
            
            if (parameters.Count == 0)
                return new ResultParameters();
            return new ResultParameters(parameters);
        }
        
        /// <summary>
        /// Initializes a new instance of the ResultParameters class.
        /// </summary>
        public ResultParameters()
        {
            indexByName = new Dictionary<(string, string), int>();
        }

        /// <summary>
        /// Initializes a new instance of the ResultParameters class.
        /// </summary>
        public ResultParameters(IEnumerable<ResultParameter> items)
        {
            addRangeUnsafe(items, true);
        }
        

        /// <summary>
        /// Returns a dictionary containing all the values in this list indexed by their <see cref="ResultParameter.Name"/>.
        /// </summary>
        /// <returns></returns>
        public Dictionary<string, object> ToDictionary()
        {
            Dictionary<string, object> values = new Dictionary<string, object>();
            foreach (ResultParameter val in this)
            {
                if(values.ContainsKey(val.Name) == false)
                    values.Add(val.Name, val.Value);
            }
            return values;
        }

        /// <summary>
        /// Returns the number of result parameters.
        /// </summary>
        public int Count => count;

        /// <summary> Adds a new element to the parameters. (synchronized). </summary>
        public void Add(ResultParameter parameter) => AddRange(new[] {parameter}); 

        int count = 0;
        
        void addRangeUnsafe(IEnumerable<ResultParameter> parameters, bool initCollection = false)
        {
            if (initCollection)
            {
                var capacity = parameters.Count();
                var data2 = new resultParameter[capacity];
                var indexByName2 = new Dictionary<(string, string), int>(capacity);
                var count2 = 0;
                foreach (var par in parameters)
                {
                    if (par?.Name == null) continue; 
                    if (indexByName2.TryGetValue(par.Key, out var idx))
                    {
                        data2[idx] = par;
                    }
                    else
                    {
                        indexByName2[par.Key] = count2;
                        data2[count2] = par;
                        count2 += 1;
                    }
                }
                // resize data to the actual count. This is a no-op if no change.
                Array.Resize(ref data2, count2);
                data = new SafeArray<resultParameter>(data2);
                indexByName = indexByName2;
                count = count2;
                return;
            }
            
            Dictionary<(string, string), int> newIndexes = null;
            List<ResultParameter> newParameters = null;
            
            foreach (var par in parameters)
            {
                if (!indexByName.TryGetValue(par.Key, out var idx))
                    idx = -1;

                if (idx >= 0)
                {
                    data[idx] = par;
                    continue;
                }

                if (newIndexes == null)
                {
                    newIndexes = new Dictionary<(string, string), int>();
                    newParameters = new List<ResultParameter>();
                }

                if (newIndexes.TryGetValue(par.Key, out idx))
                {
                    newParameters[idx - count] = par;    
                }
                else
                {
                    int nidx = count + newParameters.Count;
                    newParameters.Add(par);
                    newIndexes[par.Key] = nidx;
                }   
            }

            if (newIndexes != null)
            {
                var newSize = count + newParameters.Count;
                if(data.Count < newSize)
                    data.Resize(newSize);
                foreach (var elem in newParameters)
                {
                    data[count] = elem;
                    count += 1;
                }

                foreach (var kv in newIndexes)
                    indexByName.Add(kv.Key, kv.Value);
            }
        }

        Dictionary<(string, string), int> indexByName;

        readonly object addLock = new object();
        
        /// <summary>
        /// Adds a range of result parameters (synchronized).
        /// </summary>
        /// <param name="parameters"></param>
        public void AddRange(IEnumerable<ResultParameter> parameters)
        {
            if (parameters == null)
                throw new ArgumentNullException(nameof(parameters));
            lock(addLock)
                addRangeUnsafe(parameters);
        }

        IEnumerator<ResultParameter> IEnumerable<ResultParameter>.GetEnumerator() => data.Select(x => x.ToResultParameter()).GetEnumerator();
        IEnumerator IEnumerable.GetEnumerator() => data.Select(x => x.ToResultParameter()).GetEnumerator();

        /// <summary> Copies all the data inside a ResultParameters instance. </summary>
        /// <returns></returns>
        internal ResultParameters Clone()
        {
            var r = new ResultParameters
            {
                data = new SafeArray<resultParameter>(data),
                indexByName = new Dictionary<(string, string), int>(indexByName)
            };
            
            return r;
        }
        

        internal IConvertible GetIndexed((string, string) index, ref int keyIndex)
        {
            if(keyIndex == -1)
                keyIndex = FindIndex(index);
            if (keyIndex == -1)
                return null;
            return data[keyIndex].Value;
        }

        internal void SetIndexed((string name, string group) key, ref int index, IConvertible value)
        {
            if(index == -1)
                index = FindIndex(key);
            if (index == -1)
            {
                Add(new ResultParameter(key.group, key.name, value));
            }
            else
            {
                var prev = data[index];
                prev.Value = value;
                prev.Name = key.name;
                prev.Group = key.group;
                data[index] = prev;
            }
        }

        
        internal void IncludeMetadataFromObject(TestPlan obj)
        {
            var metadata = GetMetadataFromObject(obj);
            AddRange(metadata);
        }

        /// <summary> Adds a new result parameter. </summary>
        public void Add(string group, string name, IConvertible value, MetaDataAttribute metaDataAttribute)
        {
            Add(new ResultParameter(group, name, value, metaDataAttribute));
        }
    }
}