//            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.IO;

namespace OpenTap
{
    #region Data structure
    /// <summary>
    /// A named object.
    /// </summary>
    public interface IAttributedObject
    {
        /// <summary>
        /// Name of this object.  
        /// </summary>
        string Name { get; }
        /// <summary>
        /// String describing this object.  
        /// </summary>
        string ObjectType { get; }
    }

    /// <summary>
    /// A named parameter.
    /// </summary>
    public interface IParameter : IAttributedObject
    {
        /// <summary>
        /// Optional name of the group of parameters to which this parameter belongs.  
        /// </summary>
        string Group { get; }

        /// <summary>
        /// Value of this parameter.  
        /// </summary>
        IConvertible Value { get; }
    }

    /// <summary>
    /// A list of parameters, with a string indexer.
    /// </summary>
    public interface IParameters : IList<IParameter>
    {
        /// <summary>
        /// Get a parameter by name. This can be the ObjectType or Name of a parameter. e.g "OpenTap.Unit" or just "Unit".
        /// </summary>
        /// <returns>Null if the parameter was not found</returns>
        IConvertible this[string Name] { get; }
    }

    /// <summary>
    /// An object in a hierarchy with a name and some named properties.
    /// </summary>
    public interface IData : IAttributedObject
    {
        /// <summary>
        /// Parent of this object. 
        /// </summary>
        IData Parent { get; }
        /// <summary>
        /// All parameters that describes this object.
        /// </summary>
        IParameters Parameters { get; }

        /// <summary>
        /// Returns an ID that identifies this object.
        /// </summary>
        /// <returns></returns>
        long GetID();
    }

    /// <summary>
    /// Contains data that has the same table name, column names, and result data types as a <see cref="ResultTable"/>.
    /// </summary>
    public interface IResultTable : IData
    {
        /// <summary>
        /// Array containing the result columns.  
        /// </summary>
        IResultColumn[] Columns { get; }
    }

    /// <summary>
    /// Interface to store <see cref="IResultTable"/> column data.
    /// </summary>
    public interface IResultColumn : IAttributedObject
    {
        /// <summary>
        /// Data in the column.  
        /// </summary>
        Array Data { get; }
    }
    
    /// <summary>
    /// An "extensible Enum" that can be used to describe attachments.
    /// </summary>
    public class AttachmentType : IEquatable<AttachmentType>
    {
        #region Support
        private string _TypeName;

        /// <summary>
        /// Creates an attachment type object.
        /// </summary>
        public AttachmentType(string TypeName)
        {
            this._TypeName = TypeName;
        }

        /// <summary>
        /// Compares this object to another.
        /// </summary>
        bool IEquatable<AttachmentType>.Equals(AttachmentType other)
        {
            return _TypeName == other._TypeName;
        }

        /// <summary>
        /// Compares this object to another.
        /// </summary>
        public override bool Equals(object obj)
        {
            if (obj is AttachmentType)
                return _TypeName == ((AttachmentType)obj)._TypeName;
            else
                return false;
        }

        /// <summary>
        /// Returns the hashcode for this object.
        /// </summary>
        public override int GetHashCode()
        {
            return _TypeName.GetHashCode();
        }
        #endregion

        /// <summary>
        /// A log file.
        /// </summary>
        public static AttachmentType LogFile { get { return new AttachmentType("LogFile"); } }
        /// <summary>
        /// A TestPlan XML file.
        /// </summary>
        public static AttachmentType TestPlan { get { return new AttachmentType("TestPlan"); } }
    }
#endregion

#region Searching
    /// <summary>
    /// The operation for <see cref="SearchParameterValue"/>.
    /// </summary>
    public enum ComparisonOperator
    {
        /// <summary>Two specified values must be the same.</summary>
        Equal,
        /// <summary>Two specified values must be different.</summary>
        NotEqual,
        /// <summary>Parameter must be less than.</summary>
        Less,
        /// <summary>Parameter must be less than or equal.</summary>
        LessEqual,
        /// <summary>Parameter must be greater than.</summary>
        Greater,
        /// <summary>Parameter must be greater than or equal.</summary>
        GreaterEqual,

        /// <summary>Parameter must be similar to the value.</summary>
        /// <remarks>This is guaranteed to be true if the two values are equal, but is not otherwise guaranteed to work in any specific way.</remarks>
        Like,

        /// <summary>
        /// Value must exist as a parameter name or value. 
        /// </summary>
        Exists
    }

    /// <summary>
    /// Operation for <see cref="SearchCombinator"/>.
    /// </summary>
    public enum LogicalOperator
    {
        /// <summary>
        /// Specifies that both conditions must be satisfied.
        /// </summary>
        And,
        /// <summary>
        /// Specifies that at least one of the two conditions must be satisfied.
        /// </summary>
        Or
    }

