using AddInEnums;
using DynamicExpresso;
using OpenTap;
using OpenTap.Addin;
using OpenTap.Addin.Util;
using System;

namespace AddInPlugin.Util
{
    public class DefaultVariableResolverFactory : IVariableResolverCreator
    {
        public IVariableResolver CreateResolver()
        {
            return new DefaultVariableResolver();
        }
    }

    public class DefaultVariableResolver : IVariableResolver
    {
        public event EventHandler<string> DataChanged;

        public static Interpreter GetInterpreter(TestPlanRun run, ITestStep step)
        {
            var target = new Interpreter();
            target.SetVariable("this", MethodUtil.Instance);
            target.SetVariable("Enums", Enums.Instance);
            target.SetVariable(ConstNames.LocalsName, run?.LocalsRuntime);
            target.SetVariable(ConstNames.ParametersName, run?.ParametersRuntime);
            target.SetVariable(ConstNames.FileGlobalsName, run?.FileGlobalsRuntime);
            target.SetVariable(ConstNames.StationGlobalsName, run?.StationGlobalsRuntime);
            target.SetVariable(ConstNames.ThisContextName, run);
            target.SetVariable("Step", step);
            target.SetVariable("RunState", step?.StepRun);

            target.SetVariable("True", true);
            target.SetVariable("TRUE", true);
            target.SetVariable("False", false);
            target.SetVariable("FALSE", false);

            target.SetFunction("Val", MethodUtil.GetValImpl());


            var context = step?.GetParent<ContextStep>();
            if (context != null)
            {
                target.SetVariable("Context", context.GetContextVariables());
            }
            return target;
        }

        public dynamic Resolve(TestPlanRun run, ITestStep step, string expr)
        {
            return Resolve(run, step, expr, typeof(void));
        }

        public T Resolve<T>(TestPlanRun run, ITestStep step, string expr)
        {
            return Resolve(run, step, expr, typeof(T));
        }

        public dynamic Resolve(TestPlanRun run, ITestStep step, string expr, Type targetType)
        {
            if (string.IsNullOrEmpty(expr)) return null;
            var target = GetInterpreter(run, step);
            object obj = target.Eval(expr);
            if (obj is NullVariable || obj == null)
            {
                return null;
            }
            if (targetType == typeof(string))
            {
                return obj.ToString();
            }

            var result = obj;
            if (obj is RuntimeVariable rv)
            {
                if (targetType == typeof(RuntimeVariable))
                {
                    return rv;
                }
                result = rv.__data___;
            }

            //if (targetType != typeof(void) && !targetType.IsAssignableFrom(result.GetType()))
            //{
            //    throw new ArgumentException($"{result.GetType()} can't convert to {targetType}");
            //}
            return result;
        }

        public void Update(TestPlanRun run, ITestStep step, string expr)
        {
            var target = GetInterpreter(run, step);
            string[] arr = ExpressUtil.SplitIgnoringQuotes(expr);
            {
                foreach (var data in arr)
                {
                    target.Eval(data);
                }
            }
            DataChanged?.Invoke(this, expr);
        }

        public void Update(TestPlanRun run, ITestStep step, string name, object value)
        {
            if (string.Equals(name, "true", StringComparison.OrdinalIgnoreCase)
                || string.Equals(name, "false", StringComparison.OrdinalIgnoreCase)
                || name.StartsWith("\"")
                || name.EndsWith("\"")
                || name.StartsWith("'")
                || name.EndsWith("'")
                || double.TryParse(name, out _))
            {
                /// 基础数据直接返回
                return;
            }

            var target = GetInterpreter(run, step);
            var expr = $"{name} = __temp";
            target.Eval(expr, new Parameter("__temp", value));
            DataChanged?.Invoke(this, name);
        }
    }
}