//            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.ComponentModel;
using System.Reflection;
using System.Xml.Serialization;
using System.Text;
using System.Xml.Linq;
using System.Threading;

namespace OpenTap.Plugins.BasicSteps
{
    /// <summary> Sweep behavior for linear sweeps. </summary>
    public enum SweepBehavior
    {
        /// <summary> Linear growth function. </summary>
        [Display("Linear", Description: "Linear growth function.")]
        Linear = 0,
        /// <summary> Exponential growth function.</summary>
        [Display("Exponential", Description: "Exponential growth function.")]
        Exponential = 1
    }

    [Browsable(false)]
    [Display("Sweep Loop (Range)", Groups: new [] { "Flow Control", "Legacy" }, Description: "Loops all of its child steps while sweeping a specified parameter/setting over a range.", Collapsed:true)]
    [AllowAnyChild]
    public class SweepLoopRange : LoopTestStep
    {

        [Display("Sweep Parameters", Order: -4, Description: "Test step parameters that should be swept. The variable must be a numeric type.")]
        [XmlIgnore]
        [Browsable(true)]
        [Unsweepable]
        public List<IMemberData> SweepProperties { get; set; }

        [Display("Start", Order: -2, Description: "The parameter value where the sweep will start.")]
        public decimal SweepStart { get; set; }

        [Display("Stop", Order: -1, Description: "The parameter value where the sweep will stop.")]
        public decimal SweepStop { get; set; }

        [Browsable(false)]
        public decimal SweepEnd { get { return SweepStop; } set { SweepStop = value; } }


        [Display("Step Size", Order: 1, Description: "The value to be increased or decreased between every iteration of the sweep.")]
        [EnabledIf("SweepBehavior", SweepBehavior.Linear, HideIfDisabled = true)]
        [XmlIgnore] // this is inferred from the other properties and should not be set by the serializer
        [Browsable(true)]
        public decimal SweepStep
        {
            get
            {
                if (SweepPoints == 0) return 0;
                if (SweepPoints == 1) return 0;
                return (SweepStop - SweepStart) / (SweepPoints - 1);
            }
            set
            {
                if (decimal.Zero == value) return;
                var newv = (uint)Math.Round((SweepStop - SweepStart) / value) + 1;
                SweepPoints = newv;
            }
        }

        [Display("Points", Order: 1, Description: "The number of points to sweep.")]
        public uint SweepPoints { get; set; }
        
        [Display("Behavior", Order: -3, Description: "Linear or exponential growth.")]
        public SweepBehavior SweepBehavior { get; set; }

        [Output]
        [Display("Current Value", "Shows the current value of the loop.", Order: 4)]
        public decimal Current { get; private set; }

        [Browsable(false)]
        [DeserializeOrder(1.0)]
        public string SweepPropertyName
        {
            get => propertyInfosToString(SweepProperties);
            set => SweepProperties = parseInfosFromString(value).ToList();
        }

        static string propertyInfosToString(IEnumerable<IMemberData> infos)
        {
            return string.Join("|", infos.Select(x => String.Format("{0};{1}", x.Name, x.DeclaringType.Name)));
        }

        List<IMemberData> parseInfosFromString(string str)
        {
            var cs = this.RecursivelyGetChildSteps(TestStepSearch.All).Select( x => TypeData.GetTypeData(x)).ToArray();
            var allMembers = cs.SelectMany(x => x.GetMembers().ToArray());
            Dictionary<string, IMemberData> dict = new Dictionary<string, IMemberData>();
            foreach(var x in allMembers)
            {
                var key = String.Format("{0};{1}", x.Name, x.DeclaringType.Name);
                dict[key] = x;
            }
            var items = str.Split('|');
            List<IMemberData> outlist = new List<IMemberData>();
            foreach (var item in items)
            {
                if (dict.TryGetValue(item, out IMemberData member))
                    outlist.Add(member);
            }
            return outlist;
        }

        public override void PrePlanRun()
        {
            if (SweepProperties.Count == 0)
                throw new InvalidOperationException("No parameters selected to sweep");
            validateSweepMutex.WaitOne();
            validateSweepMutex.ReleaseMutex();
        }

        ITypeData SweepType => SweepProperties.FirstOrDefault()?.TypeDescriptor;

