using System;
using System.Collections.Generic;
using System.Linq;

namespace OpenTap
{
    /// <summary> Accelerating structure for inputs / outputs owners. Note, it is recommended to implement this explicitly. </summary>
    interface IInputOutputRelations
    {
        /// <summary> Relations to the object ('this'). </summary>
        InputOutputRelation[] Inputs { get; set; }
        /// <summary>  Relations from the object('this'); </summary>
        InputOutputRelation[] Outputs { get; set; }
    }

    /// <summary> Relations between two object and a pair of their members. </summary>
    public sealed class InputOutputRelation
    {
        readonly ITestStepParent outputObject;
        readonly ITestStepParent inputObject;
        readonly IMemberData outputMember;
        readonly IMemberData inputMember;

        /// <summary> The object that owns the output member. </summary>
        public ITestStepParent OutputObject => outputObject;

        /// <summary> The object that owns the input member.</summary>
        public ITestStepParent InputObject => inputObject;

        /// <summary> The member which the output value is read from. </summary>
        public IMemberData OutputMember => outputMember;

        /// <summary> The Member which the input value is read from. </summary>
        public IMemberData InputMember => inputMember;

        InputOutputRelation(ITestStepParent inputObject, IMemberData inputMember, ITestStepParent outputObject,
            IMemberData outputMember)
        {
            this.outputObject = outputObject;
            this.inputObject = inputObject;
            this.outputMember = outputMember;
            this.inputMember = inputMember;
        }

        /// <summary> Returns true if member on object is assigned to an output / is an input. </summary>
        public static bool IsInput(ITestStepParent @object, IMemberData member)
            => GetOutputRelations(@object).Any(con => con.InputMember == member && con.InputObject == @object);

        /// <summary> Returns true if member on object is assigned to an input / is an output. </summary>
        public static bool IsOutput(ITestStepParent @object, IMemberData member)
            => GetInputRelations(@object).Any(con => con.OutputMember == member && con.OutputObject == @object);

        /// <summary> Create a relation between two members on two different objects. </summary>
        public static void Assign(ITestStepParent inputObject, IMemberData inputMember, ITestStepParent outputObject,
            IMemberData outputMember)
        {
            if (outputMember == null)
                throw new ArgumentNullException(nameof(outputMember));
            if (inputMember == null)
                throw new ArgumentNullException(nameof(inputMember));
            if (inputObject == null)
                throw new ArgumentNullException(nameof(inputObject));
            if (outputObject == null)
                throw new ArgumentNullException(nameof(outputObject));
            if (inputMember == outputMember && inputObject == outputObject)
                throw new ArgumentException("An input/output may not be assigned to itself.");
            if (outputMember.Readable == false)
                throw new ArgumentException(nameof(outputMember) + " is not readable!", nameof(outputMember));
            if (inputMember.Writable == false)
                throw new ArgumentException(nameof(inputMember) + " is not writeable!", nameof(inputMember));
            var connTo = getOutputRelations(inputObject).ToList();
            var connFrom = getInputRelations(outputObject).ToList();
            foreach (var connection in connTo)
                if (connection.OutputObject == outputObject && connection.OutputMember == outputMember &&
                    inputMember == connection.InputMember)
                    throw new ArgumentException("Input already assigned", nameof(inputMember));
            if (IsInput(inputObject, inputMember))
                throw new Exception("This input is already in use by another connection.");

            // these two restrictions might not be necessary, but it might be good to leave it 
            // in case we want to change the mechanism
            if (IsInput(outputObject, outputMember))
                throw new Exception("An output cannot also be an input");
            if (IsOutput(inputObject, inputMember))
                throw new Exception("An input cannot also be an output");

            var newSpec = new InputOutputRelation(inputObject, inputMember, outputObject, outputMember);
            connTo.Add(newSpec);
            connFrom.Add(newSpec);

            SetOutputRelations(inputObject, connTo.ToArray());
            SetInputRelations(outputObject, connFrom.ToArray());
        }

        /// <summary> Unassign an input/output relation. </summary>
        /// <param name="relation"></param>
        internal static void Unassign(InputOutputRelation relation)
        {
            SetOutputRelations(relation.InputObject,
                getOutputRelations(relation.InputObject).Where(x => x != relation).ToArray());
            SetInputRelations(relation.OutputObject,
                getInputRelations(relation.OutputObject).Where(x => x != relation).ToArray());
        }

