using OpenTap;
using OpenTap.Addin;
using OpenTap.Addin.Entity;
using OpenTap.Addin.Util;
using System.Collections.ObjectModel;
using UILib;

namespace OpenTapEditor
{
    public class RunningVarContext : NotifyBase
    {
        private TestPlanRun planRun;
        public TestPlanRun PlanRun
        {
            get => planRun;
            set
            {
                planRun = value;
            }
        }

        private Dictionary<ObservableCollection<TestVariable>, ObservableCollection<RunningVar>> runtimeCache
            = new Dictionary<ObservableCollection<TestVariable>, ObservableCollection<RunningVar>>();


        public ObservableCollection<RunningVar> CreateRuntime(ObservableCollection<TestVariable> key, string name)
        {
            if (!runtimeCache.ContainsKey(key))
            {
                var temp = RunningVar.FromTest(this, name, false, key);
                runtimeCache[key] = temp;
            }
            return runtimeCache[key];
        }

        public event EventHandler<string> NotifyUpdate;

        private void Resolver_DataChanged(object sender, string e)
        {
            NotifyUpdate?.Invoke(this, e);
        }

        private ObservableCollection<RunningVar> children = new ObservableCollection<RunningVar>();
        public ObservableCollection<RunningVar> Children
        {
            get => children;
            set
            {
                Set(ref children, value);
            }
        }

        public void RefreshPlan(TestPlanRun planRun, TestPlan plan, TestStepList list)
        {
            if (PlanRun != null)
            {
                PlanRun.Resolver.DataChanged -= Resolver_DataChanged;
            }

            PlanRun = planRun;
            PlanRun.Resolver.DataChanged += Resolver_DataChanged;

            //Dettach(Children[0]);
            //Dettach(Children[1]);
            //Dettach(Children[2]);

            //Children[0] = new RunningVar()
            //{
            //    context = this,
            //    Name = ConstNames.LocalsName,
            //    IsArray = false,
            //    Type = TestVariableType.Container,
            //    //Children = RunningVar.FromTest(this, ConstNames.LocalsName, false, list.Variables)
            //    Children = CreateRuntime(list.Variables, ConstNames.LocalsName)
            //};
            //Children[1] = new RunningVar()
            //{
            //    context = this,
            //    Name = ConstNames.ParametersName,
            //    IsArray = false,
            //    Type = TestVariableType.Container,
            //    //Children = RunningVar.FromTest(this, ConstNames.ParametersName, false, list.Parameters)
            //    Children = CreateRuntime(list.Parameters, ConstNames.ParametersName)
            //};

            Children[0].Children = CreateRuntime(list.Variables, ConstNames.LocalsName);
            Children[1].Children = CreateRuntime(list.Parameters, ConstNames.ParametersName);
            Children[2].Children = CreateRuntime(plan.Variables, ConstNames.FileGlobalsName);
            //RunningVar.FromTest(this, ConstNames.FileGlobalsName, false, plan.Variables);
            NotifyUpdate?.Invoke(this, RunningVar.ALL);
        }


        private void Dettach(object runVar)
        {
            if (runVar is IEnumerable<RunningVar> list)
            {
                if (list == null || list.Count() <= 0)
                {
                    return;
                }
                foreach (var data in list)
                {
                    Dettach(data);
                }
            }
            else if (runVar is RunningVar rVar)
            {
                rVar.Dettach(this);
                Dettach(rVar.Children);
            }
        }

        public void Release()
        {
            if (PlanRun != null)
            {
                PlanRun.Resolver.DataChanged -= Resolver_DataChanged;
            }
            Dettach(Children);
            foreach (var val in runtimeCache.Values)
            {
                Dettach(val);
            }
            runtimeCache.Clear();
        }
    }

    public class RunningVar : NotifyBase
    {
        internal const string ALL = "*";
        internal RunningVarContext context;

        private string id;

        private void VariableResolver_DataChanged(object? sender, string e)
        {
            //if (e == ALL || e.Contains(id))
            //{

            //}
            Set(nameof(Value));
        }

        private string name;
        public string Name
        {
            get => name;
            set
            {
                Set(ref name, value);
            }
        }

        public bool IsArray { get; set; }

        private TestVariableType type;
        public TestVariableType Type
        {
            get => type;
            set
            {
                Set(ref type, value);
            }
        }

        private string contextName;
        public string ContextName
        {
            get => contextName;
            set
            {
                Set(ref contextName, value);
                Set(nameof(Title));
            }
        }

        public string Title
        {
            get
            {
                if (string.IsNullOrEmpty(ContextName))
                    return Name;
                return $"{Name}  ({ContextName})";
            }
            set
            {
                Set(ref name, value);
                Set(nameof(Title));
            }
        }

        public string Value
        {
            get
            {
                if (IsArray || Type == TestVariableType.Container)
                {
                    return null;
                }
                return context.PlanRun.Resolver.Resolve(context.PlanRun, null, id)?.ToString();
            }
            set
            {
                if (GetValue(value, out var v))
                {
                    context.PlanRun.Resolver.Update(context.PlanRun, null, id, v);
                }
            }
        }

        private ObservableCollection<RunningVar> children = new ObservableCollection<RunningVar>();
        public ObservableCollection<RunningVar> Children
        {
            get => children;
            set
            {
                Set(ref children, value);
            }
        }

        public bool GetValue(string valueStr, out dynamic value)
        {
            value = null;
            if (IsArray)
            {
                return false;
            }
            if (Type == TestVariableType.Container || Type == TestVariableType.Refrence)
            {
                return false;
            }
            try
            {
                switch (this.Type)
                {
                    case TestVariableType.String:
                        value = valueStr;
                        return true;
                    case TestVariableType.Int:
                        value = new NumberData(valueStr);
                        return true;
                    case TestVariableType.Double:
                        value = new NumberData(valueStr);
                        return true;
                    case TestVariableType.Bool:
                        value = bool.Parse(valueStr);
                        return true;
                    default:
                        return false;
                }
            }
            catch (Exception ex)
            {
                return false;
            }
        }

        public void Dettach(RunningVarContext context)
        {
            context.NotifyUpdate -= this.VariableResolver_DataChanged;
        }

        public static ObservableCollection<RunningVar> FromTest(RunningVarContext context, string parentKey, bool parentIsArray,
            ObservableCollection<TestVariable> testVars)
        {
            ObservableCollection<RunningVar> result = new ObservableCollection<RunningVar>();
            foreach (var tv in testVars)
            {
                var rv = FromTest(context, parentKey, parentIsArray, tv);
                result.Add(rv);
            }
            return result;
        }

        public static RunningVar FromTest(RunningVarContext context, string parentId, bool parentIsArray, TestVariable testVar)
        {
            var runningVar = new RunningVar();
            runningVar.context = context;
            context.NotifyUpdate += runningVar.VariableResolver_DataChanged;

            if (string.IsNullOrEmpty(parentId))
            {
                runningVar.id = testVar.Name;
            }
            else
            {
                if (parentIsArray)
                {
                    runningVar.id = parentId + testVar.Name;
                }
                else
                {
                    runningVar.id = parentId + "." + testVar.Name;
                }
            }
            runningVar.Name = testVar.Name;
            runningVar.IsArray = testVar.IsArray;
            runningVar.Type = testVar.Type;
            if (testVar.Children != null)
            {
                runningVar.Children = FromTest(context, runningVar.id, runningVar.IsArray, testVar.Children);
            }
            return runningVar;
        }
    }
}