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 MapVariableValue : IVariableValue
    {
        private readonly Dictionary<string, IVariableValue> _value;

        public MapVariableValue() {
            this._value = new Dictionary<string, IVariableValue>();
        }

        public MapVariableValue(Dictionary<string, IVariableValue> value) {
            this._value = value;
        }

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

        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 IVariableValue Get(string key) {
            return this._value.TryGetValue(key, out var value) ? value : null;
        }

        public string GetString(string key) {
            this._value.TryGetValue(key, out var value);
            if (value != null && value.Type() == VariableType.String) {
                return value.String();
            }
            return null;
        }

        public long GetInt(string key) {
            this._value.TryGetValue(key, out var value);
            if (value != null && value.Type() == VariableType.Int) {
                return value.Int();
            }
            return 0;
        }

        public double GetFloat(string key) {
            this._value.TryGetValue(key, out var value);
            if (value != null && value.Type() == VariableType.Float) {
                return value.Float();
            }
            return 0;
        }

        public bool GetBool(string key) {
            this._value.TryGetValue(key, out var value);
            if (value != null && value.Type() == VariableType.Bool) {
                return value.Bool();
            }
            return false;
        }

        public ArrayVariableValue GetArray(string key) {
            this._value.TryGetValue(key, out var value);
            if (value is ArrayVariableValue v) {
                return v;
            }
            return null;
        }

        public MapVariableValue GetMap(string key) {
            this._value.TryGetValue(key, out var value);
            if (value is MapVariableValue v) {
                return v;
            }
            return null;
        }

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

        public LuaTable ToLuaTable(LuaEnv env) {
            var table = env.NewTable();
            foreach (var element in this._value) {
                switch (element.Value.Type()) {
                    case VariableType.Int:
                        table.Set(element.Key, element.Value.Int());
                        break;
                    case VariableType.Float:
                        table.Set(element.Key, element.Value.Float());
                        break;
                    case VariableType.String:
                        table.Set(element.Key, element.Value.String());
                        break;
                    case VariableType.Bool:
                        table.Set(element.Key, element.Value.Bool());
                        break;
                    case VariableType.Array:
                        if (element.Value is ArrayVariableValue arrayVariableValue) {
                            table.Set(element.Key, arrayVariableValue.ToLuaTable(env));
                        }
                        break;
                    case VariableType.Map:
                        if (element.Value is MapVariableValue mapVariableValue) {
                            table.Set(element.Key, mapVariableValue.ToLuaTable(env));
                        }
                        break;
                    default:
                        throw new ArgumentOutOfRangeException();
                }
            }
            return table;
        }

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

        public static MapVariableValue FromJson(JsonData data) {
            var variable = new Dictionary<string, IVariableValue>();
            foreach (var key in data.Keys) {
                var v = data[key];
                if (v.IsLong || v.IsInt) {
                    variable[key] = new IntVariableValue(long.Parse(v.ToString()));
                }
                if (v.IsDouble) {
                    variable[key] = new FloatVariableValue(double.Parse(v.ToString()));
                }
                if (v.IsBoolean) {
                    variable[key] = new BoolVariableValue(bool.Parse(v.ToString()));
                }
                if (v.IsString) {
                    variable[key] = new StringVariableValue(v.ToString());
                }
                if (v.IsArray) {
                    variable[key] = ArrayVariableValue.FromJson(v.Cast<JsonData>());
                }
                if (v.IsObject) {
                    variable[key] = FromJson(v);
                }
            }
            return new MapVariableValue(variable);
        }

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