//            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.ComponentModel;
using System.Linq;
using System.IO;
using System.Xml.Serialization;
using System.Xml.Linq;
using OpenTap.Diagnostic;

namespace OpenTap.Plugins.BasicSteps
{
    [Browsable(false)]
    [Display("Test Plan Reference", "References a test plan from an external file directly, without having to store the test plan as steps in the current test plan.", "Flow Control")]
    [AllowAnyChild]
    public class TestPlanReference : TestStep
    {
        /// <summary>
        /// Mapping between step GUIDs. Old version -> New Version.
        /// </summary>
        public class GuidMapping
        {
            public Guid Guid1 { get; set; }
            public Guid Guid2 { get; set; }
        }

        /// <summary>
        /// This is the list of path of test plan loaded and used to prevent recursive TestPlan references.
        /// </summary>
        [ThreadStatic]
        static HashSet<string> referencedPlanPaths;
        
        /// <summary>  Gets or sets if the loaded test steps should be hidden from the user. </summary>
        [Display("Hide Steps", Order: 0, Description: "Set if the steps should run hidden (isolated) or if they should be loaded into the test plan.")]
        private bool HideSteps { get; set; }

        ITestStepParent parent;
        // The PlanDir of 'this' should be ignored when calculating Filepath, so the MacroString context is set to the parent.
        [XmlIgnore]
        public override ITestStepParent Parent { get => parent; set { Filepath.Context = value; parent = value; } }

        MacroString filepath = new MacroString();
        string currentlyLoaded;

        public bool CanOpenFile => File.Exists(filepath.Expand());
        
        [Display("Referenced Plan", Order: 0, Description: "A file path pointing to a test plan which will be loaded as read-only test steps.")]
        [Browsable(true)]
        [FilePath(FilePathAttribute.BehaviorChoice.Open, "TapPlan")]
        [DeserializeOrder(1.0)]
        [Unsweepable]
        public MacroString Filepath
        {
            get => filepath; 
            set {

                filepath = value;
                filepath.Context = this;
                try
                {
                    var rp = TapSerializer.GetObjectDeserializer(this)?.ReadPath;
                    if (rp != null) rp = System.IO.Path.GetDirectoryName(rp);
                    var fp = filepath.Expand(testPlanDir: rp);
                    
                    if (currentlyLoaded != fp)
                    {
                        LoadTestPlan();
                        currentlyLoaded = fp;
                    }
                }
                catch { }
            }
        }
        
        [Browsable(false)]
        public string Hash { get; set; }
        
        [AnnotationIgnore]
        public string Path => Filepath.Expand();
        
        bool isExpandingPlanDir = false;
        [MetaData(macroName: "TestPlanDir")]
        [AnnotationIgnore]
        public string PlanDir
        {
            get
            {
                if (isExpandingPlanDir) return null;
                isExpandingPlanDir = true;
                try
                {
                    var exp = new MacroString(this) { Text = Filepath.Text }.Expand();
                    if (string.IsNullOrWhiteSpace(exp))
                        return "";
                    var path = System.IO.Path.GetFullPath(exp);
                    return string.IsNullOrWhiteSpace(path) ? "" : System.IO.Path.GetDirectoryName(path);
                }
                catch
                {        
                    return "";
                }
                finally
                {
                    isExpandingPlanDir = false;
                }
            }
        }

        [XmlIgnore]
        [Browsable(false)]
        [AnnotationIgnore]
        public new TestStepList ChildTestSteps
        {
            get { return base.ChildTestSteps; }
            set { base.ChildTestSteps = value; }
        }

        public TestPlanReference()
        {
            ChildTestSteps.IsReadOnly = true;
            Filepath = new MacroString(this);
            Rules.Add(() => (string.IsNullOrWhiteSpace(Filepath) || File.Exists(Filepath)), "File does not exist.", nameof(Filepath));
            StepMapping = new List<GuidMapping>();
        }

        public override void PrePlanRun()
        {
            base.PrePlanRun();

            if (string.IsNullOrWhiteSpace(Filepath))
                throw new OperationCanceledException(string.Format("Execution aborted by {0}. No test plan configured.", Name));
            
            // Detect if the plan was not loaded or if the path has been changed since loading it.
            // Note, there is some funky things related to TestPlanDir that are not checked but 99% of use-cases are.
            var expandedPath = filepath.Text;
            if (loadedPlanPath != expandedPath && File.Exists(expandedPath) && HideSteps)
            {
                LoadTestPlan();
            }
            if (loadedPlanPath != expandedPath)
                throw new OperationCanceledException(string.Format("Execution aborted by {0}. Test plan not loaded.", Name));
        }

