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

namespace AddInPlugin
{
    public class DllData
    {
        public DateTime lastUpdateTime { get; set; }

        public Assembly assembly { get; set; }

        public ObservableCollection<string> types { get; set; }

        public DllData(DateTime lastUpdateTime, string[] types)
        {
            this.lastUpdateTime = lastUpdateTime;
            this.types = new ObservableCollection<string>(types);
        }
    }

    public class DllLoader
    {

        private DllLoader()
        {
        }

        private static object lockObj = new object();

        private ConcurrentDictionary<string, DllData> loadedCache = new ConcurrentDictionary<string, DllData>();
        private ConcurrentDictionary<Type, List<MethodInfo>> loadedMethod = new ConcurrentDictionary<Type, List<MethodInfo>>();

        private static DllLoader instance;
        public static DllLoader Instance
        {
            get
            {
                lock (lockObj)
                {
                    if (instance == null)
                    {
                        instance = new DllLoader();
                    }
                    return instance;
                }
            }
        }

        public Assembly LoadAssembly(string path, out ObservableCollection<string> typeNames)
        {
            path = path?.ToLower();
            typeNames = null;
            if (!File.Exists(path))
            {
                return null;
            }
            DateTime newTime = File.GetLastWriteTime(path);
            if (!loadedCache.ContainsKey(path) || loadedCache[path].lastUpdateTime != newTime)
            {
                var assembly = Assembly.LoadFrom(path);
                var types = assembly.GetTypes();

                var data = new DllData(newTime, types.Select(e => e.ToString()).ToArray())
                {
                    assembly = assembly,
                };
                loadedCache[path] = data;
                typeNames = data.types;
            }
            typeNames = loadedCache[path].types;
            return loadedCache[path].assembly;
        }

        //public List<MethodInfo> LoadMethods(Type type) {
        //    if (!loadedMethod.ContainsKey(type)) {
        //        loadedMethod[type] = MethodInfoHelper.GetPublicMethodNames(type);
        //    }
        //}
    }

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

    public class MethodVariable : TapNotifyBase
    {
        private string name;
        [DataGridCol("Ãû³Æ", "Auto", true)]
        public string Name
        {
            get => name;
            set
            {
                Set(ref name, value);
            }
        }

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

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

        private VariableDirection direction;
        [DataGridCol("·½Ïò", "Auto", true)]
        public VariableDirection Direction
        {
            get => direction;
            set
            {
                Set(ref direction, value);
            }
        }

        private string typeName;
        [DataGridCol("ÀàÐÍ", "Auto", true)]
        public string TypeName
        {
            get => typeName;
            set
            {
                Set(ref typeName, value);
            }
        }

        private bool log;
        [DataGridCol("Log", "Auto", false)]
        public bool Log
        {
            get => log;
            set
            {
                Set(ref log, value);
            }
        }

        private string valueStr;
        [DataGridCol("Öµ", "*", false, true)]
        public string ValueStr
        {
            get => valueStr;
            set
            {
                Set(ref valueStr, value);
            }
        }
    }

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

    public class DotNetStep : VariableTestStep
    {
        #region Settings

        private string dllPath;

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

        public bool ShouldSerializeDllPath()
        {
            return false;
        }


