#region Header
/**
 * JsonMapper.cs
 *   JSON to .Net object and object to JSON conversions.
 *
 * The authors disclaim copyright to this source code. For more details, see
 * the COPYING file included with this distribution.
 **/
#endregion


using Best.HTTP.Shared.PlatformSupport.Threading;

using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Threading;


namespace Best.HTTP.JSON.LitJson
{
    public interface IFastSetter
    {
        void SetBool(ReadOnlySpan<char> property, bool value);
        void SetInteger(ReadOnlySpan<char> property, long value);
        void SetDouble(ReadOnlySpan<char> property, double value);
        void SetOther(ReadOnlySpan<char> property, object value);
    }

    class ReadOnlyMemoryCharEqualityComparer : IEqualityComparer<ReadOnlyMemory<char>>
    {
        public static ReadOnlyMemoryCharEqualityComparer Comparer = new ReadOnlyMemoryCharEqualityComparer();

        public bool Equals(ReadOnlyMemory<char> x, ReadOnlyMemory<char> y)
        {
            var eq = MemoryExtensions.Equals(x.Span, y.Span, StringComparison.OrdinalIgnoreCase);
            return eq;
        }

        public int GetHashCode(ReadOnlyMemory<char> obj)
        {
            HashCode hash = new HashCode();

            for (int i = 0; i < obj.Length; ++i)
                hash.Add(Char.ToLowerInvariant(obj.Span[i]));

            return hash.ToHashCode();
        }
    }

    internal struct PropertyMetadata
    {
        public MemberInfo Info;
        public bool IsField;
        public Type Type;
    }


    internal struct ArrayMetadata
    {
        private Type element_type;
        private bool is_array;
        private bool is_list;


        public Type ElementType
        {
            get
            {
                if (element_type == null)
                    return typeof(JsonData);

                return element_type;
            }

            set { element_type = value; }
        }

        public bool IsArray
        {
            get { return is_array; }
            set { is_array = value; }
        }

        public bool IsList
        {
            get { return is_list; }
            set { is_list = value; }
        }
    }


    internal struct ObjectMetadata
    {
        private Type element_type;
        private bool is_dictionary;

        private IDictionary<ReadOnlyMemory<char>, PropertyMetadata> properties;


        public Type ElementType
        {
            get
            {
                if (element_type == null)
                    return typeof(JsonData);

                return element_type;
            }

            set { element_type = value; }
        }

        public bool IsDictionary
        {
            get { return is_dictionary; }
            set { is_dictionary = value; }
        }

        public IDictionary<ReadOnlyMemory<char>, PropertyMetadata> Properties
        {
            get { return properties; }
            set { properties = value; }
        }
    }


    internal delegate void ExporterFunc(object obj, JsonWriter writer);
    public delegate void ExporterFunc<T>(T obj, JsonWriter writer);

    internal delegate object ImporterFunc(object input);
    public delegate TValue ImporterFunc<TJson, TValue>(TJson input);

    public delegate IJsonWrapper WrapperFactory();


    public sealed class JsonMapper
    {
        #region Fields
        private static readonly int max_nesting_depth;

        private static readonly IFormatProvider datetime_format;

        private static readonly IDictionary<Type, ExporterFunc> base_exporters_table;
        private static readonly IDictionary<Type, ExporterFunc> custom_exporters_table;

        private static readonly IDictionary<Type,
                IDictionary<Type, ImporterFunc>> base_importers_table;
        private static readonly IDictionary<Type,
                IDictionary<Type, ImporterFunc>> custom_importers_table;

        private static readonly IDictionary<Type, ArrayMetadata> array_metadata;
        private static readonly ReaderWriterLockSlim array_metadata_lock = new();

        private static readonly IDictionary<Type,
                Dictionary<Type, MethodInfo>> conv_ops;
        private static readonly ReaderWriterLockSlim conv_ops_lock = new();

        private static readonly IDictionary<Type, ObjectMetadata> object_metadata;
        private static readonly ReaderWriterLockSlim object_metadata_lock = new();

        private static readonly IDictionary<Type,
                List<PropertyMetadata>> type_properties;
        private static readonly ReaderWriterLockSlim type_properties_lock = new();

        [ThreadStatic]
        private static JsonWriter static_writer;

        private static ConcurrentStack<JsonReader> _readerPool = new ConcurrentStack<JsonReader>();