    /// <summary>
    /// The basic search operand from which the other search operands are derived. 
    /// </summary>
    public abstract class SearchOperand
    {
    }

    /// <summary> Matches all children of the specified parents. </summary>
    public class SearchChildrenOf : SearchOperand
    {
        /// <summary>
        /// The list of elements to match the children of.
        /// </summary>
        public List<IData> Parents { get; set; }

        /// <summary> Matches all children of the specified parents. </summary>
        /// <param name="parents"></param>
        public SearchChildrenOf(List<IData> parents)
        {
            Parents = parents;
        }
    }

    /// <summary>
    /// Matches the last test plan run.
    /// </summary>
    public class SearchLastRun : SearchOperand
    {
        /// <summary>
        /// Number of the last runs to select.
        /// </summary>
        public int Count { get; }

        /// <summary>
        /// Matches the last test plan run.
        /// </summary>
        public SearchLastRun(int count = 1)
        {
            Count = count;
        }
    }

    /// <summary> A binary operation between two other operations. </summary>
    public class SearchCombinator : SearchOperand
    {
        /// <summary>
        /// Left-side operand.  
        /// </summary>
        public SearchOperand A { get; }

        /// <summary>
        /// Operation to perform.  
        /// </summary>
        public LogicalOperator Operator { get; }

        /// <summary>
        /// Right-side operand.  
        /// </summary>
        public SearchOperand B { get; }

        /// <summary> A binary operation between two other operations. </summary>
        public SearchCombinator(SearchOperand a, LogicalOperator logicalOperator, SearchOperand b)
        {
            A = a;
            Operator = logicalOperator;
            B = b;
        }
    }

    /// <summary>
    /// Comparison between a named parameter and a value.
    /// </summary>
    public class SearchParameterValue : SearchOperand
    {
        /// <summary>
        /// Scope of the parameter to match ("", "plan", or "step").  
        /// </summary>
        public string Scope { get; }

        /// <summary>
        /// GroupName of the parameter to match (leave empty to match any group).  
        /// </summary>
        public string Group { get;}

        /// <summary>
        /// Name of the parameter to match.  
        /// </summary>
        public string Parameter { get;}

        /// <summary>
        /// Operation to perform.  
        /// </summary>
        public ComparisonOperator CompareOperator { get;}

        /// <summary>
        /// Value to compare against the right-side value.  
        /// </summary>
        public IConvertible Value { get; }
        /// <summary> Comparison between a named parameter and a value. </summary>
        /// <param name="parameter"></param>
        /// <param name="compareOperator"></param>
        /// <param name="value"></param>
        /// <param name="group"></param>
        /// <param name="scope"></param>
        public SearchParameterValue(string parameter, ComparisonOperator compareOperator, IConvertible value, string group = "", string scope = "")
        {
            Parameter = parameter;
            CompareOperator = compareOperator;
            Value = value;
            Group = group;
            Scope = scope;
        }
    }

    /// <summary>
    /// Comparison between a named parameter and a value.
    /// </summary>
    public class SearchRange : SearchOperand
    {
        /// <summary>
        /// The scope of the parameter to match. Could be "plan" or "step".
        /// </summary>
        public string Scope { get; set; }

        /// <summary>
        /// The name of the parameter to match.
        /// </summary>
        public string Parameter { get; set; }

        /// <summary>
        /// The value to compare against as the right-hand side.
        /// </summary>
        public ICombinedNumberSequence<long> Value { get; set; }
    }

    /// <summary>
    /// The conditions for what to search for.
    /// </summary>
    public class SearchCondition
    {
        /// <summary>
        /// When true, specifies that any matched tree nodes automatically match all parents of that <see cref="IData"/> element.  
        /// </summary>
        public bool GetParents { get; set; }

        /// <summary>
        /// When true, specifies that a matched tree root node automatically matches all children of that given <see cref="IData"/> element.  
        /// </summary>
        public bool GetChildren { get; set; }

        /// <summary>
        /// The tree of <see cref="SearchOperand"/> conditions to match for.  
        /// </summary>
        public SearchOperand Operation { get; set; }

        /// <summary>
        /// Condition that will match all elements in the result store.  
        /// </summary>
        /// <returns></returns>
        public static SearchCondition All()
        {
            return new SearchCondition { GetChildren = true, GetParents = true, Operation = null };
        }

        /// <summary>
        /// Condition that will match any elements in a list as well as all children of those elements.  
        /// </summary>
        /// <param name="testPlanRunIds"></param>
        public static SearchCondition ChildrenOf(IEnumerable<IData> testPlanRunIds)
        {
            return new SearchCondition { Operation = new SearchChildrenOf(testPlanRunIds.ToList()), GetChildren = true, GetParents = false };
        }