        /// <summary> Unassign an input/output relation . </summary>
        public static void Unassign(ITestStepParent target, IMemberData targetMember, ITestStepParent source,
            IMemberData sourceMember)
        {
            var from = getInputRelations(source);
            var con = from.FirstOrDefault(i =>
                i.InputObject == target && i.InputMember == targetMember && i.OutputMember == sourceMember);
            if (con != null)
                Unassign(con);
        }

        static bool IsInScope(ITestStepParent target, ITestStep otherStep)
        {
            if (target.Parent == otherStep)
                return true;
            var parent = target;
            while (parent != null)
            {
                if (parent == otherStep.Parent)
                    return true;
                        
                parent = parent.Parent;
            }

            return false;
        }

        static void checkRelations(ITestStepParent target)
        {
            Action defer = null;

            foreach (var connection in getOutputRelations(target))
            {
                if (connection.OutputObject is ITestStep otherStep)
                {
                    // steps can only be connected to a step from the same test plan.
                    if (IsInScope(target, otherStep) == false)
                    {
                        defer = defer.Bind(Unassign, connection);
                    }
                }

                if (connection.OutputMember is IDynamicMemberData dyn && dyn.IsDisposed)
                {
                    defer = defer.Bind(Unassign, connection);
                }
                else if (connection.InputMember  is IDynamicMemberData dyn2 && dyn2.IsDisposed)
                {
                    defer = defer.Bind(Unassign, connection);
                }
            }

            foreach (var connection in getInputRelations(target))
            {
                if (connection.InputMember is IDynamicMemberData dyn && dyn.IsDisposed)
                {
                    defer = defer.Bind(Unassign, connection);
                }
                else if (connection.OutputMember  is IDynamicMemberData dyn2 && dyn2.IsDisposed)
                {
                    defer = defer.Bind(Unassign, connection);
                }
            }

            defer?.Invoke();
        }

        static TestStepRun ResolveStepRun(ITestStep step, Guid waiterStep)
        {
            TestStepRun run = step.StepRun;
            if (run != null) return run;
            if (step.Parent is ITestStep parent)
            {
                // recursively resolve the parent step's run.
                var parentRun = ResolveStepRun(parent, waiterStep);
                if (parentRun != null)
                {
                    // if parentRun.StepThread is the same as the current thread it does not make sense to wait.
                    return parentRun.WaitForChildStepStart(step.Id, parentRun.StepThread != TapThread.Current, waiterStep);
                }
            }

            return null;
        }
        
        internal static object GetOutput(IMemberData outputMember, object outputObject, Guid inputStepGuid)
        {
            var avail = outputMember.GetAttribute<OutputAttribute>()?.Availability ??
                        OutputAttribute.DefaultAvailability;
            if (avail != OutputAvailability.BeforeRun && outputObject is ITestStep step )
            {
                TestStepRun run = ResolveStepRun(step, inputStepGuid);  
                if (run != null)
                    run.WaitForOutput(avail, step);
            }

            return outputMember.GetValue(outputObject);
        }
    

    /// <summary> Updates the input of 'target' by reading the value of the source output.  </summary>
        public static void UpdateInputs(ITestStepParent target)
        {
            checkRelations(target);
            var outputs = getOutputRelations(target);
            if (outputs.Length == 0) return;
            
            Action defer = () => { };
            foreach (var connection in outputs)
            {
                if (connection.OutputObject is ITestStepParent src)
                {
                    var outputMember = connection.OutputMember;
                    var inputMember = connection.InputMember;
                    if (outputMember == null || inputMember == null)
                    {
                        defer = defer.Bind(Unassign, connection);
                        continue;
                    }

                    object value = GetOutput(connection.OutputMember, src, connection.InputObject is ITestStep step ? step.Id : Guid.NewGuid());
                    try
                    {
                        value = ConvertValue(value, connection.InputMember.TypeDescriptor);
                    }
                    catch (Exception convertException)
                    {
                        throw new Exception($"Unable to convert value for the '{connection.inputMember.Name}' setting: {convertException.Message}", convertException);
                    }
                    value = AssignOutputEvent.Invoke(target, value, connection.InputMember);
                    connection.InputMember.SetValue(target, value);
                }
            }
            defer();
        }