        private static ConcurrentDictionary<ReadOnlyMemory<char>, string> _stringInstanceCache = new ConcurrentDictionary<ReadOnlyMemory<char>, string>(ReadOnlyMemoryCharEqualityComparer.Comparer);

        [ThreadStatic]
        private static char[] _tmpProperty;

        private static Type int_type;
        private static Type long_type;
        private static Type ulong_type;
        private static Type bool_type;
        private static Type double_type;
        private static Type string_type;
        private static Type nullable_type;
        #endregion


        #region Constructors
        static JsonMapper()
        {
            max_nesting_depth = 100;

            array_metadata = new Dictionary<Type, ArrayMetadata>();
            conv_ops = new Dictionary<Type, Dictionary<Type, MethodInfo>>();
            object_metadata = new Dictionary<Type, ObjectMetadata>();
            type_properties = new Dictionary<Type,
                            List<PropertyMetadata>>();

            datetime_format = DateTimeFormatInfo.InvariantInfo;

            base_exporters_table = new Dictionary<Type, ExporterFunc>();
            custom_exporters_table = new Dictionary<Type, ExporterFunc>();

            base_importers_table = new Dictionary<Type,
                                 IDictionary<Type, ImporterFunc>>();
            custom_importers_table = new Dictionary<Type,
                                   IDictionary<Type, ImporterFunc>>();

            int_type = typeof(int);
            long_type = typeof(long);
            ulong_type = typeof(ulong);
            bool_type = typeof(bool);
            double_type = typeof(double);
            string_type = typeof(string);
            nullable_type = typeof(Nullable<>);

            RegisterBaseExporters();
            RegisterBaseImporters();
        }
        #endregion

        #region Private Helper Mehtods

        private static bool HasInterface(Type type, string name)
        {
#if NET_4_6
            Type[] interfaces = type.GetInterfaces();
            foreach (var iface in interfaces)
            {
                if (iface.FullName.Equals(name, StringComparison.OrdinalIgnoreCase))
                    return true;
            }

            return false;
#else
            return type.GetInterface(name, true) != null;
#endif
        }

        public static PropertyInfo[] GetPublicInstanceProperties(Type type)
        {
            return type.GetProperties();
        }

        #endregion

        #region Private Methods
        private static ArrayMetadata AddArrayMetadata(Type type)
        {
            ArrayMetadata data = default;
            if (array_metadata.TryGetValue(type, out data))
                return data;

            data = new ArrayMetadata();

            data.IsArray = type.IsArray;
            data.IsList = HasInterface(type, "System.Collections.IList");

            foreach (PropertyInfo p_info in GetPublicInstanceProperties(type))
            {
                if (p_info.Name != "Item")
                    continue;

                ParameterInfo[] parameters = p_info.GetIndexParameters();

                if (parameters.Length != 1)
                    continue;

                if (parameters[0].ParameterType == int_type)
                    data.ElementType = p_info.PropertyType;
            }

            using (new WriteLock(array_metadata_lock))
            {
                try
                {
                    array_metadata.Add(type, data);
                }
                catch (ArgumentException)
                {
                    // ??
                }
            }

            return data;
        }

        private static ObjectMetadata AddObjectMetadata(Type type)
        {
            ObjectMetadata data;
            if (object_metadata.TryGetValue(type, out data))
                return data;

            data = new ObjectMetadata();
            data.IsDictionary = HasInterface(type, "System.Collections.IDictionary");

            data.Properties = new Dictionary<ReadOnlyMemory<char>, PropertyMetadata>(ReadOnlyMemoryCharEqualityComparer.Comparer);

            foreach (PropertyInfo p_info in GetPublicInstanceProperties(type))
            {
                if (p_info.Name == "Item")
                {
                    ParameterInfo[] parameters = p_info.GetIndexParameters();

                    if (parameters.Length != 1)
                        continue;

                    if (parameters[0].ParameterType == string_type)
                        data.ElementType = p_info.PropertyType;

                    continue;
                }

                PropertyMetadata p_data = new PropertyMetadata();
                p_data.Info = p_info;
                p_data.Type = p_info.PropertyType;

                data.Properties.Add(p_info.Name.AsMemory(), p_data);
            }

            foreach (FieldInfo f_info in type.GetFields())
            {
                if (!data.Properties.TryGetValue(f_info.Name.AsMemory(), out var p_data))
                {
                    p_data = new PropertyMetadata();
                    p_data.Info = f_info;
                    p_data.IsField = true;
                    p_data.Type = f_info.FieldType;

                    data.Properties.Add(f_info.Name.AsMemory(), p_data);
                }
            }

            using (new WriteLock(object_metadata_lock))
            {
                try
                {
                    object_metadata.Add(type, data);
                }
                catch (ArgumentException)
                {
                    // ??
                }
            }

            return data;
        }