        /// <summary>
        /// Condition that will match all elements in the result store.  
        /// </summary>
        /// <returns></returns>
        public static SearchCondition LastRun()
        {
            return new SearchCondition { GetChildren = true, GetParents = true, Operation = new SearchLastRun() };
        }
    }
    #endregion

    /// <summary>
    /// A structure containing limit set data.
    /// </summary>
    public class LimitSet
    {
        /// <summary>
        /// The friendly name of the limit set.
        /// </summary>
        public string Name { get; private set; }

        /// <summary>
        /// The limits in this limit set.
        /// </summary>
        public List<Limit> Limits { get; set; }

        /// <summary>
        /// Initializes a new instance of the <see cref="LimitSet"/> class.
        /// </summary>
        /// <param name="name"></param>
        public LimitSet(string name)
        {
            Name = name;
            Limits = new List<Limit>();
        }
    }

    /// <summary>
    /// A single limit from a limit set.
    /// </summary>
    public class Limit : ValidatingObject
    {
        /// <summary>
        /// The result name to match.
        /// </summary>
        [Display("Result Name", Description: "The name of the result to match.", Order: -10)]
        public string ResultName { get; set; }
        /// <summary>
        /// The result column to which the limits are applied.
        /// </summary>
        [Display("Column Name", Description: "The name of the result column to apply limit to.", Order: -9)]
        public string ColumnName { get; set; }
        /// <summary>
        /// The lower limit to apply to the result.
        /// </summary>
        [Display("Lower Limit", Description: "The lower limit. To pass the column value must be above this.", Order: -8)]
        public double LowerLimit { get; set; }
        /// <summary>
        /// The upper limit to apply to the result.
        /// </summary>
        [Display("Upper Limit", Description: "The upper limit. To pass the column value must be below this.", Order: -7)]
        public double UpperLimit { get; set; }
        /// <summary>
        /// The conditions that have to apply for this limit.
        /// </summary>
        [Display("Conditions", Description: "Additional conditions that apply for this limit. All conditions must evaluate to true for this limit to be used.", Order: -6)]
        public List<LimitCondition> Conditions { get; set; }

        /// <summary>
        /// Initializes a new instance of the <see cref="Limit"/> class.
        /// </summary>
        public Limit()
        {
            Rules.Add(() => !string.IsNullOrWhiteSpace(ResultName), "Result Name must be valid.", "ResultName");
            Rules.Add(() => !string.IsNullOrWhiteSpace(ColumnName), "Column Name must be valid.", "ColumnName");

            Conditions = new List<LimitCondition>();
            ResultName = "";
            ColumnName = "";
        }
    }

    /// <summary>
    /// A condition for a specific limit that must be satisfied for the limit to apply.
    /// </summary>
    public class LimitCondition : ValidatingObject
    {
        /// <summary>
        /// The result column name that this condition applies to.
        /// </summary>
        [Display("When Column", Description: "The condition value tested comes from the result column with this name.", Order: -3)]
        public string ColumnName { get; set; }
        /// <summary>
        /// The lower limit for this condition.
        /// </summary>
        [Display("Greater Than", Description: "The condition value must be above this value.", Order: -2)]
        public double LowerLimit { get; set; }
        /// <summary>
        /// The upper limit for this condition.
        /// </summary>
        [Display("Less Than", Description: "The condition value must be below this value.", Order: -1)]
        public double UpperLimit { get; set; }

        /// <summary>
        /// Returns a string describing this object.
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            return String.Format("{0} < {1} < {2}", LowerLimit, ColumnName, UpperLimit);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="LimitCondition"/> class.
        /// </summary>
        public LimitCondition()
        {
            Rules.Add(() => !string.IsNullOrWhiteSpace(ColumnName), "Column Name must be valid.", "ColumnName");
        }
    }

    /// <summary>
    /// Interface to results storage plugins.
    /// </summary>
    public interface IResultStore : IResource, ITapPlugin
    {
        /// <summary>
        /// Get list of properties on entries in the database which starts with a given string.
        /// The returned properties should be ordered by their frequency of use in the dataset.
        /// </summary>
        /// <param name="scope">Only consider parameters from this scope. Could be "plan" or "step", or empty to consider all scopes.</param>
        /// <param name="group">Only consider parameters from this parameter group. Can be empty to match any group.</param>
        /// <param name="startsWith"></param>
        /// <param name="limit"></param>
        List<string> GetProperties(string scope, string group, string startsWith, int limit);

        /// <summary>
        /// Gets all <see cref="IData"/> elements which match a given search condition.
        /// </summary>
        /// <param name="cond"></param>
        /// <param name="limitsets"></param>
        /// <param name="withResults"></param>
        IEnumerable<IData> GetEntries(SearchCondition cond, List<string> limitsets, bool withResults);

