//            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.Xml.Linq;

namespace OpenTap.Plugins
{
    /// <summary> Serializer implementation for TestStep. </summary>
    public class TestStepSerializer : TapSerializerPlugin
    {
        /// <summary> The order of this serializer. </summary>
        public override double Order { get { return 1; } }

        readonly Dictionary<Guid, ITestStep> stepLookup = new Dictionary<Guid, ITestStep>();

        /// <summary> Tries to find a step based on ID. </summary>
        internal ITestStep FindStep(Guid id)
        {
            stepLookup.TryGetValue(id, out var step);
            return step;
        }
        
        /// <summary>
        /// Guids where duplicate guids should be ignored. Useful when pasting to test plan.
        /// </summary>
        readonly HashSet<Guid> ignoredGuids = new HashSet<Guid>();

        /// <summary>
        /// Adds known steps to the list of tests used for finding references in deserialization.
        /// </summary>
        /// <param name="stepParent"></param>
        public void AddKnownStepHeirarchy(ITestStepParent stepParent)
        {
            var step = stepParent as ITestStep; // could also be TestPlan.

            if (step != null)
            {
                stepLookup[step.Id] = step;
                ignoredGuids.Add(step.Id);
            }
            
            foreach (var step2 in stepParent.ChildTestSteps)
                AddKnownStepHeirarchy(step2);
        }

        /// <summary>
        /// Ensures that duplicate step IDs are not present in the test plan and updates an ID->step mapping.
        /// </summary>
        /// <param name="step">the step to fix.</param>
        /// <param name="recurse"> true if child steps should also be 'fixed'.</param>
        public void FixupStep(ITestStep step, bool recurse)
        {
            if (stepLookup.TryGetValue(step.Id, out ITestStep currentStep) && currentStep != step && !ignoredGuids.Contains(step.Id))
            {
                bool anyParentReadonly(ITestStep s) => s.GetParents().Any(p => p.ChildTestSteps.IsReadOnly);
                step.Id = Guid.NewGuid();
                // If any parent of the step's child steps are readonly, this step was likely generated from some other source.
                // This could happen e.g. when loading a TestPlanReference to the same test plan twice. In this case,
                // we don't want to emit any warnings about duplicate IDs. Just assign the step a new ID and continue.
                if (anyParentReadonly(step) == false)
                {
                    if (step is IDynamicStep)
                    {
                        // if newStep is an IDynamicStep, we just print in debug.
                        Log.Debug(
                            "Duplicate test step ID found in dynamic step. The duplicate ID has been changed for step '{0}'.",
                            step.Name);
                    }
                    else
                    {
                        Log.Warning("Duplicate test step ID found. The duplicate ID has been changed for step '{0}'.",
                            step.Name);
                    }
                }
            }
            stepLookup[step.Id] = step;

            if (recurse == false) return;
            foreach(var step2 in step.ChildTestSteps)
            {
                FixupStep(step2, true);
            }
        }

        /// <summary> Deserialization implementation. </summary>
        public override bool Deserialize( XElement elem, ITypeData t, Action<object> setResult)
        {
            if(t.DescendsTo(typeof(ITestStep)))
            {
                
                if (elem.HasElements == false)
                {
                    Guid stepGuid;
                    if (Guid.TryParse(elem.Value, out stepGuid))
                    {
                        Serializer.DeferLoad(() =>
                        {
                            if (stepLookup.ContainsKey(stepGuid))
                            {
                                setResult(stepLookup[stepGuid]);
                            }
                            else
                            {
                                if(Serializer.IgnoreErrors == false)
                                    Log.Warning("Unable to find referenced step {0}", stepGuid);
                            }
                                
                        });
                        return true;
                    }
                }
                else
                {
                    if (currentNode.Contains(elem)) return false;
                    ITestStep step = null;
                    currentNode.Add(elem);
                    try
                    {
                        if (Serializer.Deserialize(elem, x => step = (ITestStep)x, t))
                        {
                            setResult(step);
                            FixupStep(step, true);
                        }
                        // return true even tough the deserialization failed. 
                        // since this is a test step being deserialized
                        // it should always be handled here.
                        // otherwise the errors will show up twice.
                        return true;
                    }finally
                    {
                        currentNode.Remove(elem);
                    }
                }
            }
            return false;
        }
        HashSet<XElement> currentNode = new HashSet<XElement>();
        
        /// <summary> Serialization implementation. </summary>
        public override bool Serialize( XElement elem, object obj, ITypeData expectedType)
        {
            if (false == obj is ITestStep) return false;
            
            // if we are currently serializing a test step, then if that points to another test step,
            // that should be serialized as a reference.
            
            var currentlySerializing = Serializer.SerializerStack.OfType<ObjectSerializer>().FirstOrDefault();

            if(currentlySerializing?.Object != null)
            {
                if (currentlySerializing.CurrentMember.TypeDescriptor.DescendsTo(typeof(ITestStep)))
                {
                    elem.Attributes("type")?.Remove();
                    elem.Value = ((ITestStep)obj).Id.ToString();
                    return true;
                }
                if (currentlySerializing.CurrentMember.TypeDescriptor is TypeData tp)
                {
                    // serialize references in list<ITestStep>, only when they are declared by a test step and not a TestStepList.
                    if (tp.Type != typeof(TestStepList) && (tp.ElementType?.DescendsTo(typeof(ITestStep)) ?? false) && currentlySerializing.CurrentMember.DeclaringType.DescendsTo(typeof(ITestStep)))
                    {
                        elem.Attributes("type")?.Remove();
                        elem.Value = ((ITestStep)obj).Id.ToString();
                        return true;
                    }
                }
            }
            return false;
        }
    }

}