using System;
using System.Collections.Generic;
using System.Linq;
using Gs2.Util.LitJson;
using UnityEngine;
using XLua;

namespace Gs2.Unity.Gs2StateMachine.Local.Model
{
    public class ArrayVariableValue : IVariableValue
    {
        private readonly IVariableValue[] _value;

        public ArrayVariableValue() {
            this._value = Array.Empty<IVariableValue>();
        }

        public ArrayVariableValue(IVariableValue[] value) {
            this._value = value;
        }

        public VariableType Type() {
            return VariableType.Array;
        }

        public string String() {
            throw new System.NotImplementedException();
        }

        public long Int() {
            throw new System.NotImplementedException();
        }

        public double Float() {
            throw new System.NotImplementedException();
        }

        public bool Bool() {
            throw new System.NotImplementedException();
        }

        public int Count => this._value.Length;

        public IVariableValue Get(int index) {
            return index >= 0 && index < this._value.Length ? this._value[index] : null;
        }

        public string GetString(int index) {
            var value = Get(index);
            if (value != null && value.Type() == VariableType.String) {
                return value.String();
            }
            return null;
        }

        public long GetInt(int index) {
            var value = Get(index);
            if (value != null && value.Type() == VariableType.Int) {
                return value.Int();
            }
            return 0;
        }

        public double GetFloat(int index) {
            var value = Get(index);
            if (value != null && value.Type() == VariableType.Float) {
                return value.Float();
            }
            return 0;
        }

        public bool GetBool(int index) {
            var value = Get(index);
            if (value != null && value.Type() == VariableType.Bool) {
                return value.Bool();
            }
            return false;
        }

        public ArrayVariableValue GetArray(int index) {
            var value = Get(index);
            if (value is ArrayVariableValue v) {
                return v;
            }
            return null;
        }

        public MapVariableValue GetMap(int index) {
            var value = Get(index);
            if (value is MapVariableValue v) {
                return v;
            }
            return null;
        }

        public void Set(int index, IVariableValue value) {
            this._value[index] = value;
        }

        public LuaTable ToLuaTable(LuaEnv env) {
            var table = env.NewTable();
            for (var i = 0; i < this._value.Length; i++) {
                switch (this._value[i].Type()) {
                    case VariableType.Int:
                        table.Set(i+1, this._value[i].Int());
                        break;
                    case VariableType.Float:
                        table.Set(i+1, this._value[i].Float());
                        break;
                    case VariableType.String:
                        table.Set(i+1, this._value[i].String());
                        break;
                    case VariableType.Bool:
                        table.Set(i+1, this._value[i].Bool());
                        break;
                    case VariableType.Array:
                        if (this._value[i] is ArrayVariableValue arrayVariableValue) {
                            table.Set(i+1, arrayVariableValue.ToLuaTable(env));
                        }
                        break;
                    case VariableType.Map:
                        if (this._value[i] is MapVariableValue mapVariableValue) {
                            table.Set(i+1, mapVariableValue.ToLuaTable(env));
                        }
                        break;
                    default:
                        throw new ArgumentOutOfRangeException();
                }
            }
            return table;
        }

        public static ArrayVariableValue FromLuaTable(LuaTable table) {
            var variable = new List<IVariableValue>();
            foreach (var key in (from object key in table.GetKeys() select key).ToList()) {
                var v = table.Get<object>(key);
                switch (v) {
                    case long l:
                        variable.Add(new IntVariableValue(l));
                        break;
                    case double d:
                        variable.Add(new FloatVariableValue(d));
                        break;
                    case bool b:
                        variable.Add(new BoolVariableValue(b));
                        break;
                    case string s:
                        variable.Add(new StringVariableValue(s));
                        break;
                    case LuaTable t when !t.GetKeys<string>().Any() && t.GetKeys<long>().Count(v2 => v2 == 0) == 0:
                        variable.Add(ArrayVariableValue.FromLuaTable(t));
                        break;
                    case LuaTable t:
                        variable.Add(MapVariableValue.FromLuaTable(t));
                        break;
                }
            }
            return new ArrayVariableValue(variable.ToArray());
        }

        public static ArrayVariableValue FromJson(IEnumerable<JsonData> data) {
            var variable = new List<IVariableValue>();
            foreach (var v in data) {
                if (v.IsLong || v.IsInt) {
                    variable.Add(new IntVariableValue(long.Parse(v.ToString())));
                }
                if (v.IsDouble) {
                    variable.Add(new FloatVariableValue(double.Parse(v.ToString())));
                }
                if (v.IsBoolean) {
                    variable.Add(new BoolVariableValue(bool.Parse(v.ToString())));
                }
                if (v.IsString) {
                    variable.Add(new StringVariableValue(v.ToString()));
                }
                if (v.IsArray) {
                    variable.Add(FromJson(v.Cast<JsonData>()));
                }
                if (v.IsObject) {
                    variable.Add(MapVariableValue.FromJson(v));
                }
            }
            return new ArrayVariableValue(variable.ToArray());
        }

        public List<object> ToList() {
            var data = new List<object>();
            foreach (var v in this._value) {
                switch (v.Type()) {
                    case VariableType.Int:
                        data.Add($"{(double)v.Int(),10:#0.00000000}");
                        break;
                    case VariableType.Float:
                        data.Add($"{v.Float(),10:#0.00000000}");
                        break;
                    case VariableType.String:
                        data.Add(v.String());
                        break;
                    case VariableType.Bool:
                        data.Add(v.Bool());
                        break;
                    case VariableType.Array:
                        if (v is ArrayVariableValue arrayVariableValue) {
                            data.Add(arrayVariableValue.ToList());
                        }
                        break;
                    case VariableType.Map:
                        if (v is MapVariableValue mapVariableValue) {
                            data.Add(mapVariableValue.ToDictionary());
                        }
                        break;
                    default:
                        throw new ArgumentOutOfRangeException();
                }
            }
            return data;
        }
    }
}