        /// <summary>
        /// Tries to delete the given entries and all sub entries.
        /// </summary>
        /// <param name="entries">Entries to delete.</param>
        bool DeleteEntries(IEnumerable<IData> entries);

        /// <summary>
        /// Returns all registered limit sets.
        /// </summary>
        List<LimitSet> GetLimitSets();
        /// <summary>
        /// Adds a limit set to the results store.
        /// </summary>
        /// <param name="limitSet"></param>
        void AddLimitSet(LimitSet limitSet);
        /// <summary>
        /// Deletes a limit set from the database.
        /// </summary>
        /// <param name="Name">The name of the limit set to delete.</param>
        void DeleteLimitSet(string Name);

        /// <summary>
        /// Returns the binary data for the given objects attachment, or null if it could not be found.
        /// </summary>
        /// <param name="entry"></param>
        /// <param name="attachmentType"></param>
        byte[] GetAttachment(IData entry, AttachmentType attachmentType);
        /// <summary>
        /// Gets a list of attachments on the given object.
        /// </summary>
        /// <param name="entry"></param>
        List<AttachmentType> GetValidAttachments(IData entry);

        /// <summary>
        /// Returns the average duration of the last <paramref name="averageCount"/> step runs with similar settings.
        /// </summary>
        /// <param name="step"></param>
        /// <param name="averageCount"></param>
        TimeSpan? GetAverageDuration(TestStepRun step, int averageCount);
        /// <summary>
        /// Returns the average duration of the last <paramref name="averageCount"/> PlanRuns runs with a similar plan.
        /// </summary>
        /// <param name="plan"></param>
        /// <param name="averageCount"></param>
        TimeSpan? GetAverageDuration(TestPlanRun plan, int averageCount);
    }

    /// <summary>
    /// IResultStore that supports attachment streams.
    /// </summary>
    public interface IAttachmentStream : IResultStore
    {

        /// <summary>
        /// Returns a stream that can read a given attachment entry. The returned stream must be disposed.
        /// </summary>
        /// <param name="entry"></param>
        /// <param name="attachmentType"></param>
        Stream GetAttachmentStream(IData entry, AttachmentType attachmentType);
    }

    /// <summary>
    /// Interface to support result tagging in the OpenTAP Results Viewer.
    /// </summary>
    public interface IResultTagging : IResultStore
    {
        /// <summary>
        /// Add a TestPlan parameter to a number of TestPlans.
        /// </summary>
        void AddTestPlanRunParameter(IEnumerable<IData> PlanRunIDs, string Group, string ParameterName, IConvertible Value);

        /// <summary>
        /// Delete a TestPlan parameter from a number of TestPlans.
        /// </summary>
        void DeleteTestPlanRunParameter(IEnumerable<IData> PlanRunIDs, string Group, string ParameterName, IConvertible Value);

        /// <summary>
        /// Get distinct TestPlan parameter values ordered by popularity (number of uses). Optionally limited to Limit values, scope and group.
        /// </summary>
        IEnumerable<string> GetTestPlanRunParameterValues(string ParameterName, string Scope = "", string Group = "", int Limit = -1);
    }

    /// <summary>
    /// Delegate that triggers notification updates when results are added to the store.
    /// </summary>
    public delegate void ResultUpdateEvent(object Sender);

    /// <summary>
    /// Interface to add notifications when the Results Viewer gets new data.
    /// </summary>
    public interface IResultStoreNotification : IResultStore
    {
        /// <summary>
        /// Event triggered when results are added to the store.
        /// </summary>
        event ResultUpdateEvent ResultUpdated;

        /// <summary>
        /// Event triggered when TestPlan or TestStep runs are added to the store.
        /// </summary>
        event ResultUpdateEvent RunsUpdated;

        /// <summary>
        /// Enables the Updated events.
        /// </summary>
        void EnableUpdateEvents();

        /// <summary>
        /// Disables the Updated events.
        /// </summary>
        void DisableUpdateEvents();
    }

    /// <summary>
    /// When implemented along with <see cref="IResultStore"/>, this interface allows files with a given extension to be opened using your <see cref="ResultListener"/>. 
    /// It also can be used to allow the export of results to a file. 
    /// </summary>
    public interface IFileResultStore
    {
        /// <summary>
        /// Gets or sets the currently chosen file.
        /// </summary>
        string FilePath { set; get; }

        /// <summary>
        /// Default extension without the dot (.) that files must match in order to load a file's results to Results Viewer (e.g. TapResults, not .TapResults).  
        /// </summary>
        string DefaultExtension { get; }
    }
}