        private static List<PropertyMetadata> AddTypeProperties(Type type)
        {
            List<PropertyMetadata> props;
            if (type_properties.TryGetValue(type, out props))
                return props;

            props = new List<PropertyMetadata>();

            foreach (PropertyInfo p_info in GetPublicInstanceProperties(type))
            {
                if (p_info.Name == "Item")
                    continue;

                PropertyMetadata p_data = new PropertyMetadata();
                p_data.Info = p_info;
                p_data.IsField = false;
                props.Add(p_data);
            }

            foreach (FieldInfo f_info in type.GetFields())
            {
                PropertyMetadata p_data = new PropertyMetadata();
                p_data.Info = f_info;
                p_data.IsField = true;

                props.Add(p_data);
            }

            using (new WriteLock(type_properties_lock))
            {
                try
                {
                    type_properties.Add(type, props);
                }
                catch (ArgumentException)
                {
                    // ??
                }
            }

            return props;
        }

        private static MethodInfo GetConvOp(Type t1, Type t2)
        {
            Dictionary<Type, MethodInfo> ops;
            using (new WriteLock(conv_ops_lock))
            {
                if (!conv_ops.TryGetValue(t1, out ops))
                    conv_ops.Add(t1, ops = new Dictionary<Type, MethodInfo>());
            }

            MethodInfo op;
            if (conv_ops[t1].TryGetValue(t2, out op))
                return op;

            op = t1.GetMethod("op_Implicit", new Type[] { t2 });

            using (new WriteLock(conv_ops_lock))
            {
                try
                {
                    conv_ops[t1].Add(t2, op);
                }
                catch (ArgumentException)
                {
                    return conv_ops[t1][t2];
                }
            }

            return op;
        }

        private static bool TryReadInt(Type inst_type, JsonReader reader, out int value)
        {
            value = 0;

            if (reader.Token != JsonToken.Int)
                return false;

            value = reader.ValueInt;
            return true;
        }

        private static bool TryReadLong(Type inst_type, JsonReader reader, out long value)
        {
            value = 0;

            if (reader.Token != JsonToken.Long)
                return false;

            value = reader.ValueLong;
            return true;
        }

        private static bool TryReadULong(Type inst_type, JsonReader reader, out ulong value)
        {
            value = 0;

            if (reader.Token != JsonToken.ULong)
                return false;

            value = reader.ValueULong;
            return true;
        }

        private static bool TryReadDouble(Type inst_type, JsonReader reader, out double value)
        {
            value = 0;

            if (reader.Token != JsonToken.Double)
                return false;

            value = reader.ValueDouble;
            return true;
        }

        private static bool TryReadBool(Type inst_type, JsonReader reader, out bool value)
        {
            value = false;

            if (reader.Token != JsonToken.Boolean)
                return false;

            value = reader.ValueBool;
            return true;
        }

        private static unsafe object ReadValue(Type inst_type, JsonReader reader, bool skipRead = false)
        {
            if (!skipRead)
                reader.Read();

            if (reader.Token == JsonToken.ArrayEnd)
                return null;

            Type underlying_type = inst_type.IsGenericType && inst_type.GetGenericTypeDefinition() == nullable_type ? Nullable.GetUnderlyingType(inst_type) : null;
            Type value_type = underlying_type ?? inst_type;

            if (reader.Token == JsonToken.Null)
            {
                if (inst_type.IsClass || underlying_type != null)
                    return null;

                throw new JsonException(String.Format(
                        "Can't assign null to an instance of type {0}",
                        inst_type));
            }

