//            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 OpenTap.Addin;
using OpenTap.Addin.Annotation;
using OpenTap.Addin.Listener;
using OpenTap.Addin.Reader;
using OpenTap.Addin.Util;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Xml.Linq;
using System.Xml.Serialization;

namespace OpenTap.Plugins.BasicSteps
{
    [Display("Sequence Call", Description: "µ÷ÓÃ×ÓÐòÁÐ")]
    public class SequenceCallStep : TestStep
    {
        protected override void OnRootChanged(TestPlan old, TestPlan plan)
        {
            LoadPlan();
        }


        //public List<>

        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 { parent = value; } }

        string currentlyLoaded;

        public bool CanOpenFile => File.Exists(Filepath);


        private string filePath;
        [Display("Îļþ", 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 | *.TapPlan", 1)]
        [DeserializeOrder(1.0)]
        [Unsweepable]
        public string Filepath
        {
            get => filePath;
            set
            {
                filePath = value;
                OnPropertyChanged(nameof(Filepath));
                try
                {
                    LoadPlan();
                }
                catch
                {

                }
            }
        }

        [Obsolete]
        public bool ShareGlobals { get; set; }

        private string realPath;

        private bool currentFile;
        [Display("µ±Ç°Îļþ")]
        public bool CurrentFile
        {
            get => currentFile;
            set
            {
                currentFile = value;
                OnPropertyChanged(nameof(CurrentFile));
                try
                {
                    LoadPlan();
                }
                catch
                {

                }
            }
        }

        private string sequenceName;

        [Display("ÐòÁÐÃû")]
        [DynamicSelect("SequenceNames")]
        public string SequenceName
        {
            get => sequenceName;
            set
            {
                sequenceName = value;
                var seq = Sequences?.FirstOrDefault(e => e.SequenceName == value);
                if (seq != null)
                {
                    var list = new ObservableCollection<TestVariable>();
                    foreach (var tv in seq.Parameters)
                    {
                        var newone = new TestVariable
                        {
                            Name = tv.Name,
                            IsArray = tv.IsArray,
                            Type = tv.Type
                        };
                        var old = Parameters.FirstOrDefault(e => e.Name == tv.Name);
                        if (old != null)
                        {
                            newone.Value = old.Value;
                        }
                        list.Add(newone);
                    }
                    Parameters = list;// seq.Parameters;
                }
                OnPropertyChanged(nameof(SequenceName));
            }
        }

        [XmlIgnore]
        public List<string> SequenceNames
        {
            get => plan?.Sequences.Select(s => s.SequenceName).ToList();
        }


        [XmlIgnore]
        public ObservableCollection<TestStepList> Sequences
        {
            get => plan?.Sequences;
        }

        [Browsable(false)]
        public string Hash { get; set; }

        [AnnotationIgnore]
        public string Path => Filepath;

        private ObservableCollection<TestVariable> parameters = new ObservableCollection<TestVariable>();
        [Display("²ÎÊý")]
        [BindingList(nameof(Parameters), false)]
        //[TreeData]
        public ObservableCollection<TestVariable> Parameters
        {
            get => parameters;
            set
            {
                parameters = value;
                OnPropertyChanged(nameof(Parameters));
            }
        }

        public SequenceCallStep()
        {

        }

        private void RefreshPlan(string path)
        {
            if (CurrentFile)
            {
                plan = this.Root;
            }
            else
            {
                var newSerializer = new TapSerializer();
                var timer = Stopwatch.StartNew();
                var doc = ReadCachedXmlFile(path);
                Log.Debug(timer, $"Read Sequence Xml {path}");

                //plan = (TestPlan)newSerializer.Deserialize(doc, TypeData.FromType(typeof(TestPlan)), true, path);
                plan = TestPlanReader.ReadTestPlanFromDocument(doc, path);
                OnPropertyChanged(nameof(SequenceNames));

                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);
                    }
                }
            }
        }

        private string GetPlanPath()
        {
            if (CurrentFile)
            {
                return this.plan?.VisualPath;
            }
            if (PlanRun == null)
            {
                // ¼æÈÝδÔËÐеÄÇé¿ö£¬ÕâÀﻹҪÓÅ»¯
                realPath = VariableResolverFactory.DEFAULT.Resolve<string>(null, this, Filepath);
            }
            else
            {
                realPath = PlanRun.Resolve<string>(this, Filepath);
            }

            if (!string.IsNullOrEmpty(realPath))
            {
                var refPlanPath = realPath;
                return refPlanPath.Replace('\\', '/');
            }
            return realPath;
        }

        private void LoadPlan()
        {
            if (this.Root == null)
            {
                return;
            }
            if (CurrentFile)
            {
                plan = this.Root;
                OnPropertyChanged(nameof(SequenceNames));
            }
            else
            {
                string path = GetPlanPath();
                if (string.IsNullOrEmpty(path))
                {
                    return;
                }

                string p1 = System.IO.Path.GetFullPath(path);
                string p2 = System.IO.Path.GetFullPath(this.Root.VisualPath);
                if (string.Equals(p1, p2, StringComparison.OrdinalIgnoreCase))
                {
                    plan = this.Root;
                    OnPropertyChanged(nameof(SequenceNames));
                    return;
                }

                if (!File.Exists(path))
                {
                    Log.Warning("File does not exist: \"{0}\"", path);
                    return;
                }

                try
                {
                    RefreshPlan(path);
                }
                catch (Exception ex)
                {
                    Log.Error("Unable to read '{0}'.", realPath);
                    Log.Error(ex);
                }
            }
        }

        public override void PrePlanRun()
        {
            string path = GetPlanPath();

            if (string.IsNullOrEmpty(path))
            {
                throw new ArgumentException("Path Can't be empty!");
            }

            if (!File.Exists(path))
            {
                throw new ArgumentException($"File does not exist: \"{path}\"");
            }
            RefreshPlan(path);


            var xml = plan.SerializeToString();
            using (var reader = new MemoryStream(Encoding.UTF8.GetBytes(xml)))
            {
                runningPlan = TestPlanReader.ReadTestPlanFromStream(reader, plan.Path);
            }
            //runningPlan = Utils.DeserializeFromString<TestPlan>(xml);
            runningPlan.PrintTestPlanRunSummary = false;
            runningPlan.VisualPath = plan.VisualPath;
        }

        private RuntimeVariable Convert(TestVariable tv)
        {
            if (tv.Type == TestVariableType.String)
            {
                return new RuntimeVariable(PlanRun, tv.Name, PlanRun.Resolve<string>(this, tv.Value));
            }

            if (tv.Type == TestVariableType.Int)
            {
                return new RuntimeVariable(PlanRun, tv.Name, PlanRun.Resolve<int>(this, tv.Value));
            }

            if (tv.Type == TestVariableType.Double)
            {
                return new RuntimeVariable(PlanRun, tv.Name, PlanRun.Resolve<double>(this, tv.Value));
            }

            if (tv.Type == TestVariableType.Bool)
            {
                return new RuntimeVariable(PlanRun, tv.Name, PlanRun.Resolve<bool>(this, tv.Value));
            }
            return new RuntimeVariable(PlanRun, tv.Name, PlanRun.Resolve(this, tv.Value));
        }

        private RuntimeVariable GetMergeContainer()
        {
            ConcurrentDictionary<string, RuntimeVariable> pool = new ConcurrentDictionary<string, RuntimeVariable>();
            foreach (var tv in Parameters)
            {
                pool[tv.Name] = Convert(tv);
            }
            return new RuntimeVariable(PlanRun, ConstNames.ParametersName, pool);
        }

        protected override void RunDetail()
        {
            try
            {
                var loglisteners = OpenTap.Log.GetListeners();

                var resultSetting = ResultSettings.Current;
                var fileGlobalsContext = PlanRun.fileGlobalsContext;

                List<object> childrenListeners = new List<object>();
                using (Session.Create())
                {
                    var sb = ResultSettings.Current;
                    foreach (var listener in loglisteners)
                    {
                        OpenTap.Log.AddListener(listener);
                    }

                    // Ìí¼Ó×Ó±¨¸æ
                    foreach (var listener in resultSetting)
                    {
                        if (listener is RootListener rl)
                        {
                            var child = rl.CreateChild();
                            childrenListeners.Add(child);
                            ResultSettings.Current.Add(child);
                        }
                    }
                    TestPlanRun subRun;
                    subRun = runningPlan.Execute(SequenceName, sb, null, null,
                           new VariableContainer(GetMergeContainer(), fileGlobalsContext, this.PlanRun.StationGlobalsRuntime));

                    UpgradeVerdict(subRun.Verdict);

                    foreach (var listener in loglisteners)
                    {
                        OpenTap.Log.RemoveListener(listener);
                    }

                    foreach (var listener in childrenListeners)
                    {
                        ResultSettings.Current.Remove(listener);
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Error("Sequence Call Error. {0}", ex);
                this.Verdict = Verdict.Error;
            }
        }

        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);
        }

        [XmlIgnore]
        internal TestPlan plan;

        [XmlIgnore]
        public TestPlan runningPlan { get; private set; }
        string loadedPlanPath;

        void UpdateStep()
        {
            if (CurrentFile)
            {
                plan = this.Root;
                OnPropertyChanged(nameof(SequenceNames));
                // Sequences = plan?.Sequences;
            }
            else
            {
                object testplandir = null;
                var currentSerializer = TapSerializer.GetObjectDeserializer(this);
                if (currentSerializer != null && currentSerializer.ReadPath != null)
                    testplandir = System.IO.Path.GetDirectoryName(currentSerializer.ReadPath);

                var refPlanPath = realPath;
                refPlanPath = refPlanPath.Replace('\\', '/');
                if (!File.Exists(refPlanPath))
                {
                    Log.Warning("File does not exist: \"{0}\"", refPlanPath);
                    return;
                }
                try
                {
                    try
                    {
                        var newSerializer = new TapSerializer();
                        if (currentSerializer != null)
                            newSerializer.GetSerializer<ExternalParameterSerializer>().PreloadedValues.MergeInto(currentSerializer.GetSerializer<ExternalParameterSerializer>().PreloadedValues);
                        var ext = newSerializer.GetSerializer<ExternalParameterSerializer>();

                        loadedPlanPath = realPath;

                        var doc = ReadCachedXmlFile(refPlanPath);
                        TestPlan tp = (TestPlan)newSerializer.Deserialize(doc, TypeData.FromType(typeof(TestPlan)), true, refPlanPath);
                        plan = tp;
                        OnPropertyChanged(nameof(SequenceNames));
                        //Sequences = tp.Sequences;

                        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);
                            }
                        }

                        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
                    {

                    }
                }
                catch (Exception ex)
                {
                    Log.Error("Unable to read '{0}'.", realPath);
                    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; }

        [Browsable(true)]
        //[Display("Load Test Plan", Order: 1, Description: "Load the selected test plan.")]
        [EnabledIf(nameof(CanOpenFile))]
        public void LoadTestPlan() => loadTestPlan();

        public void loadTestPlan()
        {
            if (!CurrentFile && string.IsNullOrWhiteSpace(realPath))
            {
                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 = realPath;
            refPlanPath = refPlanPath.Replace('\\', '/');

            return refPlanPath;
        }

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



        
    }
}