        class SubPlanResultListener : ResultListener
        {
            readonly ResultSource proxy;
            public SubPlanResultListener(ResultSource proxy) => this.proxy = proxy;

            public override void OnResultPublished(Guid stepRunId, ResultTable result)
            {
                base.OnResultPublished(stepRunId, result);
                proxy.PublishTable(result);
            }
        }

        class LogForwardingTraceListener : ILogListener
        {
            readonly ILogContext2 forwardTo;
            public LogForwardingTraceListener(ILogContext2 forwardTo) => this.forwardTo = forwardTo;
            public void EventsLogged(IEnumerable<Event> Events)
            {
                foreach (var evt in Events)
                {
                    if (evt.Source == "TestPlan" || evt.Source == "N/A")
                        if(evt.EventType != (int)LogEventType.Error)
                            continue;
                    forwardTo.AddEvent(evt);
                }
            }

            public void Flush() { }
        }
        public override void Run()
        {
            if (HideSteps)
            {
                LogForwardingTraceListener forwarder = null;
                var xml = plan.SerializeToString();
                if(OpenTap.Log.Context is ILogContext2 ctx2)
                    forwarder = new LogForwardingTraceListener(ctx2);
                using (Session.Create())
                {   
                    var plan2 = Utils.DeserializeFromString<TestPlan>(xml);
                    plan2.PrintTestPlanRunSummary = false;
                    if(forwarder != null)
                        OpenTap.Log.AddListener(forwarder);
                    var subRun = plan2.Execute(new IResultListener[] {new SubPlanResultListener(Results)});
                    UpgradeVerdict(subRun.Verdict);
                }
            }
            else
            {
                foreach (var run in RunChildSteps())
                    UpgradeVerdict(run.Verdict);
            }
        }

        [ThreadStatic] static List<GuidMapping> CurrentMappings;

        static readonly Memorizer<string, XDocument> dict = new Memorizer<string, XDocument>(p =>
        {
            return XDocument.Load(p, LoadOptions.SetLineInfo);
            }) 
            {
                // Validator is to reload the file if it has been changed.
                // Assuming it is much faster to check file write time than to read and parse it. Testing has verified this.
                Validator = str =>
                {
                    var file = new FileInfo(str);
                    return $"{file.LastWriteTime} {file.Length}";
                },
                MaxNumberOfElements = 100
            };

        
        
        static XDocument ReadCachedXmlFile(string path)
        {
            var cached = dict.Invoke(path);
            // The deserializer may modify the XDocument class so it must be cloned by constructing a new XDocument (this causes a deep clone to be made).
            return new XDocument(cached);
        }

        internal TestPlan plan;
        string loadedPlanPath;
        