            if (reader.Token == JsonToken.Double ||
                reader.Token == JsonToken.Int ||
                reader.Token == JsonToken.Long ||
                reader.Token == JsonToken.ULong ||
                reader.Token == JsonToken.String ||
                reader.Token == JsonToken.Boolean)
            {
                object value = null;
                Type json_type = null;// reader.Value.GetType();
                switch (reader.Token)
                {
                    case JsonToken.Int: json_type = int_type; value = reader.ValueInt; break;
                    case JsonToken.Long: json_type = long_type; value = reader.ValueLong; break;
                    case JsonToken.ULong: json_type = ulong_type; value = reader.ValueULong; break;
                    case JsonToken.Boolean: json_type = bool_type; value = reader.ValueBool; break;
                    case JsonToken.Double: json_type = double_type; value = reader.ValueDouble; break;
                    case JsonToken.String: json_type = string_type; value = GetStringInstance(reader.ValueString); break;
                }

                if (value_type.IsAssignableFrom(json_type))
                    return value;

                // If there's a custom importer that fits, use it
                if (custom_importers_table.TryGetValue(json_type, out var typeTable) &&
                    typeTable.TryGetValue(value_type, out var cutomImporter))
                {
                    return cutomImporter(value);
                }

                // Maybe there's a base importer that works
                if (base_importers_table.TryGetValue(json_type, out var importersTable) &&
                    importersTable.TryGetValue(value_type, out var importersImporter))
                {
                    return importersImporter(value);
                }

                // Maybe it's an enum
                if (value_type.IsEnum)
                {
                    if (reader.Token == JsonToken.String)
                        return Enum.Parse(value_type, value.ToString(), true);

                    return Enum.ToObject(value_type, value);
                }

                // Try using an implicit conversion operator
                MethodInfo conv_op = GetConvOp(value_type, json_type);

                if (conv_op != null)
                    return conv_op.Invoke(null, new object[] { value });

                // No luck
                throw new JsonException($"Can't assign value '{value}' (type {json_type}) to type {inst_type}");
            }

            object instance = null;