        // Check if the test plan is running before validating sweeps.
        // the validateSweep might have been started before the plan started.
        // hence we use the validateSweeepMutex to ensure that validation is done before 
        // the plan starts.
        bool isRunning => GetParent<TestPlan>()?.IsRunning ?? false;
        Mutex validateSweepMutex = new Mutex();
        string validateSweep(decimal Value)
        {   // Mostly copied from Run
            if (SweepProperties.Count == 0) return "";
            if (isRunning) return ""; // Avoid changing the value during run when the gui asks for validation errors.
            if (!validateSweepMutex.WaitOne(0)) return "";
            StringBuilder sb = new StringBuilder();

            var sets = GetPropertySets(ChildTestSteps).ToList();
            var originalValues = sets.Select(set => set.GetValue()).ToArray();
            try
            {
                foreach (var set in sets)
                    set.SetValue(Value, false);
                bool first = true;
                foreach (var step in sets)
                {
                    if (string.IsNullOrWhiteSpace(step.Obj.Error))
                        continue;
                    if (first)
                        first = false;
                    else
                        sb.AppendLine();
                    ITestStep step2 = step.Obj as ITestStep;
                    if (step2 != null)
                        sb.AppendFormat("Step '{0}' : {1}", step2.Name, step2.Error);
                    else
                        sb.AppendFormat("Object '{0}' : {1}", step.Obj, step.Obj.Error);
                }
                return sb.ToString();
            }
            catch (TargetInvocationException e)
            {
                return e.InnerException.Message;
            }
            finally
            {
                for (int i = 0; i < sets.Count; i++)
                    sets[i].SetValue(originalValues[i], false);
                validateSweepMutex.ReleaseMutex();
            }
        }

        public SweepLoopRange()
        {
            SweepProperties = new List<IMemberData>();

            SweepStart = 1;
            SweepStop = 100;
            SweepPoints = 100;

            Rules.Add(() => SweepProperties.Count != 0, "No parameters selected to sweep", nameof(SweepProperties));
            Rules.Add(() => string.IsNullOrWhiteSpace(validateSweep(SweepStart)), () => validateSweep(SweepStart), "SweepStart");
            Rules.Add(() => string.IsNullOrWhiteSpace(validateSweep(SweepStop)), () => validateSweep(SweepStop), "SweepEnd");

            Rules.Add(() => ((SweepBehavior != SweepBehavior.Exponential)) || (SweepStart != 0), "Sweep start value must be non-zero.", "SweepStart");
            Rules.Add(() => ((SweepBehavior != SweepBehavior.Exponential)) || (SweepStop != 0), "Sweep end value must be non-zero.", "SweepEnd");
            Rules.Add(() => SweepPoints > 1, "Sweep points must be bigger than 1.", "SweepPoints");
            
            Rules.Add(() => ((SweepBehavior != SweepBehavior.Exponential)) || (Math.Sign(SweepStop) == Math.Sign(SweepStart)), "Sweep start and end value must have the same sign.", "SweepEnd", "SweepStart");

            ChildTestSteps.ChildStepsChanged += childStepsChanged;
            PropertyChanged += SweepLoopRange_PropertyChanged;
        }

        void SweepLoopRange_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            if (e.PropertyName == nameof(ChildTestSteps))
                ChildTestSteps.ChildStepsChanged += childStepsChanged;
        }

        readonly Dictionary<IMemberData, object> membersCache = new Dictionary<IMemberData, object>();
        void childStepsChanged(TestStepList sender, TestStepList.ChildStepsChangedAction Action, ITestStep Object, int Index)
        {
            // Make a copy to stop collection modified exception in TapSerializer.
            membersCache.Clear();
            getPropertiesForItems(this, membersCache);
            SweepProperties.RemoveIf<IMemberData>(x => membersCache.ContainsKey(x) == false);

        }
        static bool memberCanSweep(IMemberData mem) => false == mem.HasAttribute<UnsweepableAttribute>();
        static void getPropertiesForItems(ITestStep step, Dictionary<IMemberData, object> members)
        {
            foreach (ITestStep cs in step.ChildTestSteps)
            {
                foreach (var member in TypeData.GetTypeData(cs).GetMembers())
                {
                    if (member.TypeDescriptor is TypeData t)
                    {
                        if (t.Type.IsNumeric() && members.ContainsKey(member) == false && memberCanSweep(member))
                        {
                            members.Add(member, member.GetValue(cs));
                        }
                    }
                }
                getPropertiesForItems(cs, members);
            }
        }

        internal static Dictionary<IMemberData, object> GetPropertiesForItems(ITestStep baseStep)
        {
            Dictionary<IMemberData, object> members = new Dictionary<IMemberData, object>();
            getPropertiesForItems(baseStep, members);
            return members;
        } 

        /// <summary> Obj/Property mapping </summary>
        struct ObjPropSet
        {
            public IValidatingObject Obj;
            public IMemberData Prop;
            public void SetValue(object value, bool invokePropertyChanged = true)
            {

                if (Prop.TypeDescriptor.DescendsTo(value.GetType()))
                {
                    Prop.SetValue(Obj, value);
                }
                else if(Prop.TypeDescriptor is TypeData cst)
                {
                    Prop.SetValue(Obj, Convert.ChangeType(value, cst.Type));
                }
                else
                {
                    return;
                }
                if (invokePropertyChanged)
                    Obj.OnPropertyChanged(Prop.Name);
            }
            public object GetValue()
            {
                return Prop.GetValue(Obj);
            }
        }