        void UpdateStep()
        {
            if (CurrentMappings == null)
                CurrentMappings = new List<GuidMapping>();
            // Load GUID mappings which is every two GUIDS between <Guids/> and <Guids/>
            var mapping = new Dictionary<Guid, Guid>();
            var allMapping = this.mapping.Concat(CurrentMappings).ToList();
            foreach (var mapItem in allMapping)
            {
                mapping[mapItem.Guid1] = mapItem.Guid2;
            }
            ITestStep parent = this;
            while(parent != null)
            {
                if(parent is TestPlanReference tpr)
                {
                    foreach(var mp in tpr.mapping)
                    {
                        mapping[mp.Guid1] = mp.Guid2;
                    }
                }
                parent = parent.Parent as ITestStep;
            }

            object testplandir = null;
            var currentSerializer = TapSerializer.GetObjectDeserializer(this);
            if (currentSerializer != null && currentSerializer.ReadPath != null)
                testplandir = System.IO.Path.GetDirectoryName(currentSerializer.ReadPath);
            
            var refPlanPath = Filepath.Expand(testPlanDir: testplandir as string);
            refPlanPath = refPlanPath.Replace('\\', '/');
            if (!File.Exists(refPlanPath))
            {
                Log.Warning("File does not exist: \"{0}\"", refPlanPath);
                return;
            }
            ChildTestSteps.Clear();
            var prevc = CurrentMappings;
            try
            {
                try
                {
                    if (referencedPlanPaths == null)
                        referencedPlanPaths = new HashSet<string>();
                    if (currentSerializer?.ReadPath == refPlanPath || referencedPlanPaths.Add(refPlanPath) == false)
                        throw new Exception("Test plan reference is trying to load itself leading to recursive loop.");

                    var newSerializer = new TapSerializer();
                    if (currentSerializer != null)
                        newSerializer.GetSerializer<ExternalParameterSerializer>().PreloadedValues.MergeInto(currentSerializer.GetSerializer<ExternalParameterSerializer>().PreloadedValues);
                    var ext = newSerializer.GetSerializer<ExternalParameterSerializer>();
                    foreach (var e in ExternalParameters)
                    {
                        /* If the value can be converted to/from a string, do so */
                        if (StringConvertProvider.TryGetString(e.GetValue(plan), out var str))
                        {
                            ext.PreloadedValues[e.Name] = str;
                        }
                        /* otherwise, write a null value to ensure the current value is not overwritten in the serializer. We can write it back later. */
                        else
                        {
                            ext.PreloadedValues[e.Name] = null;
                        }
                    }

                    CurrentMappings = allMapping;

                    loadedPlanPath = filepath.Text;

                    var doc = ReadCachedXmlFile(refPlanPath);
                    TestPlan tp = (TestPlan)newSerializer.Deserialize(doc, TypeData.FromType(typeof(TestPlan)), true, refPlanPath) ;
                    plan = tp;

                    using (var algo = System.Security.Cryptography.SHA1.Create())
                    {
                        using (var ms = new MemoryStream())
                        {
                            doc.Save(ms, SaveOptions.DisableFormatting);
                            Hash = BitConverter.ToString(algo.ComputeHash(ms.ToArray()), 0, 8)
                                .Replace("-", string.Empty);
                        }
                    }

                    { /* write back any parameters that could not be converted to a string */
                        var newParameters = TypeData.GetTypeData(tp).GetMembers().OfType<ParameterMemberData>()
                            .ToArray();
                        ILookup<string, ParameterMemberData> lookup = null;
                        foreach (var par in newParameters)
                        {
                            if (par.GetValue(plan) == null)
                            {
                                lookup ??= ExternalParameters.ToLookup(m => m.Name);
                                var prevParameter = lookup[par.Name].FirstOrDefault();
                                if (prevParameter != null)
                                    par.SetValue(plan, prevParameter.GetValue(plan));
                            }
                        }
                        ExternalParameters = newParameters;
                    }


                    var flatSteps = Utils.FlattenHeirarchy(tp.ChildTestSteps, x => x.ChildTestSteps);

                    StepIdMapping = flatSteps.ToDictionary(x => x, x => x.Id);

                    foreach (var step in flatSteps)
                    {
                        Guid id;
                        if (mapping.TryGetValue(step.Id, out id))
                            step.Id = id;
                    }

                    if (HideSteps == false)
                    {
                        foreach (var item in tp.ChildTestSteps)
                            ChildTestSteps.Add(item);

                        foreach (var step in RecursivelyGetChildSteps(TestStepSearch.All))
                        {
                            step.IsReadOnly = true;
                            step.ChildTestSteps.IsReadOnly = true;
                            step.OnPropertyChanged("");
                        }
                    }

                    if (currentSerializer == null)
                    {
                        // if currentSerializer is set, it means that we are loading a previously saved test plan reference.
                        // Hence these things will be automatically set up.
                        // otherwise we need to trasfer mixins and dynamic member values.
                        
                        // transfer mixins
                        var thisType = TypeData.GetTypeData(this);
                        var s = TypeData.GetTypeData(tp).GetMembers();

                        foreach (var member in TypeData.GetTypeData(tp).GetMembers())
                        {
                            if (member is MixinMemberData mixinMember)
                            {
                                if (thisType.GetMember(member.Name) != null) continue;
                                var mixin = mixinMember.Source;
                                var mem = mixin.ToDynamicMember(thisType);
                                if (mem == null)
                                {
                                    if (mixin is IValidatingObject validating && validating.Error is string err && string.IsNullOrEmpty(err) == false)
                                    {
                                        Log.Error($"Unable to load mixin: {err}");
                                    }
                                    else
                                    {
                                        Log.Error($"Unable to load mixin: {TypeData.GetTypeData(mixin)?.GetDisplayAttribute()?.Name ?? mixin.ToString()}");
                                    }
                                    continue;
                                }
                                // transfer  the value from the test plan instance to this instance.
                                var value = member.GetValue(tp);
                                DynamicMember.AddDynamicMember(this, mem);
                                mem.SetValue(this, value);
                            }
                        }

                        // transfer dynamic member values.
                        foreach (var member in TypeData.GetTypeData(tp).GetMembers().Where(mem => mem is DynamicMember))
                        {
                            if (member.HasAttribute<XmlIgnoreAttribute>())
                                continue;
                            member.SetValue(this, member.GetValue(tp));
                        }
                    }


                }
                finally
                {
                    if (referencedPlanPaths != null)
                    {
                        referencedPlanPaths.Remove(refPlanPath);
                        if (referencedPlanPaths.Count == 0) referencedPlanPaths = null;
                    }
                    CurrentMappings = prevc;
                }
            }
            catch (Exception ex)
            {
                Log.Error("Unable to read '{0}'.", Filepath.Text);
                Log.Error(ex);
            }
        }
        