        private LocationString dllLocation = new LocationString();
        [Display("·¾¶", Order: 0.0, Description: "Dll¾ø¶Ô·¾¶.")]
        [FilePath(FilePathAttribute.BehaviorChoice.Open, fileExtension: "dll|*.dll")]
        public LocationString DllLocation
        {
            get => dllLocation;
            set
            {
                Set(ref dllLocation, value);
            }
        }

        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 (loadException == null)
                {
                    Set(ref className, value);
                    if (!string.IsNullOrEmpty(value))
                    {
                        LoadType();
                    }
                }
            }
        }

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

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

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

        [XmlIgnore]
        private object instance;

        #endregion


        private Exception loadException;

        [XmlIgnore]
        public Exception LoadException
        {
            get => loadException;
            set
            {
                Set(ref loadException, value);
            }
        }

        public DotNetStep()
        {
            // ToDo: Set default values for properties / settings.
            //Rules.Add(() => !string.IsNullOrWhiteSpace(DllPath), "·¾¶²»ÄÜΪ¿Õ", DllPath);
            //Rules.Add(() => DllLocation.GetLocation(Root.Path, out _), "·¾¶²»´æÔÚ", nameof(DllLocation));
            Rules.Add(() => DllLocation.GetLocation("C:\\Users\\chrry\\Desktop\\Release\\Api\\test.plan", out _), "·¾¶²»´æÔÚ", nameof(DllLocation));
            Rules.Add(() => !string.IsNullOrWhiteSpace(ClassName), "ÀàÃû²»ÄÜΪ¿Õ", nameof(ClassName));
            Rules.Add(() => LoadException == null, () => $"Dll¼ÓÔØʧ°Ü:{LoadException}", nameof(DllLocation));
        }

        private void DllLocation_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
        {
            LoadDll();
        }

        protected override void OnRootChanged(TestPlan old, TestPlan plan)
        {
            try
            {
                if (!string.IsNullOrEmpty(dllPath))
                {
                    DllLocation.AbsoluteLocation = dllPath;
                    dllPath = null;
                }
                DllLocation.Refresh(Root?.Path);
                DllLocation.PropertyChanged += DllLocation_PropertyChanged;

                if (!DllLocation.GetLocation(Root.Path, out string path))
                {
                    throw new Exception("Dll Exception");
                }
                assembly = Assembly.LoadFrom(path);
                Types = new ObservableCollection<string>(assembly.GetTypes().Select(e => e.ToString()).ToArray());
                LoadType();
                RefreshVariables();
                LoadException = null;
            }
            catch (Exception ex)
            {
                LoadException = ex;
                //Log.Error("DotNetStep load dll error. {0}", ex);
            }
        }

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

        private void LoadDll()
        {
            try
            {
                if (!DllLocation.GetLocation(Root?.Path, out string path))
                {
                    throw new Exception("Dll Exception");
                }
                assembly = DllLoader.Instance.LoadAssembly(path, out var types);
                Types = types;
                LoadException = null;
            }
            catch (Exception ex)
            {
                LoadException = ex;
                //Log.Error("DotNetStep load dll error. {0}", ex);
            }
        }

        public void LoadType()
        {
            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);
            }
        }

        private void ConcatVariable(MethodVariable mv, MethodVariable[] source)
        {
            MethodVariables.Add(mv);
            var preview = source?.FirstOrDefault(v => v.Name == mv.Name && !string.IsNullOrEmpty(v.ValueStr));
            if (preview != null)
            {
                mv.ValueStr = preview.ValueStr;
            }
        }

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

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

                    ConcatVariable(new MethodVariable
                    {
                        Name = "(return)",
                        Type = mi.ReturnType,
                        TypeName = mi.ReturnType?.ToString(),
                        Direction = VariableDirection.Out,
                    }, last);
                }

                foreach (var p in ps)
                {
                    ConcatVariable(new MethodVariable
                    {
                        Name = p.Name,
                        Type = p.ParameterType,
                        TypeName = p.ParameterType.ToString(),
                        Direction = p.IsOut ? VariableDirection.Out : VariableDirection.In,
                    }, last);
                }
                // MethodVariables = variables;
            }
            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];
            var IsStatic = method.IsStatic;
            var IsConstructorMethod = method.IsConstructor;
            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();

            var method = methodCache[methodName];
            var IsStatic = method.IsStatic;
            var IsConstructorMethod = method.IsConstructor;

            if (IsConstructorMethod)
            {
                var constructor = (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 = constructor.Invoke(methodParams);
                MethodVariables[0].Value = instance;
            }
            else if (IsStatic)
            {
                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 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];
                }
            }
        }

        protected override void RunDetail()
        {
            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;
            }
        }
    }
}