            if (reader.Token == JsonToken.ArrayStart)
            {

                //if (inst_type.FullName == "System.Object")
                if (inst_type == typeof(System.Object))
                    inst_type = typeof(object[]);

                ArrayMetadata t_data = AddArrayMetadata(inst_type);

                if (!t_data.IsArray && !t_data.IsList)
                    throw new JsonException(String.Format(
                            "Type {0} can't act as an array",
                            inst_type));

                IList list;
                Type elem_type;

                if (!t_data.IsArray)
                {
                    //list = (IList)Activator.CreateInstance(inst_type);
                    list = (IList)GetInstance(inst_type);
                    elem_type = t_data.ElementType;
                }
                else
                {
                    list = new System.Collections.Generic.List<object>();
                    elem_type = inst_type.GetElementType();
                }

                list.Clear();

                while (true)
                {
                    object item = ReadValue(elem_type, reader);
                    if (item == null && reader.Token == JsonToken.ArrayEnd)
                        break;

                    list.Add(item);
                }

                if (t_data.IsArray)
                {
                    int n = list.Count;
                    instance = Array.CreateInstance(elem_type, n);

                    for (int i = 0; i < n; i++)
                        ((Array)instance).SetValue(list[i], i);
                }
                else
                    instance = list;

            }
            else if (reader.Token == JsonToken.ObjectStart || reader.Token == JsonToken.PropertyName)
            {

                if (inst_type == typeof(System.Object))
                    value_type = inst_type = typeof(Dictionary<string, object>);

                ObjectMetadata t_data = AddObjectMetadata(value_type);

                //instance = Activator.CreateInstance(value_type);
                instance = GetInstance(value_type);
                var fastSetter = instance as IFastSetter;

                while (true)
                {
                    if (reader.Token != JsonToken.PropertyName)
                        reader.Read();

                    if (reader.Token == JsonToken.ObjectEnd)
                        break;

                    if (fastSetter != null)
                    {
                        if (_tmpProperty == null || _tmpProperty.Length < reader.ValueString.Length)
                            _tmpProperty = new char[reader.ValueString.Length];

                        reader.ValueString.CopyTo(_tmpProperty);

                        Span<char> prop = stackalloc char[reader.ValueString.Length];
                        _tmpProperty.AsSpan(0, reader.ValueString.Length).CopyTo(prop);

                        reader.Read();

                        switch (reader.Token)
                        {
                            case JsonToken.Int:
                                if (TryReadInt(inst_type, reader, out var value_int))
                                    fastSetter.SetInteger(prop, value_int);
                                break;

                            case JsonToken.Long:
                                if (TryReadLong(inst_type, reader, out var value_long))
                                    fastSetter.SetInteger(prop, value_long);
                                break;

                            case JsonToken.ULong:
                                if (TryReadULong(inst_type, reader, out var value_ulong))
                                {
                                    if (value_ulong > (ulong)long.MaxValue)
                                        throw new JsonException($"Can't call SetInteger for property '{new string(prop)}', because value_long({value_ulong}) is larger than long.MaxValue!");

                                    fastSetter.SetInteger(prop, (long)value_ulong);
                                }
                                break;

                            case JsonToken.Double:
                                if (TryReadDouble(inst_type, reader, out var value_double))
                                    fastSetter.SetDouble(prop, value_double);
                                break;

                            case JsonToken.Boolean:
                                if (TryReadBool(inst_type, reader, out var value_bool))
                                    fastSetter.SetBool(prop, value_bool);
                                break;

                            case JsonToken.ObjectStart:
                                reader.Read();
                                goto default;

                            default:
                                if (t_data.Properties.TryGetValue(_tmpProperty.AsMemory(0, prop.Length), out var prop_meta_data))
                                {
                                    fastSetter.SetOther(prop, ReadValue(prop_meta_data.Type, reader, reader.Token != JsonToken.ObjectStart));
                                }
                                else
                                    ReadSkip(reader);

                                break;
                        }
                    }
                    else if (!t_data.IsDictionary && t_data.Properties.TryGetValue(reader.ValueString, out var prop_data))
                    {
                        try
                        {
                            if (prop_data.IsField)
                            {
                                ((FieldInfo)prop_data.Info).SetValue(
                                    instance, ReadValue(prop_data.Type, reader));
                            }
                            else
                            {
                                PropertyInfo p_info =
                                    (PropertyInfo)prop_data.Info;

                                if (p_info.CanWrite)
                                    p_info.SetValue(
                                        instance,
                                        ReadValue(prop_data.Type, reader),
                                        null);
                                else
                                    ReadValue(prop_data.Type, reader);
                            }
                        }
                        catch (JsonException ex)
                        {
                            throw new JsonException($"While parsing property '{new string(reader.ValueString.Span)}': {ex.Message}");
                        }

                    }
                    else
                    {
                        if (!t_data.IsDictionary)
                        {

                            if (!reader.SkipNonMembers)
                            {
                                throw new JsonException(String.Format(
                                        "The type {0} doesn't have the " +
                                        "property '{1}'",
                                        inst_type, new string(reader.ValueString.Span)));
                            }
                            else
                            {
                                ReadSkip(reader);
                                continue;
                            }
                        }

                        try
                        {
                            ((IDictionary)instance).Add(
                                GetStringInstance(reader.ValueString), ReadValue(
                                    t_data.ElementType, reader));
                        }
                        catch (JsonException ex)
                        {
                            throw new JsonException($"While parsing property '{new string(reader.ValueString.Span)}': {ex.Message}");
                        }
                    }

                }

            }

            return instance;
        }

        private static IJsonWrapper ReadValue(WrapperFactory factory,
                                               JsonReader reader)
        {
            reader.Read();

            if (reader.Token == JsonToken.ArrayEnd ||
                reader.Token == JsonToken.Null)
                return null;

            IJsonWrapper instance = factory?.Invoke();

            if (reader.Token == JsonToken.String)
            {
                instance?.SetString(new string(reader.ValueString.Span));
                return instance;
            }

            if (reader.Token == JsonToken.Double)
            {
                instance?.SetDouble(reader.ValueDouble);
                return instance;
            }

            if (reader.Token == JsonToken.Int)
            {
                instance?.SetInt(reader.ValueInt);
                return instance;
            }

            if (reader.Token == JsonToken.Long)
            {
                instance?.SetLong(reader.ValueLong);
                return instance;
            }

            if (reader.Token == JsonToken.Boolean)
            {
                instance?.SetBoolean(reader.ValueBool);
                return instance;
            }

            if (reader.Token == JsonToken.ArrayStart)
            {
                instance?.SetJsonType(JsonType.Array);

                while (true)
                {
                    IJsonWrapper item = ReadValue(factory, reader);
                    if (item == null && reader.Token == JsonToken.ArrayEnd)
                        break;

                    if (instance != null)
                        ((IList)instance).Add(item);
                }
            }
            else if (reader.Token == JsonToken.ObjectStart)
            {
                instance?.SetJsonType(JsonType.Object);

                while (true)
                {
                    reader.Read();

                    if (reader.Token == JsonToken.ObjectEnd)
                        break;

                    string property = new string(reader.ValueString.Span);

                    if (instance != null)
                        ((IDictionary)instance)[property] = ReadValue(factory, reader);
                }

            }

            return instance;
        }

