//            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;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace OpenTap
{
    /// <summary>
    /// A class to store a column of data for a <see cref="ResultTable"/>.
    /// </summary>
    [Serializable]
    public class ResultColumn : IResultColumn, IData
    {
        /// <summary>
        /// The name of the column.
        /// </summary>
        public string Name { get; private set; }

        /// <summary>
        /// The data in the column.
        /// </summary>
        public Array Data { get; private set; }

        /// <summary>
        /// The TypeCode of data in the column.
        /// </summary>
        public TypeCode TypeCode { get; private set; }

        /// <summary>
        /// String describing the column.
        /// </summary>
        public string ObjectType { get; }

        /// <summary>
        /// Helper to access a strongly typed value in the <see cref="Data"/> array.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="Index">Index in the array.</param>
        /// <returns></returns>
        public T GetValue<T>(int Index) where T : IConvertible
        {
            if ((Index < 0) || (Index >= Data.Length))
                return default;

            var value = Data.GetValue(Index);
            if (value == null)
                return default;
            if (typeof(T) == typeof(object))
                return (T)value;
            return (T)Convert.ChangeType(value, Type.GetTypeCode(typeof(T)));
        }

        /// <summary>
        /// Creates a new populated result column.
        /// </summary>
        /// <param name="name">The name of the column.</param>
        /// <param name="data">The data of the column.</param>
        public ResultColumn(string name, Array data)
        {
            if (name == null) throw new ArgumentNullException(nameof(name));
            if (data == null) throw new ArgumentNullException(nameof(data));

            Name = name;
            Data = data;
            TypeCode = Type.GetTypeCode(data.GetType().GetElementType());
            Parameters = ParameterCollection.Empty;
            ObjectType = ResultObjectTypes.ResultColumn;
        }

        /// <summary> Creates a new result column with parameters attached.  </summary>
        public ResultColumn(string name, Array data, params IParameter[] parameters) : this(name, data)
        {
            Parameters = new ParameterCollection(parameters);
        }

        internal ResultColumn(string name, Array data, IData table, IParameters parameters,
            string ObjectType = ResultObjectTypes.ResultColumn) : this(name, data)
        {
            Parameters = parameters;
            Parent = table;
            this.ObjectType = ObjectType;
        }

        internal ResultColumn WithResultTable(ResultTable table)
        {
            return new ResultColumn(Name, Data, table, Parameters, (this as IAttributedObject).ObjectType);
        }

        /// <summary>
        /// The parent object of this column. Usually a Result Table. This value will get assigned during ResultProxy.Publish.
        /// </summary>
        public IData Parent { get; }

        /// <summary> Unused. </summary>
        long IData.GetID() => 0;

        /// <summary> The parameters attached to this column. </summary>
        public IParameters Parameters { get; }

        /// <summary>  Create a result column clone with additional parameters. </summary>
        public ResultColumn AddParameters(params IParameter[] additionalParameters)
        {
            return new ResultColumn(Name, Data, Parent,
                new ParameterCollection(Parameters.Concat(additionalParameters).ToArray()));
        }
    }

    /// <summary>
    /// A result table containing rows of results with matching names, column name, and types. 
    /// </summary>
    [Serializable]
    public class ResultTable : IResultTable
    {
        /// <summary>
        /// The name of the results.
        /// </summary>
        public string Name { get; private set; }

        ResultColumn[] columns;

        /// <summary> An array containing the result columns. </summary>
        public ResultColumn[] Columns
        {
            get => columns;
            private set => columns = value;
        }

        /// <summary>
        /// Indicates how many rows of results this table contains.
        /// </summary>
        public int Rows { get; private set; }

        IResultColumn[] IResultTable.Columns
        {
            get { return Columns; }
        }

        /// <summary>
        /// The parent of this object.
        /// </summary>
        public IData Parent { get; protected set; }

        /// <summary>
        /// Parameters attached to this Result Table.
        /// Note, test step parameter are often attached in the result listener and does not need to be added here.
        /// </summary>
        public IParameters Parameters { get; } = ParameterCollection.Empty;


        string IAttributedObject.ObjectType => ResultObjectTypes.ResultVector;

        long IData.GetID()
        {
            return 0;
        }

        /// <summary>
        /// Creates an empty results table.
        /// </summary>
        public ResultTable()
        {
            Name = "";
            Columns = new ResultColumn[0];
            Rows = 0;
        }

        /// <summary>
        /// Creates a new result table.
        /// </summary>
        /// <param name="name">The name of the result table.</param>
        /// <param name="resultColumns">The columns of the table.</param>
        public ResultTable(string name, ResultColumn[] resultColumns)
        {
            if (name == null) throw new ArgumentNullException(nameof(name));
            if (resultColumns == null) throw new ArgumentNullException(nameof(resultColumns));

            Name = name;
            columns = resultColumns.ToArray();
            for (int i = 0; i < columns.Length; i++)
            {
                columns[i] = columns[i].WithResultTable(this);
            }

            if (columns.Length <= 0)
                Rows = 0;
            else
            {
                Rows = columns[0].Data.Length;
                for (int i = 1; i < columns.Length; i++)
                {
                    if (columns[i].Data.Length != Rows)
                        throw new ArgumentException("Columns needs to be of same length.", nameof(resultColumns));
                }
            }
        }

        /// <summary>
        /// Creates a new Result Table with a name, result columns and parameters.
        /// </summary>
        public ResultTable(string name, ResultColumn[] resultColumns, params IParameter[] parameters) : this(name,
            resultColumns)
        {
            Parameters = new ParameterCollection(parameters);
        }

        ResultTable(string name, ResultColumn[] resultColumns, IParameters parameters) : this(name, resultColumns)
        {
            Parameters = parameters;
        }

        internal ResultTable WithName(string newName) => new ResultTable(newName, Columns, Parameters);
    }

    /// <summary>
    /// Interface that the TestStep can access through the Results property.
    /// </summary>
    public interface IResultSource
    {
        /// <summary>
        /// Waits for the propagation of results from all Proxies to the Listeners. Normally this is not necessary. 
        /// However, if a step needs to change a property after it has written results, this method makes sure the ResultListeners record the previous/correct value before changing it.
        /// </summary>
        void Wait();

        /// <summary>
        /// Defer an action from the current teststep run.
        /// This action will be called as soon as possible, and block the execution for any parent steps.
        /// </summary>
        /// <param name="action"></param>
        void Defer(Action action);

        /// <summary>
        /// Run an action as the final step after the last deferred action.
        /// This should not be used while the associated TestStep is running.
        /// </summary>
        /// <param name="action"></param>
        void Finally(Action<Task> action);

        /// <summary>
        /// Stores a result. These results will be propagated to the ResultStore after the TestStep completes.
        /// </summary>
        /// <param name="name">Name of the result.</param>
        /// <param name="columnNames">Titles of the columns.</param>
        /// <param name="results">The values of the results to store.</param>
        void Publish(string name, List<string> columnNames, params IConvertible[] results);

        /// <summary>
        /// The fastest way to store a result. These results will be propagated to the ResultStore after the TestStep completes.
        /// </summary>
        /// <param name="name">Name of the result.</param>
        /// <param name="columnNames">Titles of the columns.</param>
        /// <param name="results">The columns of the results to store.</param>
        /// <remarks>
        /// This is the fastest way to store a large number of results.
        /// </remarks>
        void PublishTable(string name, List<string> columnNames, params Array[] results);
    }

    /// <summary>
    /// Temporarily holds results from a TestStep, before they are propagated to the ResultListener by the TestPlan. See <see cref="TestStep.Results"/>
    /// </summary>
    public class ResultSource : IResultSource
    {
        /// <summary>  Logging source for this class. </summary>
        static readonly TraceSource log = Log.CreateSource("ResultProxy");

        static Array GetArray(Type type, object Value)
        {
            var array = Array.CreateInstance(type, 1);
            array.SetValue(Value, 0);
            return array;
        }

        void Propagate(IResultListener rt, ResultTable result)
        {
            try
            {
                rt.OnResultPublished(stepRun.Id, result);
            }
            catch (Exception e)
            {
                log.Warning("Caught exception in result handling task.");
                log.Debug(e);
                planRun.RemoveFaultyResultListener(rt);
            }
        }


        /// <summary>
        /// The current plan run.
        /// </summary>
        readonly TestPlanRun planRun;

        /// <summary>
        /// The TestStepRun for this object.
        /// </summary>
        readonly TestStepRun stepRun;

        /// <summary>
        /// Adds an additional parameter to this TestStep run.
        /// </summary>
        /// <param name="param">Parameter to add.</param>
        public void AddParameter(ResultParameter param)
        {
            stepRun.Parameters.Add(param);
        }

        /// <summary>
        /// Creates a new ResultProxy. Done for each test step run.
        /// </summary>
        /// <param name="stepRun">TestStepRun that this result proxy is proxy for.</param>
        /// <param name="planRun">TestPlanRun that this result proxy is proxy for.</param>
        public ResultSource(TestStepRun stepRun, TestPlanRun planRun)
        {
            this.stepRun = stepRun;
            this.planRun = planRun;
            stepRun.SetResultSource(this);
        }

        /// <summary>
        /// Waits for the propagation of results from all Proxies to the Listeners. Normally this is not necessary. 
        /// However, if a step needs to change a property after it has written results, this method makes sure the ResultListeners record the previous/correct value before changing it.  	 
        /// </summary>
        public void Wait()
        {
            planRun.WaitForResults();
        }

        WorkQueue deferWorker;
        List<Exception> deferExceptions;

        /// <summary>
        /// Defer an action from the current test step run. This means the action will be executed some time after
        /// the current run. 
        /// </summary>
        /// <param name="action"></param>
        public void Defer(Action action)
        {
            if (TapThread.Current != stepRun.StepThread)
                throw new InvalidOperationException(
                    "Defer may only be executed from the same thread as the test step.");
            DeferNoCheck(action);
        }

        int deferCount = 0;

        internal void DeferNoCheck(Action action)
        {
            if (deferWorker == null)
            {
                deferExceptions = new List<Exception>();
                deferWorker = new WorkQueue(WorkQueue.Options.None, "Defer Worker");
            }

            Interlocked.Increment(ref deferCount);
            // only one defer task may run at a time.
            deferWorker.EnqueueWork(() =>
            {
                try
                {
                    action();
                }
                catch (Exception e)
                {
                    deferExceptions.Add(e);
                }
                finally
                {
                    Interlocked.Decrement(ref deferCount);
                }
            });
        }

        static readonly Task Finished = Task.FromResult(0);

        /// <summary>
        /// Run an action as the final step after the last deferred action
        /// </summary>
        /// <param name="action"></param>
        void IResultSource.Finally(Action<Task> action)
        {
            if (deferCount == 0)
            {
                action(Finished);
                deferWorker?.Dispose();
            }
            else
            {
                deferWorker.EnqueueWork(() =>
                {
                    try
                    {
                        if (deferExceptions.Count == 1)
                            action(Task.FromException(deferExceptions[0]));
                        else if (deferExceptions.Count > 1)
                            action(Task.FromException(new AggregateException(deferExceptions.ToArray())));
                        else
                            action(Finished);
                        deferWorker.Dispose();
                    }
                    catch (OperationCanceledException)
                    {
                    }
                    catch (Exception e)
                    {
                        log.Error("Caught error while finalizing test step run. {0}", e.Message);
                        log.Debug(e);
                    }
                });
            }
        }

        Dictionary<ITypeData, Func<object, ResultTable>>
            resultFunc = null; //new Dictionary<Type, Func<object, ResultTable>>();

        readonly object resultFuncLock = new object();

        ResultTable ToResultTable<T>(T result)
        {
            ITypeData runtimeType = TypeData.GetTypeData(result);
            if (resultFunc == null)
            {
                lock (resultFuncLock)
                    resultFunc = new Dictionary<ITypeData, Func<object, ResultTable>>();
            }

            if (!resultFunc.ContainsKey(runtimeType))
            {
                bool enumerable = result is IEnumerable && !(result is string);
                var targetType = runtimeType;
                if (enumerable)
                {
                    targetType = targetType.AsTypeData().ElementType;
                }

                var Typename = targetType.GetDisplayAttribute().GetFullName();
                var classParameters = targetType.GetAttributes<IParameter>().ToArray();
                var Props = targetType.GetMembers()
                    .Where(x => x.Readable && x.TypeDescriptor.DescendsTo(typeof(IConvertible))).ToArray();
                var PropNames = Props.Select(p => p.GetDisplayAttribute().GetFullName()).ToArray();
                var propParameter = Props.Select(p => p.GetAttributes<IParameter>().ToArray()).ToArray();
                resultFunc[runtimeType] = (v) =>
                {
                    int count;
                    IEnumerable values;
                    if (enumerable)
                    {
                        values = (IEnumerable)v;
                        count = values.Count();
                    }
                    else
                    {
                        values = new[] { v };
                        count = 1;
                    }

                    var arrays = Props
                        .Select(p => Array.CreateInstance(p.TypeDescriptor.AsTypeData().Type, count)).ToArray();

                    int j = 0;
                    foreach (var obj in values)
                    {
                        for (int i = 0; i < Props.Length; i++)
                        {
                            arrays[i].SetValue(Props[i].GetValue(obj), j);
                        }

                        j++;
                    }

                    var cols = new ResultColumn[Props.Length];
                    for (int i = 0; i < Props.Length; i++)
                    {
                        cols[i] = new ResultColumn(PropNames[i], arrays[i], propParameter[i]);
                    }

                    return new ResultTable(Typename, cols, classParameters);
                };
            }

            return resultFunc[runtimeType](result);
        }

        /// <summary>
        /// Stores an object as a result.  These results will be propagated to the ResultStore after the TestStep completes.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="result">The result whose properties should be stored.</param>
        public void Publish<T>(T result)
        {
            if (result == null)
                throw new ArgumentNullException(nameof(result));
            PublishTable(ToResultTable(result));
        }

        /// <summary> Publishes a result table. </summary>
        public void Publish(ResultTable result) => PublishTable(result);

        /// <summary>
        /// Stores an object as a result.  These results will be propagated to the ResultStore after the TestStep completes.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="name">The name of the result.</param>
        /// <param name="result">The result whose properties should be stored.</param>
        public void Publish<T>(string name, T result)
        {
            if (result == null)
                throw new ArgumentNullException(nameof(result));
            if (name == null)
                throw new ArgumentNullException(nameof(name));
            Publish(ToResultTable(result).WithName(name));
        }

        /// <summary>
        /// Stores a result. These results will be propagated to the ResultStore after the TestStep completes.
        /// </summary>
        /// <param name="name">Name of the result.</param>
        /// <param name="columnNames">Titles of the columns.</param>
        /// <param name="results">The values of the results to store.</param>
        public void Publish(string name, List<string> columnNames, params IConvertible[] results)
        {
            if (columnNames == null)
                throw new ArgumentNullException(nameof(columnNames));
            if (results == null)
                throw new ArgumentNullException(nameof(results));

            var columns = results.Zip(columnNames, (val, title)
                => new ResultColumn(title, GetArray(val == null ? typeof(object) : val.GetType(), val))).ToArray();

            Publish(new ResultTable(name, columns));
        }

        /// <summary>
        /// The fastest way to store a result. These results will be propagated to the ResultStore after the TestStep completes.
        /// </summary>
        /// <param name="name">Name of the result.</param>
        /// <param name="columnNames">Titles of the columns.</param>
        /// <param name="results">The columns of the results to store.</param>
        /// <remarks>
        /// This is the fastest way to store a large number of results.
        /// </remarks>
        public void PublishTable(string name, List<string> columnNames, params Array[] results)
        {
            if (columnNames == null)
                throw new ArgumentNullException(nameof(columnNames));
            if (results == null)
                throw new ArgumentNullException(nameof(results));

            var columns = results.Zip(columnNames, (val, title) => new ResultColumn(title, val)).ToArray();

            Publish(new ResultTable(name, columns));
        }

        /// <summary> Publishes a result table. </summary>
        public void PublishTable(ResultTable table)
        {
            planRun.ScheduleInResultProcessingThread(new PublishResultTableInvokable(table, this));
        }

        internal bool WasDeferred => deferWorker != null;

        class PublishResultTableInvokable : IInvokable<IResultListener, WorkQueue>, ISkippableInvokable<IResultListener, WorkQueue>
        {
            readonly ResultTable table;
            readonly ResultSource proxy;

            public PublishResultTableInvokable(ResultTable table, ResultSource proxy)
            {
                this.table = table;
                this.proxy = proxy;
            }

            /// <summary>
            /// If possible, introspect the current work queue and collapse result table propagations into one.
            /// This can give a huge performance boost for many use cases, but mostly when PublishTable is not used.
            ///
            /// Note that this has to be done in the result listener thread - since each may have different number of elements queued
            /// depending on the speed of the result listener. Slow ones like internet based ones will have more items queued.
            /// </summary>
            /// <returns>An optimized table or the original one if it is not possible to optimize.</returns>
            ResultTable CreateOptimizedTable(WorkQueue workQueue)
            {
                // optimization: only allocate the list if there are more than one mergeable table.
                List<ResultTable> mergeTables = null;
                
                while (workQueue?.Peek() is PublishResultTableInvokable p)
                {
                    // this can occur if two steps are publishing results in parallel.
                    // in this case, the tables should not be combined.
                    if(p.proxy != proxy)
                        break;
                    
                    // check if the tables can be merged.
                    if (!ResultTableOptimizer.CanMerge(p.table, table) )
                        break;
                    
                    // pop the peeked object
                    var dq = workQueue.Dequeue();
                    if (dq != p)
                    {
                        if (dq == null)
                            // we weren't able to dequeue the object - just give up on the optimization.
                            break; 
                        
                        // This should never happen.
                        // If it did, something went really wrong.
                        Debug.Fail("Peeked object not in front of queue.");
                        throw new InvalidOperationException("Peeked object not in front of queue.");
                    }

                    // optimization: only allocate a list if it helps. Also initialize it two long to avoid more allocations.
                    if (mergeTables == null)
                        mergeTables = new List<ResultTable>{table, p.table};
                    else mergeTables.Add(p.table);
                }

                if (mergeTables != null)
                    return ResultTableOptimizer.MergeTables(mergeTables);

                return table;
            }

            public void Invoke(IResultListener a, WorkQueue queue)
            {
                try
                {
                    // only merge result tables where it is explicitly supported by the result listener.
                    if (a is IMergedTableResultListener)
                    {
                        a.OnResultPublished(proxy.stepRun.Id, CreateOptimizedTable(queue));    
                    }
                    else
                    {
                        a.OnResultPublished(proxy.stepRun.Id, table);
                    }
                }
                catch (Exception e)
                {
                    log.Warning("Caught exception in result handling task.");
                    log.Debug(e);
                    proxy.planRun.RemoveFaultyResultListener(a);
                }
            }

            // Skip the invocation if the result listener does not implement OnResultPublished.
            public bool Skip(IResultListener a, WorkQueue b)
            {
                if (a is ResultListener r)
                    return ResultListener.ImplementsOnResultsPublished(r) == false;
                
                return false;
            }
        }
    }
}