using AddInPlugin.Util;
using OpenTap;
using OpenTap.Addin.Annotation;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Reflection;
using System.Xml.Serialization;
using UtilLib;

namespace AddInPlugin
{
    public enum VariableDirection
    {
        In = 0,
        Out = 1
    }

    public class MethodVariable
    {
        [DataGridCol("Ãû³Æ", "*", true)]
        public string Name { get; set; }

        [XmlIgnore]
        public Type Type { get; set; }

        [XmlIgnore]
        public object Value { get; set; }

        [DataGridCol("·½Ïò", "*", true)]
        public VariableDirection Direction { get; set; }

        [DataGridCol("ÀàÐÍ", "*", true)]
        public string TypeName { get; set; }

        [DataGridCol("Öµ", "*", false)]
        public string ValueStr { get; set; }

        public override bool Equals(object obj)
        {
            if (obj is MethodVariable ev)
            {
                return ev.Name == Name && ev.ValueStr == ValueStr;
            }
            return base.Equals(obj);
        }

        public override int GetHashCode()
        {
            var h1 = Name?.GetHashCode() ?? 0;
            var h2 = ValueStr?.GetHashCode() ?? 0;
            return (((h1 + 742759321) * 1593213024) + h2) * 1079741372;
        }
    }

    [Prototype]
    [Display("DotNetStep", Description: "ÔËÐÐ.Net")]

    public class DotNetStep : VariableTestStep
    {
        #region Settings
        // ToDo: Add property here for each parameter the end user should be able to change
        //[Display("Instrument", Order: 0.0, Description: "The instrument that the query is sent to.")]
        //public DllAction Instrument { get; set; }

        //// ToDo: Add property here for each parameter the end user should be able to change
        //[Display("Dut", Order: 0.0, Description: "The instrument that the query is sent to.")]
        //public MyDUT Dut { get; set; }

        private string dllPath;

        [Display("·¾¶", Order: 0.0, Description: "Dll¾ø¶Ô·¾¶.")]
        [FilePath(FilePathAttribute.BehaviorChoice.Open)]
        public string DllPath
        {
            get => dllPath;
            set
            {
                if (dllPath != value)
                {
                    dllPath = value;
                    OnPropertyChanged(nameof(DllPath));
                    LoadDll();
                }
            }
        }

        private Assembly assembly;

        private Type targetType;

        private ObservableCollection<string> types;
        [XmlIgnore]
        public ObservableCollection<string> Types
        {
            get => types;
            set
            {
                types = value;
                OnPropertyChanged(nameof(Types));
            }
        }

        private string className;
        [Display("ˈ̞", Order: 0.0, Description: "ˈ̞.")]
        [DynamicSelect("Types")]
        public string ClassName
        {
            get => className;
            set
            {
                if (className != value)
                {
                    className = value;
                    if (!string.IsNullOrEmpty(value))
                    {
                        LoadTypes();
                    }
                    OnPropertyChanged(nameof(ClassName));
                }
            }
        }

        private ObservableCollection<string> methods;
        [XmlIgnore]
        public ObservableCollection<string> Methods
        {
            get => methods;
            set
            {
                methods = value;
                OnPropertyChanged(nameof(Methods));
            }
        }

        private string methodName;
        [Display("·½·¨", Order: 0.0, Description: "·½·¨Ãû.")]
        //[DynamicSelect(nameof(MethodName), "ClassName", "RefreshMethodName")]
        [DynamicSelect("Methods")]
        public string MethodName
        {
            get => methodName;
            set
            {
                if (methodName != value)
                {
                    methodName = value;
                    OnPropertyChanged(nameof(MethodName));
                    if (!string.IsNullOrEmpty(value))
                    {
                        RefreshVariables();
                    }
                }
            }
        }

        private Dictionary<string, MethodBase> methodCache = new Dictionary<string, MethodBase>();

        [XmlIgnore]
        private bool IsConstructorMethod = false;

        [XmlIgnore]
        private bool IsStatic = false;

        [XmlIgnore]
        private object instance;

