using OpenTap.Addin.Annotation;
using System.Collections.Concurrent;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Runtime.CompilerServices;

namespace OpenTap.Addin
{
    public enum TestVariableType
    {
        String = 0,
        Int = 1,
        Double = 2,
        Bool = 3,
        Container = 8,
        Refrence = 9
    }

    public class TestVariable : INotifyPropertyChanged
    {
        #region ...
        public event PropertyChangedEventHandler PropertyChanged;

        protected void Set([CallerMemberName] string name = null)
        {

            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
        }

        protected void Set<T>(ref T old, T @new, [CallerMemberName] string propertyName = null)
        {
            old = @new;
            if (propertyName != null)
            {
                Set(propertyName);
            }
        }
        #endregion

        private string name;
        [DataGridCol("名称", "*", false)]
        public string Name
        {
            get => name;
            set
            {
                Set(ref name, value);
            }
        }

        public bool IsArray { get; set; }

        private TestVariableType type;
        [DataGridCol("类型", "*", false)]

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

        [DataGridCol("值", "*", false)]
        public string Value { get; set; }

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

        public object GetValue()
        {
            if (Type == TestVariableType.Int)
            {
                if (int.TryParse(Value, out int intValue))
                    return intValue;
            }
            else if (Type == TestVariableType.Double)
            {
                if (double.TryParse(Value, out double doubleValue))
                    return doubleValue;
            }
            else if (Type == TestVariableType.Bool)
            {
                if (bool.TryParse(Value, out bool boolValue))
                    return boolValue;
            }
            else if (Type == TestVariableType.String)
            {
                return Value;
            }
            return null;
        }

        public RuntimeVariable ToRuntime()
        {
            if (IsArray)
            {
                switch (Type)
                {
                    case TestVariableType.String:
                        return new RuntimeVariable
                        {
                            Name = Name,
                            Type = typeof(string[]),
                            TypeName = "string[]",
                            data = Children.Select(e => e.GetValue()).ToArray()
                        };
                    case TestVariableType.Int:
                        return new RuntimeVariable
                        {
                            Name = Name,
                            Type = typeof(int[]),
                            TypeName = "int[]",
                            data = Children.Select(e => e.GetValue()).ToArray()
                        };
                    case TestVariableType.Double:
                        return new RuntimeVariable
                        {
                            Name = Name,
                            Type = typeof(double[]),
                            TypeName = "double[]",
                            data = Children.Select(e => e.GetValue()).ToArray()
                        };
                    case TestVariableType.Bool:
                        return new RuntimeVariable
                        {
                            Name = Name,
                            Type = typeof(bool[]),
                            TypeName = "bool[]",
                            data = Children.Select(e => e.GetValue()).ToArray()
                        };
                    case TestVariableType.Container:
                        return new RuntimeVariable
                        {
                            Name = Name,
                            Type = typeof(object[]),
                            TypeName = "Container[]",
                            data = new VariableContext(new ConcurrentDictionary<string, RuntimeVariable>
                                (Children.Select(e => e.ToRuntime()).ToDictionary(v => v.Name, v => v)))
                        };
                }
            }
            else
            {
                switch (Type)
                {
                    case TestVariableType.String:
                        return new RuntimeVariable
                        {
                            Name = Name,
                            Type = typeof(string),
                            TypeName = "string",
                            data = Value
                        };
                    case TestVariableType.Int:
                        return new RuntimeVariable
                        {
                            Name = Name,
                            Type = typeof(int),
                            TypeName = "int",
                            data = int.Parse(Value)
                        };
                    case TestVariableType.Double:
                        return new RuntimeVariable
                        {
                            Name = Name,
                            Type = typeof(double),
                            TypeName = "double",
                            data = double.Parse(Value)
                        };
                    case TestVariableType.Bool:
                        return new RuntimeVariable
                        {
                            Name = Name,
                            Type = typeof(bool),
                            TypeName = "bool",
                            data = bool.Parse(Value)
                        };
                    case TestVariableType.Container:
                        return new RuntimeVariable
                        {
                            Name = Name,
                            Type = typeof(object[]),
                            TypeName = "object",
                            data = new VariableContext(new ConcurrentDictionary<string, RuntimeVariable>
                               (Children.Select(e => e.ToRuntime()).ToDictionary(v => v.Name, v => v)))
                        };
                }
            }
            return null;
        }

        public static string DefaultValue(TestVariableType type)
        {
            switch (type)
            {
                case TestVariableType.String:
                    return string.Empty;
                case TestVariableType.Int:
                    return "0";
                case TestVariableType.Double:
                    return "0";
                case TestVariableType.Bool:
                    return "False";
                default:
                    return null;
            }
        }
    }
}