        IEnumerable<ObjPropSet> GetPropertySets(TestStepList childTestStep)
        {
            foreach (var step in childTestStep)
            {
                foreach (var prop in SweepProperties)
                {
                    IMemberData paramProp = TypeData.GetTypeData(step).GetMember(prop.Name);
                    if (paramProp != null && (paramProp.TypeDescriptor == prop.TypeDescriptor && paramProp.GetDisplayAttribute().GetFullName() == prop.GetDisplayAttribute().GetFullName()))
                        yield return new ObjPropSet { Obj = step, Prop = paramProp };
                    if (step is TestPlanReference) continue; //TODO: keep this hack?
                    foreach (var set in GetPropertySets(step.ChildTestSteps))
                    {
                        yield return set;
                    }
                }
            }
        }


        public static IEnumerable<decimal> LinearRange(decimal start,  decimal end, int points)
        {
            if (points == 0) yield break;
            decimal Value = start;
            for(int i = 0; i < points - 1; i++)
            {
                yield return (start * (points - 1- i) + end * (i)) / (points - 1);
            }
            yield return end;
        }

        public static IEnumerable<decimal> ExponentialRange(decimal start, decimal end, int points)
        {
            if (start == 0)
                throw new ArgumentException("Start value must be different than zero.");
            if (end == 0)
                throw new ArgumentException("End value must be different than zero.");
            if (Math.Sign(start) != Math.Sign(end))
                throw new ArgumentException("Start and end value must have the same sign.");
            
            var logs = Math.Log10((double) start);
            var loge = Math.Log10((double) end);
            return LinearRange((decimal)logs, (decimal)loge, points).Select(x => (decimal)Math.Pow(10, (double)x));
        }
        
        
        public override void Run()
        {
            base.Run();

            var sets = GetPropertySets(ChildTestSteps).ToList();
            var originalValues = sets.Select(set => set.GetValue()).ToArray();


            IEnumerable<decimal> range = LinearRange(SweepStart, SweepStop, (int)SweepPoints);

            if (SweepBehavior == SweepBehavior.Exponential)
                range = ExponentialRange(SweepStart, SweepStop, (int)SweepPoints);

            var disps = SweepProperties.Select(x => x.GetDisplayAttribute()).ToList();
            string names = string.Join(", ", disps.Select(x => x.Name));
            
            if (disps.Count > 1)
                names = string.Format("{{{0}}}", names);

            foreach (var Value in range)
            {
                Current = Value;
                OnPropertyChanged("Current");
                foreach (var set in sets)
                {
                    try
                    {
                        set.SetValue(Value);
                    }
                    catch (TargetInvocationException ex)
                    {
                        Log.Error("Unable to set '{0}' to value '{2}': {1}", set.Prop.GetDisplayAttribute().Name, ex.InnerException.Message, Value);
                        Log.Debug(ex.InnerException);
                    }
                }

                var AdditionalParams = new ResultParameters();
                
                foreach (var disp in disps)
                    AdditionalParams.Add(new ResultParameter(disp.Group.FirstOrDefault() ?? "", disp.Name, Value));

                Log.Info("Running child steps with {0} = {1} ", names, Value);

                var runs = RunChildSteps(AdditionalParams, BreakLoopRequested, throwOnBreak: false).ToArray();
                if (BreakLoopRequested.IsCancellationRequested) break;
                runs.ForEach(r => r.WaitForCompletion());
                if (runs.LastOrDefault()?.BreakConditionsSatisfied() == true)
                    break;
            }
            for (int i = 0; i < sets.Count; i++)
                sets[i].SetValue(originalValues[i]);
        }
    }

    public class LegacySweepLoader : TapSerializerPlugin
    {
        public override double Order { get { return 4; } }

        HashSet<XElement> proccessingNodes = new HashSet<XElement>();

        static readonly XName Type = "type";
        
        public override bool Deserialize(XElement node, ITypeData t, Action<object> setter)
        {
            var typeAttribute = node.Attribute(Type);
            if(typeAttribute != null && (typeAttribute.Value == "OpenTap.Plugins.BasicSteps.LinearSweepLoop" || typeAttribute.Value == "OpenTap.Plugins.BasicSteps.SweepLoopRange") )
            {
                if (!proccessingNodes.Add(node))
                    return false;
                try
                {
                    typeAttribute.SetValue(typeof(SweepLoopRange).FullName);
                    //Rename old SweepEnd setting to its new (8x) name "SweepStop"
                    var newN = node.Element("SweepStop");
                    var oldN = node.Element("SweepEnd");
                    if (oldN != null)
                    {
                        oldN.Name = "SweepStop";

                        if (newN != null)
                        {
                            if (oldN.Attribute("external") != null && newN.Attribute("external") == null)
                                newN.SetAttributeValue("external", oldN.Attribute("external").Value); // move the attribute from the old to the new

                            oldN.Remove();
                        }
                    }
                    return Serializer.Deserialize(node, setter, typeof(SweepLoopRange));
                }
                finally
                {
                    proccessingNodes.Remove(node);
                }
            }
            return false;
        }

        public override bool Serialize(XElement node, object obj, ITypeData expectedType)
        {
            return false;
        }
    }
}