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

namespace OpenTap
{
    /// <summary>   Interface for TestStep input properties. </summary>
    public interface IInput
    {
        /// <summary>   Gets or sets the TestStep that has the output property to which this Input is connected. </summary>
        ITestStep Step { get; set; }

        /// <summary>   Describes the <see cref="OutputAttribute"/> property on the <see cref="Step"/> to which this Input is connected.   </summary>
        IMemberData Property { get; set; }
    }

    /// <summary>
    /// Input type restriction for IInput.
    /// </summary>
    public interface IInputTypeRestriction : IInput
    {
        /// <summary> returns true if the concrete type is supported. </summary>
        /// <param name="concreteType"></param>
        /// <returns></returns>
        bool SupportsType(ITypeData concreteType);
    }

    interface IOwnedInput
    {
        object Owner { get; set; }
    }

    /// <summary>   
    /// A generic type that specifies input properties for a TestStep. The user can link this property to properties on other TestSteps that are marked with the <see cref="OutputAttribute"/>
    /// When used in a TestStep, Input value should always be set in the constructor.
    /// </summary>
    /// <typeparam name="T"> Generic type parameter. </typeparam>
    public class Input<T> : IInput, IInputTypeRestriction, ICloneable, IOwnedInput
    {
        /// <summary> 
        /// Describes the output property on the <see cref="Step"/> to which this Input is connected.  
        /// </summary>
        [XmlIgnore]
        public IMemberData Property { get; set; }

        void updatePropertyFromName()
        {
            if (string.IsNullOrEmpty(propertyName))
                return;
            else
            {
                string[] parts = propertyName.Split('|');
                if (parts.Length == 1)
                {
                    if (step != null)
                    {
                        ITypeData stepType = TypeData.GetTypeData(step);
                        Property = stepType.GetMember(parts[0]);    
                    }
                    else
                    {
                        Property = null;
                    }
                }
                else
                {
                    var typename = parts[0];
                    ITypeData stepType = TypeData.GetTypeData(typename);
                    Property = stepType.GetMember(parts[1]);
                }
            }

            if (Property != null)
                propertyName = null;
        }
        
        string propertyName;
        /// <summary> Gets or sets the name of the property to which this Input is connected. Used for serialization. </summary>
        public string PropertyName
        {
            get => Property != null ? Property.DeclaringType.Name + "|" + Property.Name : propertyName;
            set
            {
                propertyName = value;
                updatePropertyFromName();
                
            }
        }

        private ITestStepParent getTopmostParent(ITestStepParent step)
        {
            if (step == null) return null;
            ITestStepParent parent = step;
            while (parent.Parent != null)
                parent = parent.Parent;
            return parent;
        }

        object testStepOwner = null;
        const string OwnerNotFound = nameof(OwnerNotFound);
        ITestStep step;

        /// <summary>
        /// Sometimes we need to know the owner object.
        /// Since we cannot automatically get it from the owning object, we can iterate the entire test plan to find it.
        /// It's a bit of a hack, but works well.
        /// For better performance we set the owner object for all Inputs in the test plan by using the IOwnedInput (internal) interface.
        /// </summary>
        void UpdateAllOwnedInputsInPlan()
        {
            if (step == null) return;
            var topmost = getTopmostParent(step);
            foreach (var step in topmost.ChildTestSteps.RecursivelyGetAllTestSteps(TestStepSearch.All))
            {
                foreach (var inputMember in TypeData.GetTypeData(step).GetMembers().Where(member => member.TypeDescriptor.DescendsTo(typeof(IOwnedInput)) && member.Readable))
                {
                    try
                    {
                        if (inputMember.GetValue(step) is IOwnedInput owned)
                        {
                            owned.Owner = step;
                        }
                    }
                    catch
                    {
                        // Ignore errors in user code.
                    }
                }
            }
        }

        /// <summary>   Gets or sets the TestStep that has the output property to which this Input is connected. </summary>
        public ITestStep Step
        {
            get
            {
                // If the step is part of the test plan heirarchy, return the step.
                // Otherwise, return null.
                if (step == null) return null;

                if (testStepOwner == null)
                {
                    UpdateAllOwnedInputsInPlan();
                    if(testStepOwner == null)
                        testStepOwner = OwnerNotFound;
                }

                if (testStepOwner is ITestStep ownerStep)
                {

                    if (getTopmostParent(ownerStep).ChildTestSteps.GetStep(step.Id) != null)
                        return step;

                    // the step is not in the same plan as the owner step.
                    return null;
                }

                // if we could not find the owner step, then its better to assume that the value of step is ok.
                return step;
            }
            set
            {
                if(step != value)
                {
                    step = value;
                    
                    if (step == null)
                    {   
                        return;
                    }
                    stepId = step.Id; 
                    updatePropertyFromName();
                }
            }
        }

        // the step ID is used for storing the step ID when moving the Step owning the Input.
        // otherwise, after moving the step (taking it out of the test plan and moving it back in) the Step might be null.
        Guid stepId;

        /// <summary>   Gets the value of the connected output property. </summary>
        /// <exception cref="Exception">    Thrown when this Input does not contain a reference to a TestStep output. </exception>
        [XmlIgnore]
        public T Value
        {
            get
            {
                if (step == null || Property == null)
                    throw new Exception("Step input requires reference to a TestStep output.");
                
                // Wait for the step to complete
                return (T)InputOutputRelation.GetOutput(Property, step, Guid.NewGuid()); 
            }
        }

        T GetValueNonBlocking()
        {
            if (Step is ITestStep step && Property?.GetValue(step) is T v)
                return v;
            return default;
        }
        
        /// <summary> Converts the value of this instance to its equivalent string representation. </summary>
        /// <returns> The string representation of the value of this instance. </returns>
        public override string ToString() =>  StringConvertProvider.GetString(GetValueNonBlocking()) ?? "";

        /// <summary> Compares one Input to another. </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public override bool Equals(object obj)
        {
            if(obj is Input<T> other)
                return other.step == step && other.Property == Property;
            return false;
        }

        /// <summary> Gets the hash code.</summary>
        /// <returns></returns>
        public override int GetHashCode()
        {
            return (step?.GetHashCode() ?? 0) ^ (Property?.GetHashCode() ?? 0);
        }

        object ICloneable.Clone() => new Input<T>
        {
            step = step,
            Property = Property
        };

        /// <summary> Returns true if this input supports the concrete type. </summary>
        /// <param name="concreteType"></param>
        /// <returns></returns>
        public virtual bool SupportsType(ITypeData concreteType)
        {
            return concreteType.DescendsTo(typeof(T));
        }

        /// <summary> Compares two Input for equality.</summary>
        /// <returns></returns>
        public static bool operator==(Input<T> a, Input<T> b) => object.Equals(a, b);

        /// <summary> Compares two Input for inequality.</summary>
        /// <returns></returns>
        public static bool operator !=(Input<T> a, Input<T> b) => !(a == b);
        object IOwnedInput.Owner
        {
            get => testStepOwner as ITestStepParent;
            set => testStepOwner = value;
        }
    }
}