BadSettings.cs

Go to the documentation of this file.

using System.Text;
 
using Newtonsoft.Json.Linq;
 
namespace BadScript2.Settings;
 
public class BadSettings
{
    private readonly Dictionary<string, BadSettings> m_Properties;
 
    private readonly string m_SourcePath;
 
    public bool HasSourcePath => !string.IsNullOrEmpty(m_SourcePath);
    public string SourcePath => m_SourcePath;
    
    private object? m_Cache;
 
    private bool m_IsDirty;
 
    private JToken? m_Value;
 
    public BadSettings(string sourcePath)
    {
        m_SourcePath = sourcePath;
        m_Value = null;
        m_IsDirty = true;
        m_Properties = new Dictionary<string, BadSettings>();
    }
 
    public BadSettings(JToken? value, string sourcePath)
    {
        m_Value = value;
        m_SourcePath = sourcePath;
        m_IsDirty = true;
        m_Properties = new Dictionary<string, BadSettings>();
    }
 
    public BadSettings(Dictionary<string, BadSettings> properties, string sourcePath)
    {
        m_Value = null;
        m_IsDirty = true;
        m_Properties = properties;
        m_SourcePath = sourcePath;
        foreach (KeyValuePair<string, BadSettings> kvp in m_Properties)
        {
            kvp.Value.OnValueChanged += PropertyValueChanged;
        }
    }
 
    public IEnumerable<string> PropertyNames => m_Properties.Keys;
 
    public event Action OnValueChanged = delegate { };
 
    private void PropertyValueChanged()
    {
        m_IsDirty = true;
        InvokeValueChanged();
    }
 
    private void InvokeValueChanged()
    {
        OnValueChanged();
    }
 
    public JToken? GetValue()
    {
        return m_Value;
    }
 
    public T? GetValue<T>()
    {
        if (!m_IsDirty)
        {
            return (T?)m_Cache;
        }
 
        if (m_Value == null)
        {
            return default;
        }
 
        T? v = m_Value.ToObject<T>();
 
        m_Cache = v;
        m_IsDirty = false;
 
        return v;
    }
 
    public bool HasValue()
    {
        return m_Value != null;
    }
 
    private bool HasValue<T>()
    {
        if (m_Value?.Type == JTokenType.Array && !typeof(T).IsArray)
        {
            return false;
        }
 
        return m_Value != null && m_Value.ToObject<T>() != null;
    }
 
    public void SetValue(JToken? value, bool invokeOnChange = true)
    {
        m_Value = value;
        if (invokeOnChange)
        {
            PropertyValueChanged();
        }
        else
        {
            m_IsDirty = true;
        }
    }
 
    private void SetValue(object? value)
    {
        SetValue(value == null ? JValue.CreateNull() : JToken.FromObject(value));
    }
 
    public bool HasProperty(string propertyName)
    {
        return m_Properties.ContainsKey(propertyName);
    }
 
    public BadSettings GetProperty(string propertyName)
    {
        return m_Properties[propertyName];
    }
 
    public void SetProperty(string propertyName, BadSettings value, bool invokeOnChange = true)
    {
        if (m_Properties.TryGetValue(propertyName, out BadSettings? old))
        {
            old.OnValueChanged -= PropertyValueChanged;
        }
 
        m_Properties[propertyName] = value;
        if (invokeOnChange)
        {
            PropertyValueChanged();
        }
        else
        {
            m_IsDirty = true;
        }
    }
 