        #endregion
        public DotNetStep()
        {
            // ToDo: Set default values for properties / settings.
            Rules.Add(() => !string.IsNullOrWhiteSpace(DllPath), "·¾¶²»ÄÜΪ¿Õ", DllPath);
            Rules.Add(() => !string.IsNullOrWhiteSpace(ClassName), "ÀàÃû²»ÄÜΪ¿Õ", ClassName);
        }

        private void LoadDll()
        {
            try
            {
                if (string.IsNullOrEmpty(DllPath))
                {
                    return;
                }
                assembly = Assembly.LoadFrom(DllPath);
                Types = new ObservableCollection<string>(assembly.GetTypes().Select(e => e.ToString()).ToArray());
            }
            catch (Exception ex)
            {
                Log.Error("DotNetStep load dll error. {0}", ex);
            }
        }

        public void LoadTypes()
        {
            methodCache.Clear();
            try
            {
                targetType = assembly?.GetType(ClassName);
                if (targetType != null)
                {
                    var creators = targetType?.GetConstructors();
                    if (creators != null)
                    {
                        for (int i = 0; i < creators.Length; i++)
                        {
                            var creator = creators[i];
                            var ps = creator.GetParameters();
                            var displayName = $"{targetType.Name} ({string.Join(", ", ps.Select(p => $"{p.ParameterType.ToString()} {p.Name}").ToArray())})";
                            methodCache[displayName] = creator;
                        }
                    }

                    var methods = MethodInfoHelper.GetPublicMethodNames(targetType);
                    if (methods != null)
                    {
                        for (int i = 0; i < methods.Count; i++)
                        {
                            var method = methods[i];
                            var ps = method.GetParameters();
                            var displayName = $"{method.Name} ({string.Join(", ", ps.Select(p => $"{p.ParameterType.ToString()} {p.Name}").ToArray())})";
                            methodCache[displayName] = method;
                        }
                    }
                }
                Methods = new ObservableCollection<string>(methodCache.Keys.ToArray());
            }
            catch (Exception ex)
            {
                Log.Error("DotNetStep LoadTypes error. {0}", ex);
            }
        }

        public void RefreshVariables()
        {
            if (MethodVariables == null)
            {
                MethodVariables = new ObservableCollection<MethodVariable>();
            }
            MethodVariables.Clear();
            try
            {
                if (!methodCache.ContainsKey(MethodName))
                {
                    return;
                }
                var method = methodCache[MethodName];
                var ps = method.GetParameters();
                IsStatic = method.IsStatic;
                IsConstructorMethod = method.IsConstructor;

                if (IsConstructorMethod)
                {
                    MethodVariables.Add(new MethodVariable
                    {
                        Name = "(return)",
                        Type = targetType,
                        TypeName = targetType?.ToString(),
                        Direction = VariableDirection.Out,
                    });

                }
                else if (!IsStatic)
                {
                    var mi = (MethodInfo)method;
                    MethodVariables.Add(new MethodVariable
                    {
                        Name = "(instance)",
                        Type = targetType,
                        TypeName = targetType?.ToString(),
                        Direction = VariableDirection.In,
                    });
                    MethodVariables.Add(new MethodVariable
                    {
                        Name = "(return)",
                        Type = mi.ReturnType,
                        TypeName = mi.ReturnType?.ToString(),
                        Direction = VariableDirection.Out,
                    });
                }
                else
                {
                    var mi = (MethodInfo)method;
                    MethodVariables.Add(new MethodVariable
                    {
                        Name = "(return)",
                        Type = mi.ReturnType,
                        TypeName = mi.ReturnType?.ToString(),
                        Direction = VariableDirection.Out,
                    });
                }

                foreach (var p in ps)
                {
                    MethodVariables.Add(new MethodVariable
                    {
                        Name = p.Name,
                        Type = p.ParameterType,
                        TypeName = p.ParameterType.ToString(),
                        Direction = p.IsOut ? VariableDirection.Out : VariableDirection.In,
                    });
                }
            }
            catch (Exception ex)
            {
                Log.Error("DotNetStep LoadVariables error. {0}", ex);
            }
        }

        public override void PrePlanRun()
        {
            // ToDo: Optionally add any setup code this step needs to run before the testplan starts
            base.PrePlanRun();
        }