        internal static bool CanConvert(ITypeData to, ITypeData from)
        {
            if (from.DescendsTo(to))
                return true;
            if (to is TypeData to2 && from is TypeData from2)
            {
                if (from2.Type.IsEnum)
                {
                    // if from is an enum, it has TypeCode Int, but we dont allow assigning an enum to a int input.
                    if (to2.IsString)
                        return true;
                    
                    return false;
                }
                if (to2.IsNumeric || to2.IsString || to2.Type == typeof(bool))
                {
                    switch (from2.TypeCode)
                    {
                        case TypeCode.Double:
                        case TypeCode.Single:
                        case TypeCode.Int32:
                        case TypeCode.Int16:
                        case TypeCode.Int64:
                        case TypeCode.UInt32:
                        case TypeCode.UInt16:
                        case TypeCode.UInt64:
                        case TypeCode.Byte:
                        case TypeCode.SByte:
                        case TypeCode.Decimal:
                        case TypeCode.Boolean:
                            return true;
                        case TypeCode.String:
                            return to2.IsString;
                        default: return false;
                    }
                }
            }
            return false;
        }
    
        internal static object ConvertValue(object value, ITypeData to)
        {
            if (value == null) return null;
            
            if (to is TypeData td1 && td1.TypeCode != TypeCode.Object)
            {
                if(td1.Type != value.GetType())
                    return Convert.ChangeType(value, td1.Type);
            }
            return value;

        }

        static readonly AcceleratedDynamicMember<IInputOutputRelations> Inputs = new AcceleratedDynamicMember<IInputOutputRelations>()
        {
            ValueSetter = (owner, value) => ((IInputOutputRelations) owner).Inputs = (InputOutputRelation[])value,
            ValueGetter = (owner) => ((IInputOutputRelations) owner).Inputs,
            Name = "ConnectedInputs",
            DefaultValue = Array.Empty<InputOutputRelation>(),
            DeclaringType = TypeData.FromType(typeof(ITestStep)),
            Writable = true,
            Readable = true,
            TypeDescriptor = TypeData.FromType(typeof(InputOutputRelation[]))
        };
        
        static readonly AcceleratedDynamicMember<IInputOutputRelations> Outputs = new AcceleratedDynamicMember<IInputOutputRelations>()
        {
            ValueSetter = (owner, value) => ((IInputOutputRelations) owner).Outputs = (InputOutputRelation[])value,
            ValueGetter = (owner) => ((IInputOutputRelations) owner).Outputs,
            Name = "ConnectedOutputs",
            DefaultValue = Array.Empty<InputOutputRelation>(),
            DeclaringType = TypeData.FromType(typeof(ITestStep)),
            Writable = true,
            Readable = true,
            TypeDescriptor = TypeData.FromType(typeof(InputOutputRelation[]))
        };

        
        static InputOutputRelation[] getOutputRelations(ITestStepParent step) =>  (InputOutputRelation[]) Inputs.GetValue(step) ?? Array.Empty<InputOutputRelation>();
        
        /// <summary> Sets all the output relations from an object. </summary>
        static void SetOutputRelations(ITestStepParent step, InputOutputRelation[] specs) =>
            Inputs.SetValue(step, specs ?? Array.Empty<InputOutputRelation>());
        
        
        static InputOutputRelation[] getInputRelations(ITestStepParent step) =>  (InputOutputRelation[]) Outputs.GetValue(step) ?? Array.Empty<InputOutputRelation>();
        
        /// <summary> Gets a list of all the input relations to an object. </summary>
        static InputOutputRelation[] GetInputRelations(ITestStepParent step)
        {
            if (Outputs.GetValue(step) == null) return Array.Empty<InputOutputRelation>();
            checkRelations(step);
            return getInputRelations(step);
        }
        /// <summary> Gets a list of all the output relations from an object. </summary>
        static InputOutputRelation[] GetOutputRelations(ITestStepParent step)
        {
            if (Inputs.GetValue(step) == null) return Array.Empty<InputOutputRelation>();
            checkRelations(step);
            return getOutputRelations(step);
        }

        /// <summary> Get input/output relations to/from a test step. </summary>
        public static IEnumerable<InputOutputRelation> GetRelations(ITestStepParent step)
        {
            if (Inputs.GetValue(step) == null && Outputs.GetValue(step) == null)
                return Array.Empty<InputOutputRelation>();
            checkRelations(step);
            return getOutputRelations(step).Concat(getInputRelations(step));
        }
        
        /// <summary> Sets a list of all the input relations to an object. </summary>
        static void SetInputRelations(ITestStepParent step, InputOutputRelation[] specs) =>
            Outputs.SetValue(step, specs ?? Array.Empty<InputOutputRelation>());
    }
}