BadJson.cs

Go to the documentation of this file.

using BadScript2.Runtime.Interop.Reflection.Objects;
using BadScript2.Runtime.Objects;
using BadScript2.Runtime.Objects.Functions;
using BadScript2.Runtime.Objects.Native;
 
using Newtonsoft.Json.Linq;
 
namespace BadScript2.Interop.Json;
 
public static class BadJson
{
    public static BadRuntime UseJsonApi(this BadRuntime runtime)
    {
        return runtime.UseApi(new BadJsonApi(), true);
    }
 
    private static BadArray ConvertArray(JArray array)
    {
        List<BadObject> a = array.Where(x => x != null)
                                 .Select(ConvertNode)
                                 .ToList();
 
        return new BadArray(a);
    }
 
    private static BadTable ConvertObject(JObject obj)
    {
        Dictionary<string, BadObject> t = new Dictionary<string, BadObject>();
 
        foreach (KeyValuePair<string, JToken?> keyValuePair in obj)
        {
            t.Add(keyValuePair.Key, keyValuePair.Value == null ? BadObject.Null : ConvertNode(keyValuePair.Value));
        }
 
        return new BadTable(t);
    }
 
    public static JToken ConvertNode(BadObject value)
    {
        if (value == BadObject.Null)
        {
            return JValue.CreateNull();
        }
 
        return value switch
        {
            IBadString s          => new JValue(s.Value),
            IBadNumber n          => new JValue(n.Value),
            IBadBoolean b         => new JValue(b.Value),
            BadArray a            => ConvertArray(a),
            BadTable t            => ConvertTable(t),
            BadReflectedObject ro => JToken.FromObject(ro.Instance),
            BadFunction f         => new JValue(f.ToSafeString()),
            _                     => throw new Exception("Unsupported value type: " + value.GetType()),
        };
    }
 
    private static JObject ConvertTable(BadTable table)
    {
        JObject obj = new JObject();
 
        foreach (KeyValuePair<string, BadObject> keyValuePair in table.InnerTable)
        {
            obj.Add(keyValuePair.Key, ConvertNode(keyValuePair.Value));
        }
 
        return obj;
    }
 
    private static JArray ConvertArray(BadArray value)
    {
        JArray array = new JArray();
 
        foreach (BadObject node in value.InnerArray)
        {
            array.Add(ConvertNode(node));
        }
 
        return array;
    }
 
    private static BadObject ConvertValue(JValue value)
    {
        switch (value.Type)
        {
            case JTokenType.Integer:
                if (value.Value is int i)
                {
                    return i;
                }
                if(value.Value is byte b)
                {
                    return b;
                }
                if(value.Value is sbyte sb)
                {
                    return sb;
                }
                if(value.Value is short s)
                {
                    return s;
                }
                if(value.Value is ushort us)
                {
                    return us;
                }
                if(value.Value is uint ui)
                {
                    return ui;
                }
                if(value.Value is long l)
                {
                    return l;
                }
                if(value.Value is ulong ul)
                {
                    return ul;
                }
 
                return (long)value.Value!;
            case JTokenType.Float:
                return value.Value switch
                {
                    float f   => (decimal)f,
                    decimal d => d,
                    _         => (decimal)(double)value.Value!,
                };
 
            case JTokenType.String:
                return (string)value.Value!;
            case JTokenType.Boolean:
                return (bool)value.Value!;
            case JTokenType.Guid:
                return value.Value!.ToString();
            case JTokenType.Date:
                return value.Value<DateTime>()
                            .ToString("O");
            case JTokenType.Null:
                return BadObject.Null;
            case JTokenType.None:
            case JTokenType.Object:
            case JTokenType.Array:
            case JTokenType.Constructor:
            case JTokenType.Property:
            case JTokenType.Comment:
            case JTokenType.Undefined:
            case JTokenType.Raw:
            case JTokenType.Bytes:
            case JTokenType.Uri:
            case JTokenType.TimeSpan:
            default:
                throw new Exception("Unsupported Json type: " + value.Type);
        }
    }
 
    public static BadObject ConvertNode(JToken? node)
    {
        return node switch
        {
            null      => BadObject.Null,
            JArray a  => ConvertArray(a),
            JObject o => ConvertObject(o),
            JValue v  => ConvertValue(v),
            _         => throw new Exception("Unsupported node type: " + node.GetType()),
        };
    }
 
    public static BadObject FromJson(string s)
    {
        JToken o = JToken.Parse(s);
 
        return ConvertNode(o);
    }
 
    public static string ToJson(BadObject o)
    {
        JToken token = ConvertNode(o);
 
        return token.ToString();
    }
}