        private static void ReadSkip(JsonReader reader)
        {
            ToWrapper(null, reader);
        }

        private static void RegisterBaseExporters()
        {
            base_exporters_table[typeof(byte)] =
                delegate (object obj, JsonWriter writer)
                {
                    writer.Write(Convert.ToInt32((byte)obj));
                };

            base_exporters_table[typeof(char)] =
                delegate (object obj, JsonWriter writer)
                {
                    writer.Write(Convert.ToString((char)obj));
                };

            base_exporters_table[typeof(DateTime)] =
                delegate (object obj, JsonWriter writer)
                {
                    writer.Write(Convert.ToString((DateTime)obj,
                                                    datetime_format));
                };

            base_exporters_table[typeof(decimal)] =
                delegate (object obj, JsonWriter writer)
                {
                    writer.Write((decimal)obj);
                };

            base_exporters_table[typeof(sbyte)] =
                delegate (object obj, JsonWriter writer)
                {
                    writer.Write(Convert.ToInt32((sbyte)obj));
                };

            base_exporters_table[typeof(short)] =
                delegate (object obj, JsonWriter writer)
                {
                    writer.Write(Convert.ToInt32((short)obj));
                };

            base_exporters_table[typeof(ushort)] =
                delegate (object obj, JsonWriter writer)
                {
                    writer.Write(Convert.ToInt32((ushort)obj));
                };

            base_exporters_table[typeof(uint)] =
                delegate (object obj, JsonWriter writer)
                {
                    writer.Write(Convert.ToUInt64((uint)obj));
                };

            base_exporters_table[typeof(ulong)] =
                delegate (object obj, JsonWriter writer)
                {
                    writer.Write((ulong)obj);
                };

            base_exporters_table[typeof(DateTimeOffset)] =
                delegate (object obj, JsonWriter writer)
                {
                    writer.Write(((DateTimeOffset)obj).ToString("yyyy-MM-ddTHH:mm:ss.fffffffzzz", datetime_format));
                };
        }

        private static void RegisterBaseImporters()
        {
            ImporterFunc importer;

            importer = delegate (object input)
            {
                return Convert.ToByte((int)input);
            };
            RegisterImporter(base_importers_table, typeof(int),
                              typeof(byte), importer);

            importer = delegate (object input)
            {
                return Convert.ToUInt64((int)input);
            };
            RegisterImporter(base_importers_table, typeof(int),
                              typeof(ulong), importer);

            importer = delegate (object input)
            {
                return Convert.ToInt64((int)input);
            };
            RegisterImporter(base_importers_table, typeof(int),
                              typeof(long), importer);

            importer = delegate (object input)
            {
                return Convert.ToSByte((int)input);
            };
            RegisterImporter(base_importers_table, typeof(int),
                              typeof(sbyte), importer);

            importer = delegate (object input)
            {
                return Convert.ToInt16((int)input);
            };
            RegisterImporter(base_importers_table, typeof(int),
                              typeof(short), importer);

            importer = delegate (object input)
            {
                return Convert.ToUInt16((int)input);
            };
            RegisterImporter(base_importers_table, typeof(int),
                              typeof(ushort), importer);

            importer = delegate (object input)
            {
                return Convert.ToUInt32((int)input);
            };
            RegisterImporter(base_importers_table, typeof(int),
                              typeof(uint), importer);

            importer = delegate (object input)
            {
                return Convert.ToSingle((int)input);
            };
            RegisterImporter(base_importers_table, typeof(int),
                              typeof(float), importer);

            importer = delegate (object input)
            {
                return Convert.ToDouble((int)input);
            };
            RegisterImporter(base_importers_table, typeof(int),
                              typeof(double), importer);

            importer = delegate (object input)
            {
                return Convert.ToDecimal((double)input);
            };
            RegisterImporter(base_importers_table, typeof(double),
                              typeof(decimal), importer);

            importer = delegate (object input)
            {
                return Convert.ToSingle((double)input);
            };
            RegisterImporter(base_importers_table, typeof(double),
                typeof(float), importer);

            importer = delegate (object input)
            {
                return Convert.ToUInt32((long)input);
            };
            RegisterImporter(base_importers_table, typeof(long),
                              typeof(uint), importer);

            importer = delegate (object input)
            {
                return Convert.ToChar((string)input);
            };
            RegisterImporter(base_importers_table, typeof(string),
                              typeof(char), importer);

            importer = delegate (object input)
            {
                return Convert.ToDateTime((string)input, datetime_format);
            };
            RegisterImporter(base_importers_table, typeof(string),
                              typeof(DateTime), importer);

            importer = delegate (object input)
            {
                return DateTimeOffset.Parse((string)input, datetime_format);
            };
            RegisterImporter(base_importers_table, typeof(string),
                typeof(DateTimeOffset), importer);
        }