        /// <summary> Used to determine if a step ID has changed from the time it was loaded to the time it is saved. </summary>
        Dictionary<ITestStep, Guid> StepIdMapping { get; set; }
        public List<GuidMapping> mapping;

        [Browsable(false)]
        [AnnotationIgnore]
        public List<GuidMapping> StepMapping
        {
            get {
                if (StepIdMapping == null)
                    return new List<GuidMapping>();
                var subMappings = Utils.FlattenHeirarchy(ChildTestSteps, x => x.ChildTestSteps).OfType<TestPlanReference>().SelectMany(x => (IEnumerable< KeyValuePair < ITestStep, Guid > >)x.StepIdMapping ?? Array.Empty<KeyValuePair<ITestStep, Guid>>()).ToArray();
                return StepIdMapping.Concat(subMappings).Select(x => new GuidMapping { Guid2 = x.Key.Id, Guid1 = x.Value }).Where(x => x.Guid1 != x.Guid2).ToList(); }
            set { mapping = value; }
        }

        [Browsable(true)]
        [Display("Load Test Plan", Order: 1, Description: "Load the selected test plan.")]
        [EnabledIf(nameof(CanOpenFile))]
        public void LoadTestPlan() => loadTestPlan();
        
        public void loadTestPlan()
        {
            ChildTestSteps.Clear();
            
            if (string.IsNullOrWhiteSpace(Filepath))
            {
                ExternalParameters = Array.Empty<ParameterMemberData>();
                return;
            }
            
            UpdateStep();
        }

        string GetPath()
        {
            object testplandir = null;
            var currentSerializer = TapSerializer.GetObjectDeserializer(this);
            if (currentSerializer != null && currentSerializer.ReadPath != null)
                testplandir = System.IO.Path.GetDirectoryName(currentSerializer.ReadPath);
            
            var refPlanPath = Filepath.Expand(testPlanDir: testplandir as string);
            refPlanPath = refPlanPath.Replace('\\', '/');
            
            return refPlanPath;
        }

        public bool anyStepsLoaded => ChildTestSteps.Any() && GetPath() is string path && File.Exists(path);

        
        
        [Display("Are you sure?")]
        class ConvertWarning
        {
            public enum ConvertOrCancel
            {
                Convert,
                Cancel
            }
            [Browsable(true)]
            [Layout(LayoutMode.FullRow | LayoutMode.WrapText)]
            public string Message { get; }

            [Layout(LayoutMode.FloatBottom | LayoutMode.FullRow)]
            [Submit]
            public ConvertOrCancel Response { set; get; } = ConvertOrCancel.Cancel;

            public ConvertWarning(bool multiSelect)
            {
                Message = "Are you sure you want to convert the Test Plan Reference to a Sequence?\n\nAny future changes to the referenced test plan will not be reflected.";
                if(multiSelect)
                    Message += "\n\nThis will affect all selected test steps.";
            }
        }
            

        /// <summary> Convert the test plan reference to a sequence step. This will pop up a dialog. </summary>
        [Browsable(true)]
        [Display("Convert to Sequence", "Convert the test plan reference to a sequence step.", Order: 1.1)]
        [EnabledIf(nameof(anyStepsLoaded), HideIfDisabled = true)]
        public void ConvertToSequence()
        {
            // only show the dialog if the user input interface has been set.
            // otherwise treat this as a normal method.
            bool showDialog = UserInput.Interface != null;

            ConvertToSequence(showDialog, false);
        }