        /// <summary>
        /// ת»»²ÎÊý
        /// </summary>
        private void ResolveVariables()
        {
            var method = methodCache[methodName];
            if (IsConstructorMethod)
            {
                //methodParams = new object[MethodVariables.Count - 1];
                for (int i = 1; i < MethodVariables.Count; i++)
                {
                    MethodVariable mv = MethodVariables[i];
                    if (mv.Direction == VariableDirection.In)
                    {
                        mv.Value = PlanRun.Resolve(this, mv.ValueStr, mv.Type); // mv.GetValue(PlanRun);
                    }
                    //methodParams[i-1] = mv.GetValue(PlanRun);
                }
            }
            else if (IsStatic)
            {
                //methodParams = new object[MethodVariables.Count - 2];
                for (int i = 1; i < MethodVariables.Count; i++)
                {
                    MethodVariable mv = MethodVariables[i];
                    if (mv.Direction == VariableDirection.In)
                    {
                        mv.Value = PlanRun.Resolve(this, mv.ValueStr, mv.Type); //mv.GetValue(PlanRun);
                    }
                    //methodParams[i] = mv.GetValue(PlanRun);
                }
            }
            else
            {
                //methodParams = new object[MethodVariables.Count - 1];
                for (int i = 1; i < MethodVariables.Count; i++)
                {
                    var mv = MethodVariables[i];
                    if (mv.Direction == VariableDirection.In)
                    {
                        mv.Value = PlanRun.Resolve(this, mv.ValueStr, mv.Type); //mv.GetValue(PlanRun);
                    }
                    //methodParams[i] = mv.GetValue(PlanRun);
                }
            }
        }

        /// <summary>
        /// ÔËÐк¯Êý
        /// </summary>
        private void RunMethod()
        {
            ResolveVariables();

            if (IsConstructorMethod)
            {
                var method = (ConstructorInfo)methodCache[methodName];
                var methodParams = new object[MethodVariables.Count - 1];
                for (int i = 1; i < MethodVariables.Count; i++)
                {
                    var mv = MethodVariables[i];
                    methodParams[i - 1] = mv.Value;
                }
                instance = method.Invoke(methodParams);
                MethodVariables[0].Value = instance;
            }
            else if (IsStatic)
            {
                var method = methodCache[methodName];
                var methodParams = new object[MethodVariables.Count - 1];
                for (int i = 1; i < MethodVariables.Count; i++)
                {
                    var mv = MethodVariables[i];
                    methodParams[i - 1] = mv.Value;
                }

                MethodVariables[0].Value = method.Invoke(null, methodParams);
                for (int i = 0; i < methodParams.Length; i++)
                {
                    MethodVariables[i + 1].Value = methodParams[i];
                }
            }
            else
            {
                var method = methodCache[methodName];
                var methodParams = new object[MethodVariables.Count - 2];
                for (int i = 2; i < MethodVariables.Count; i++)
                {
                    var mv = MethodVariables[i];
                    methodParams[i - 2] = mv.Value;
                }
                instance = PlanRun.Resolve(this, MethodVariables[0].ValueStr);
                MethodVariables[1].Value = method.Invoke(instance, methodParams);
                for (int i = 0; i < methodParams.Length; i++)
                {
                    MethodVariables[i + 2].Value = methodParams[i];
                }
            }
        }

        public override void Run()
        {
            try
            {
                // ToDo: Add test case code here
                //RunChildSteps(); //If step has child steps.
                RunMethod();

                UpdateVariableToRuntime();
                this.Verdict = Verdict.Pass;
            }
            catch (Exception ex)
            {
                Log.Error("DotNetStep Run error. {0}", ex);
                this.Verdict = Verdict.Error;
            }
        }

        private void UpdateVariableToRuntime()
        {
            //if (IsConstructorMethod)
            //{
            //    var methodVariable = MethodVariables[0];
            //    PlanRun.UpdateRuntimeVariable(methodVariable.ValueStr, instance);
            //}
            foreach (var mv in MethodVariables)
            {
                if (mv.Direction == VariableDirection.Out)
                {
                    PlanRun.Update(this, mv.ValueStr, mv.Value);
                }
            }
        }

        public override void PostPlanRun()
        {
            // ToDo: Optionally add any cleanup code this step needs to run after the entire testplan has finished
            base.PostPlanRun();
        }
    }
}