        private static void RegisterImporter(
            IDictionary<Type, IDictionary<Type, ImporterFunc>> table,
            Type json_type, Type value_type, ImporterFunc importer)
        {
            if (!table.TryGetValue(json_type, out var importerTable))
                table.Add(json_type, importerTable = new Dictionary<Type, ImporterFunc>());

            importerTable[value_type] = importer;
        }

        private static void WriteValue(object obj, JsonWriter writer,
                                        bool writer_is_private,
                                        int depth)
        {
            if (depth > max_nesting_depth)
                throw new JsonException(
                    String.Format("Max allowed object depth reached while " +
                                   "trying to export from type {0}",
                                   obj.GetType()));

            if (obj == null)
            {
                writer.Write(null);
                return;
            }

            if (obj is IJsonWrapper)
            {
                if (writer_is_private)
                    writer.TextWriter.Write(((IJsonWrapper)obj).ToJson());
                else
                    ((IJsonWrapper)obj).ToJson(writer);

                return;
            }

            if (obj is String)
            {
                writer.Write((string)obj);
                return;
            }

            if (obj is Double)
            {
                writer.Write((double)obj);
                return;
            }

            if (obj is Single)
            {
                writer.Write((float)obj);
                return;
            }

            if (obj is Int32)
            {
                writer.Write((int)obj);
                return;
            }

            if (obj is Boolean)
            {
                writer.Write((bool)obj);
                return;
            }

            if (obj is Int64)
            {
                writer.Write((long)obj);
                return;
            }

            if (obj is Array)
            {
                writer.WriteArrayStart();

                foreach (object elem in (Array)obj)
                    WriteValue(elem, writer, writer_is_private, depth + 1);

                writer.WriteArrayEnd();

                return;
            }

            if (obj is IList)
            {
                writer.WriteArrayStart();
                foreach (object elem in (IList)obj)
                    WriteValue(elem, writer, writer_is_private, depth + 1);
                writer.WriteArrayEnd();

                return;
            }

            var iDictionary = obj as IDictionary;
            if (iDictionary != null)
            {
                writer.WriteObjectStart();
                foreach (DictionaryEntry entity in iDictionary)
                {
                    var propertyName = entity.Key as string ?? Convert.ToString(entity.Key, CultureInfo.InvariantCulture);
                    writer.WritePropertyName(propertyName);
                    WriteValue(entity.Value, writer, writer_is_private,
                                depth + 1);
                }
                writer.WriteObjectEnd();

                return;
            }

            Type obj_type = obj.GetType();

            // See if there's a custom exporter for the object
            if (custom_exporters_table.TryGetValue(obj_type, out var customExporter))
            {
                customExporter(obj, writer);

                return;
            }

            // If not, maybe there's a base exporter
            if (base_exporters_table.TryGetValue(obj_type, out var baseExporter))
            {
                baseExporter(obj, writer);

                return;
            }

            // Last option, let's see if it's an enum
            if (obj is Enum)
            {
                //Type e_type = Enum.GetUnderlyingType (obj_type);

                try
                {
                    /*if (e_type == long_type
                        || e_type == typeof(uint)
                        || e_type == ulong_type)
                        writer.Write((ulong)obj);
                    else if (e_type == typeof(byte))
                        writer.Write((byte)obj);
                    else
                        writer.Write((int)obj);*/
                    writer.Write(Convert.ToInt32(obj));
                }
                catch //(InvalidCastException ex)
                {
                    throw new InvalidCastException($"Failed to cast {obj_type.Name}.'{obj}' of type '{Enum.GetUnderlyingType(obj_type).Name}'!");
                }

                return;
            }

            // Okay, so it looks like the input should be exported as an
            // object
            List<PropertyMetadata> props = AddTypeProperties(obj_type);

            writer.WriteObjectStart();
            foreach (PropertyMetadata p_data in props)
            {
                if (p_data.IsField)
                {
                    writer.WritePropertyName(p_data.Info.Name);
                    WriteValue(((FieldInfo)p_data.Info).GetValue(obj),
                                writer, writer_is_private, depth + 1);
                }
                else
                {
                    PropertyInfo p_info = (PropertyInfo)p_data.Info;

                    if (p_info.CanRead)
                    {
                        writer.WritePropertyName(p_data.Info.Name);
                        WriteValue(p_info.GetValue(obj, null),
                                    writer, writer_is_private, depth + 1);
                    }
                }
            }
            writer.WriteObjectEnd();
        }
        #endregion