        internal bool ConvertToSequence(bool userShouldConfirm, bool multiSelect)
        {
            if (userShouldConfirm)
            {
                var warn = new ConvertWarning(multiSelect);
                UserInput.Request(warn, true);
                if (warn.Response == ConvertWarning.ConvertOrCancel.Cancel)
                    return false;
            }

            // This test plan contains a clone of all the test steps in 'this'.
            var subPlan = TestPlan.Load(GetPath());
            
            // the new sequence step.
            var seq = new SequenceStep
            {
                // Replace Test Plan Reference if the name starts with that.
                Name = Name.StartsWith("Test Plan Reference") ? ("Sequence" + Name.Substring("Test Plan Reference".Length)) : Name,
                Parent = Parent,
                Id = this.Id
            };
            
            ChildItemVisibility.SetVisibility(seq, ChildItemVisibility.GetVisibility(this));
            
            // first figure out which steps are parameterized to this in the list of child steps.
            var parameters = TypeData.GetTypeData(subPlan).GetMembers().OfType<ParameterMemberData>()
                .Select(e => new {Name = e.Name , Members = e.ParameterizedMembers.ToArray()}).ToArray();
            foreach (var param in TypeData.GetTypeData(subPlan).GetMembers().OfType<ParameterMemberData>().ToArray())
            {
                // unparameterize those.
                param.Remove();
            }
            
            // now copy the steps over to the new step. 
            var steps = subPlan.ChildTestSteps.ToArray();
            subPlan.ChildTestSteps.Clear();
            foreach (var step in steps)
            {
                seq.ChildTestSteps.Add(step);
            }
            ChildTestSteps.IsReadOnly = false;
            var parent = this.Parent;
            var idx = parent.ChildTestSteps.IndexOf(this);
            parent.ChildTestSteps[idx] = seq;
            
            // This section copies parameters over from the test plan reference to the sequence
            foreach (var parameter in parameters)
            {
                var name = parameter.Name;
                ParameterMemberData parameterMember = null;
                foreach (var member in parameter.Members)
                {
                    parameterMember = member.Member.Parameterize(seq, member.Source, name);
                }
                parameterMember.SetValue(seq, ExternalParameters.First(x => x.Name == name).GetValue(this));
            }
            
            // This section copies mixins over from the test plan reference to the sequence           
            var seqType = TypeData.GetTypeData(seq);

            // Some MixinMemberData members may be seen multiple times
            // e.g. multiple EmbeddedMemberData can have the same OwnerMember
            // Store the seen members so that we can skip it
            HashSet<MixinMemberData> seen = new HashSet<MixinMemberData>();

            foreach (var member in TypeData.GetTypeData(this).GetMembers())
            {
                MixinMemberData mixinMember = member switch
                {
                    MixinMemberData mixin => mixin,
                    IEmbeddedMemberData emb => emb.OwnerMember as MixinMemberData,
                    var _ => null
                };


                if (mixinMember != null && !seen.Contains(mixinMember))
                {
                    seen.Add(mixinMember);
                    var mixin = mixinMember.Source;
                    var mem = mixin.ToDynamicMember(seqType);
                    if (mem == null)
                    {
                        if (mixin is IValidatingObject validating && validating.Error is string err && string.IsNullOrEmpty(err) == false)
                        {
                            Log.Error($"Unable to load mixin: {err}");
                        }
                        else
                        {
                            Log.Error($"Unable to load mixin: {TypeData.GetTypeData(mixin)?.GetDisplayAttribute()?.Name ?? mixin.ToString()}");
                        }
                        continue;
                    }
                    DynamicMember.AddDynamicMember(seq, mem);
                    mem.SetValue(seq, mixinMember.GetValue(this));
                }
            }

            
            // This section migrates parameters to the new step.
            
            ParameterMemberData GetParameter(object target, object source, IMemberData parameterizedMember)
            {
                var parameterMembers = TypeData.GetTypeData(target).GetMembers().OfType<ParameterMemberData>();
                foreach (var fwd in parameterMembers)
                {
                    if (fwd.ContainsMember((source, parameterizedMember)))
                        return fwd;
                }
                return null;
            }
            foreach (var member in TypeData.GetTypeData(this).GetMembers())
            {
                if (member.IsParameterized(this))
                {
                    
                    var parent2 = Parent;
                    while (parent2 != null)
                    {
                        var p = GetParameter(parent2, this, member);
                        if (p != null)
                        {
                            TypeData.GetTypeData(seq).GetMember(member.Name).Parameterize(parent2, seq, p.Name);
                            member.Unparameterize(p, this);
                            
                            break;
                        }
                        parent2 = parent2.Parent;
                    }
                }
            }


            // This section copies dynamic member values.

            foreach (var member in TypeData.GetTypeData(this).GetMembers().Where(mem => mem is DynamicMember))
            {
                if (member.HasAttribute<XmlIgnoreAttribute>())
                    continue;
                var val = member.GetValue(this);
                val = new ObjectCloner(val).Clone(false, this, member.TypeDescriptor);
                member.SetValue(seq, val);
            }
            // .. and done.
            return true;
        }
        
        internal ParameterMemberData[] ExternalParameters { get; private set; } = Array.Empty<ParameterMemberData>();
    }
}