using System;
using System.Collections.Generic;
using System.Linq;
using System.Xml.Linq;
using System.Xml.Serialization;

namespace OpenTap.Plugins
{
    /// <summary>
    /// Serializes input/output relations. It does so by adding a collection of inputs to the step XML while serializing.
    /// This is done because some of the properties might be read-only or XML ignore and in these cases we might still want
    /// to serialize the relation ship between them, even though the values are not themselves serialized.
    /// </summary>
    class InputOutputRelationSerializer : TapSerializerPlugin
    {
        class InputOutputMember
        {
            [XmlAttribute("id")]
            public Guid Id { get; set; }
            [XmlAttribute("member")]
            public string Member { get; set; }       
            [XmlAttribute("target-member")]
            public string TargetMember { get; set; }

            public void Bind(ITestStepParent step, Func<Guid,ITestStepParent> getStep)
            {
                ITestStepParent source;
                if (Id == Guid.Empty)
                {
                    source =  step.GetParent<TestPlan>();
                }
                else
                {
                    source = getStep(Id);
                }

                if (source == null) return;
                var sourceType = TypeData.GetTypeData(source);
                var targetType = TypeData.GetTypeData(step);
                var sourceMember = sourceType.GetMember(Member);
                var targetMember = targetType.GetMember(TargetMember);
                if(sourceMember != null && targetMember != null)
                    InputOutputRelation.Assign(step, targetMember, source, sourceMember);
            } 
        }

        static readonly XName stepInputsName = "TestStep.Inputs";
        readonly HashSet<XElement> activeElements = new HashSet<XElement>();

        readonly Dictionary<ITestStepParent, IEnumerable<InputOutputMember>> unusedInputs = new Dictionary<ITestStepParent, IEnumerable<InputOutputMember>>();
        
        /// <summary> Deserialize input/output relations </summary>
        public override bool Deserialize(XElement node, ITypeData t, Action<object> setter)
        {
            if (t.DescendsTo(typeof(ITestStepParent)) == false)
                return false;
            if (node.Element(stepInputsName) is XElement subelems && activeElements.Contains(node) == false)
            {
                var tps = Serializer.GetSerializer<TestPlanSerializer>();
                ITestStepParent step = null;
                var prevsetter = setter;
                setter = x => prevsetter(step = x as ITestStepParent);
                var plan = tps?.Plan;
                InputOutputMember[] items = null;
                if (Serializer.Deserialize(subelems, x => items = (InputOutputMember[]) x, TypeData.FromType(typeof(InputOutputMember[]))))
                {
                    
                    bool ok = false;
                    activeElements.Add(node);
                    try
                    {
                        ok = Serializer.Deserialize(node, setter, t);
                    }
                    catch
                    {
                        activeElements.Remove(node);
                    }


                    void connectInputs()
                    {
                        if (step == null) return;
                        Func<Guid, ITestStepParent> lookup;
                        if (plan == null)
                            lookup = Serializer.GetSerializer<TestStepSerializer>().FindStep;
                        else
                            lookup = plan.ChildTestSteps.GetStep;
                        if (lookup == null) return;
                        foreach (var elem in items)
                        {
                            elem.Bind(step, lookup);
                        }
                    }
                    if(ok)
                        Serializer.DeferLoad(connectInputs);
                    return ok;
                }
            }

            return false;
        }

        /// <summary> Serialize input/output relations </summary>
        public override bool Serialize(XElement node, object obj, ITypeData expectedType)
        {
            
            if (obj is ITestStepParent step && activeElements.Contains(node) == false)
            {
                activeElements.Add(node);
                try
                {
                    var inputs = InputOutputRelation.GetRelations(step).Where(x => x.InputObject == step).ToArray();
                    if (inputs.Length == 0) return false;
                    var items = inputs.Select(x => new InputOutputMember
                        {Id = (x.OutputObject as ITestStep)?.Id ?? Guid.Empty, Member = x.OutputMember.Name, TargetMember = x.InputMember.Name}).ToArray();
                    var subnode = new XElement(stepInputsName);
                    Serializer.Serialize(subnode, items, TypeData.GetTypeData(items));
                    var ok = Serializer.Serialize(node, obj, expectedType);
                    if (ok)
                        node.Add(subnode);
                    return ok;
                }
                finally
                {
                    activeElements.Remove(node);
                }
            }

            return false;
        }
    }
}