BadSettingsObject.cs

Go to the documentation of this file.

using BadScript2.Common;
using BadScript2.Runtime;
using BadScript2.Runtime.Error;
using BadScript2.Runtime.Interop;
using BadScript2.Runtime.Interop.Functions;
using BadScript2.Runtime.Objects;
using BadScript2.Runtime.Objects.Types;
using BadScript2.Settings;
 
namespace BadScript2.Interop.Json;
 
public class BadSettingsObject : BadObject
{
    public static readonly BadClassPrototype Prototype =
        new BadNativeClassPrototype<BadSettingsObject>("BadSettings", (_, args) => CreateObj(args));
 
    private readonly Dictionary<string, BadObjectReference> m_PropertyReferences;
 
    private readonly BadSettings m_Settings;
 
    public BadSettingsObject(BadSettings settings)
    {
        m_Settings = settings;
        Dictionary<string, BadObject> properties = new Dictionary<string, BadObject>
        {
            {
                "HasValue",
                new BadDynamicInteropFunction(
                    "HasValue",
                    _ => m_Settings.HasValue(),
                    BadNativeClassBuilder.GetNative("bool")
                )
            },
            {
                "GetValue",
                new BadDynamicInteropFunction(
                    "GetValue",
                    _ => BadJson.ConvertNode(m_Settings.GetValue()),
                    BadAnyPrototype.Instance
                )
            },
            {
                "SetValue", new BadDynamicInteropFunction<BadObject>(
                    "SetValue",
                    (_, obj) =>
                    {
                        m_Settings.SetValue(BadJson.ConvertNode(obj));
 
                        return Null;
                    },
                    BadAnyPrototype.Instance
                )
            },
            {
                "HasProperty",
                new BadDynamicInteropFunction<string>(
                    "HasProperty",
                    (_, name) => m_Settings.HasProperty(name),
                    BadNativeClassBuilder.GetNative("bool")
                )
            },
            {
                "GetProperty", new BadDynamicInteropFunction<string>(
                    "GetProperty",
                    (_, name) => new BadSettingsObject(m_Settings.GetProperty(name)),
                    BadAnyPrototype.Instance
                )
            },
            {
                "FindProperty", new BadDynamicInteropFunction<string>(
                    "FindProperty",
                    (_, name) =>
                    {
                        BadSettings? obj = m_Settings.FindProperty(name);
 
                        return obj == null ? Null : new BadSettingsObject(obj);
                    },
                    BadAnyPrototype.Instance
                )
            },
            {
                "FindOrCreateProperty", new BadDynamicInteropFunction<string>(
                    "FindOrCreateProperty",
                    (_, name) =>
                    {
                        BadSettings obj = m_Settings.FindOrCreateProperty(name);
 
                        return new BadSettingsObject(obj);
                    },
                    BadAnyPrototype.Instance
                )
            },
            {
                "SetProperty", new BadDynamicInteropFunction<string, BadSettingsObject>(
                    "SetProperty",
                    (_, name, prop) =>
                    {
                        m_Settings.SetProperty(name, prop.m_Settings);
 
                        return Null;
                    },
                    BadAnyPrototype.Instance
                )
            },
            {
                "RemoveProperty", new BadDynamicInteropFunction<string>(
                    "RemoveProperty",
                    (_, name) => m_Settings.RemoveProperty(name),
                    BadNativeClassBuilder.GetNative("bool")
                )
            },
            {
                "GetPropertyNames", new BadDynamicInteropFunction(
                    "GetPropertyNames",
                    _ => new BadArray(m_Settings.PropertyNames.Select(x => (BadObject)x).ToList()),
                    BadNativeClassBuilder.GetNative("Array")
                )
            },
            {
                "GetEnumerator", new BadDynamicInteropFunction(
                    "GetEnumerator",
                    _ => new BadInteropEnumerator(m_Settings.PropertyNames.Select(x => (BadObject)x).GetEnumerator()),
                    BadAnyPrototype.Instance
                )
            },
            {
                BadStaticKeys.ARRAY_ACCESS_OPERATOR_NAME, new BadDynamicInteropFunction<string>(
                    BadStaticKeys.ARRAY_ACCESS_OPERATOR_NAME,
                    (_, name) => BadObjectReference.Make(
                        $"BadSettings.{name}",
                        () => new BadSettingsObject(m_Settings.GetProperty(name)),
                        (o, _) =>
                        {
                            if (o is not BadSettingsObject obj)
                            {
                                throw new BadRuntimeException("BadSettingsObject expected");
                            }
 
                            m_Settings.SetProperty(name, obj.m_Settings);
                        }
                    ),
                    BadAnyPrototype.Instance
                )
            },
        };
 
        m_PropertyReferences = new Dictionary<string, BadObjectReference>();
 
        foreach (KeyValuePair<string, BadObject> property in properties)
        {
            m_PropertyReferences.Add(
                property.Key,
                BadObjectReference.Make($"BadSettings.{property.Key}", () => properties[property.Key])
            );
        }
    }
 
    public override BadClassPrototype GetPrototype()
    {
        return Prototype;
    }
 
    private static BadObject CreateObj(IReadOnlyList<BadObject> args)
    {
        if (args.Count != 1)
        {
            return new BadSettingsObject(new BadSettings(string.Empty));
        }
 
        if (args[0] is not BadSettingsObject settings)
        {
            throw new BadRuntimeException("BadSettings expected");
        }
 
        return settings;
    }
 
    public override string ToSafeString(List<BadObject> done)
    {
        return m_Settings.ToString();
    }
 
    public override bool HasProperty(string propName, BadScope? caller = null)
    {
        return m_PropertyReferences.ContainsKey(propName) ||
               m_Settings.HasProperty(propName) ||
               base.HasProperty(propName, caller);
    }
 
    public override BadObjectReference GetProperty(string propName, BadScope? caller = null)
    {
        if (m_PropertyReferences.TryGetValue(propName, out BadObjectReference? property))
        {
            return property;
        }
 
        if (m_Settings.HasProperty(propName))
        {
            return BadObjectReference.Make(
                $"BadSettings.{propName}",
                () => new BadSettingsObject(m_Settings.GetProperty(propName))
            );
        }
 
        return base.GetProperty(propName, caller);
    }
}