        public static string ToJson(object obj)
        {
            static_writer ??= new JsonWriter();
            static_writer.Reset();

            WriteValue(obj, static_writer, true, 0);

            return static_writer.ToString();
        }

        public static void ToJson(object obj, JsonWriter writer)
        {
            WriteValue(obj, writer, false, 0);
        }

        public static JsonData ToObject(JsonReader reader)
        {
            return (JsonData)ToWrapper(
                delegate { return new JsonData(); }, reader);
        }

        public static object ToObject(Type toType, JsonReader reader)
        {
            return ReadValue(toType, reader);
        }

        public static JsonData ToObject(TextReader reader)
        {
            JsonReader json_reader = new JsonReader(reader);

            return (JsonData)ToWrapper(
                delegate { return new JsonData(); }, json_reader);
        }

        public static JsonData ToObject(string json)
        {
            return (JsonData)ToWrapper(
                delegate { return new JsonData(); }, json);
        }

        public static T ToObject<T>(JsonReader reader)
        {
            return (T)ReadValue(typeof(T), reader);
        }

        public static T ToObject<T>(TextReader reader)
        {
            JsonReader json_reader = new JsonReader(reader);

            return (T)ReadValue(typeof(T), json_reader);
        }

        public static T ToObject<T>(string json)
        {
            JsonReader reader = null;
            if (_readerPool.TryPop(out reader))
                reader.SetJson(json);
            else
                reader = new JsonReader(json, true);

            try
            {
                return (T)ReadValue(typeof(T), reader);
            }
            finally
            {
                _readerPool.Push(reader);
            }
        }

        public static object ToObject(Type toType, string json)
        {
            JsonReader reader = new JsonReader(json);

            return ReadValue(toType, reader);
        }

        public static IJsonWrapper ToWrapper(WrapperFactory factory,
                                              JsonReader reader)
        {
            return ReadValue(factory, reader);
        }

        public static IJsonWrapper ToWrapper(WrapperFactory factory,
                                              string json)
        {
            JsonReader reader = new JsonReader(json);

            return ReadValue(factory, reader);
        }

        public static void RegisterExporter<T>(ExporterFunc<T> exporter)
        {
            ExporterFunc exporter_wrapper =
                delegate (object obj, JsonWriter writer)
                {
                    exporter((T)obj, writer);
                };

            custom_exporters_table[typeof(T)] = exporter_wrapper;
        }

        public static void RegisterImporter<TJson, TValue>(
            ImporterFunc<TJson, TValue> importer)
        {
            ImporterFunc importer_wrapper =
                delegate (object input)
                {
                    return importer((TJson)input);
                };

            RegisterImporter(custom_importers_table, typeof(TJson),
                              typeof(TValue), importer_wrapper);
        }

        private static System.Func<Type, object> _instanceProvider;
        public static void RegisterInstanceProvider(System.Func<Type, object> provider)
        {
            _instanceProvider = provider;
        }

        public static void RegisterStringCache(string str)
        {
            _stringInstanceCache.TryAdd(str.AsMemory(), str);
        }

        public static string GetStringInstance(ReadOnlyMemory<char> chars)
        {
            if (_stringInstanceCache.TryGetValue(chars, out var value))
                return value;

            return new string(chars.Span);
        }

        public static object GetInstance(Type type)
        {
            var provider = _instanceProvider;
            object result = null;

            if (provider != null)
                result = provider(type);

            if (result == null)
                result = Activator.CreateInstance(type);

            return result;
        }

        public static void UnregisterExporters()
        {
            custom_exporters_table.Clear();
        }

        public static void UnregisterImporters()
        {
            custom_importers_table.Clear();
        }
    }
}