    public bool RemoveProperty(string propertyName, bool invokeOnChange = true)
    {
        if (m_Properties.TryGetValue(propertyName, out BadSettings? old))
        {
            old.OnValueChanged -= PropertyValueChanged;
        }
 
        bool r = m_Properties.Remove(propertyName);
 
        if (invokeOnChange)
        {
            PropertyValueChanged();
        }
        else
        {
            m_IsDirty = true;
        }
 
        return r;
    }
 
 
    public void Populate(bool invokeOnChanged, params BadSettings[] settings)
    {
        if (m_Value is JArray arr)
        {
            foreach (BadSettings setting in settings)
            {
                if (!setting.HasValue())
                {
                    continue;
                }
 
                if (setting.GetValue() is JArray arr2)
                {
                    foreach (JToken jToken in arr2)
                    {
                        arr.Add(jToken);
                    }
                }
                else
                {
                    arr.Add(setting.GetValue() ?? JValue.CreateNull());
                }
            }
        }
 
        foreach (BadSettings setting in settings)
        {
            foreach (string propertyName in setting.PropertyNames)
            {
                if (HasProperty(propertyName))
                {
                    GetProperty(propertyName).Populate(false, setting.GetProperty(propertyName));
                }
                else
                {
                    SetProperty(propertyName, setting.GetProperty(propertyName), false);
                }
            }
        }
 
        if (invokeOnChanged)
        {
            PropertyValueChanged();
        }
        else
        {
            m_IsDirty = true;
        }
    }
 
    public T? FindProperty<T>(string propertyName) where T : class
    {
        BadSettings? settings = FindProperty(propertyName);
 
        return settings?.GetValue<T>();
    }
 
    public BadSettings FindOrCreateProperty(string propertyPath)
    {
        string[] path = propertyPath.Split('.');
        BadSettings current = this;
 
        foreach (string s in path)
        {
            if (!current.HasProperty(s))
            {
                BadSettings se = new BadSettings(string.Empty);
                current.SetProperty(s, se);
                current = se;
            }
            else
            {
                current = current.GetProperty(s);
            }
        }
 
        return current;
    }
 
    public BadSettings? FindProperty(string propertyPath)
    {
        string[] path = propertyPath.Split('.');
        BadSettings current = this;
 
        foreach (string s in path)
        {
            if (!current.HasProperty(s))
            {
                return null;
            }
 
            current = current.GetProperty(s);
        }
 
        return current;
    }
 
    public override string ToString()
    {
        if (HasValue())
        {
            return GetValue()?.ToString() ?? "NULL";
        }
 
        StringBuilder sb = new StringBuilder();
 
        sb.AppendLine("{");
 
        foreach (string propertyName in PropertyNames)
        {
            BadSettings s = GetProperty(propertyName);
            string str = s.ToString().Replace("\n", "\n\t");
            sb.AppendLine($"  {propertyName}: {str}");
        }
 
        sb.AppendLine("}");
 
        return sb.ToString();
    }
 
    private static string ResolveEnvironmentVariables(BadSettings root, BadSettings parent, string str)
    {
        for (int i = 0; i < str.Length; i++)
        {
            if (str[i] != '$' || i + 1 >= str.Length || str[i + 1] != '(')
            {
                continue;
            }
 
            int end = str.IndexOf(')', i + 2);
 
            if (end == -1)
            {
                throw new Exception("Unclosed environment variable");
            }
 
            string envVar = str.Substring(i + 2, end - i - 2);
 
            string? env = root.FindProperty<string>(envVar);
 
            if (env == null)
            {
                env = parent.FindProperty<string>(envVar);
 
                if (env == null)
                {
                    throw new Exception($"Environment variable '{envVar}' not found");
                }
            }
 
            str = str.Replace(str.Substring(i, end - i + 1), env);
            i--;
        }
 
        return str;
    }
 
    public static void ResolveEnvironmentVariables(BadSettings root)
    {
        ResolveEnvironmentVariables(root, root, root);
    }
 
    public static void ResolveEnvironmentVariables(BadSettings root, BadSettings settings, BadSettings parent)
    {
        if (settings.HasValue<string>())
        {
            string value = settings.GetValue<string>()!;
 
            settings.SetValue(ResolveEnvironmentVariables(root, parent, value));
        }
        else if (settings.HasValue<string[]>())
        {
            string[] value = settings.GetValue<string[]>()!;
 
            for (int i = 0; i < value.Length; i++)
            {
                value[i] = ResolveEnvironmentVariables(root, parent, value[i]);
            }
 
            settings.SetValue(value);
        }
 
        foreach (string propertyName in settings.PropertyNames)
        {
            ResolveEnvironmentVariables(root, settings.GetProperty(propertyName), settings);
        }
    }
}