Extended managed configuration (#560)

app/MindWork AI Studio/Settings/ManagedConfiguration.cs

@@ -4,62 +4,34 @@ using System.Linq.Expressions;
 using AIStudio.Settings.DataModel;
 using AIStudio.Tools.PluginSystem;
 
-using Lua;
-
 namespace AIStudio.Settings;
 
-public static class ManagedConfiguration
+public static partial class ManagedConfiguration
 {
     private static readonly ConcurrentDictionary<string, IConfig> METADATA = new();
-    
-    /// <summary>
-    /// Registers a configuration setting with a default value.
-    /// </summary>
-    /// <remarks>
-    /// When called from the JSON deserializer, the configSelection parameter will be null.
-    /// In this case, the method will return the default value without registering the setting.
-    /// </remarks>
-    /// <param name="configSelection">The expression to select the configuration class.</param>
-    /// <param name="propertyExpression">The expression to select the property within the configuration class.</param>
-    /// <param name="defaultValue">The default value to use when the setting is not configured.</param>
-    /// <typeparam name="TClass">The type of the configuration class.</typeparam>
-    /// <typeparam name="TValue">The type of the property within the configuration class.</typeparam>
-    /// <returns>The default value.</returns>
-    public static TValue Register<TClass, TValue>(Expression<Func<Data, TClass>>? configSelection, Expression<Func<TClass, TValue>> propertyExpression, TValue defaultValue)
-    {
-        // When called from the JSON deserializer by using the standard constructor,
-        // we ignore the register call and return the default value:
-        if(configSelection is null)
-            return defaultValue;
-		
-        var configPath = Path(configSelection, propertyExpression);
-
-        // If the metadata already exists for this configuration path, we return the default value:
-        if (METADATA.ContainsKey(configPath))
-            return defaultValue;
-        
-        METADATA[configPath] = new ConfigMeta<TClass, TValue>(configSelection, propertyExpression)
-        {
-            Default = defaultValue,
-        };
-
-        return defaultValue;
-    }
 
     /// <summary>
-    /// Attempts to retrieve the configuration metadata for a given configuration selection and property expression.
+    /// Attempts to retrieve the configuration metadata for a given configuration selection and
+    /// property expression (enum-based).
     /// </summary>
     /// <remarks>
-    /// When no configuration metadata is found, it returns a NoConfig instance with the default value set to default(TValue).
-    /// This allows the caller to handle the absence of configuration gracefully. In such cases, the return value of the method will be false.
+    /// When no configuration metadata is found, it returns a NoConfig instance with the default
+    /// value set to default(TValue). This allows the caller to handle the absence of configuration
+    /// gracefully. In such cases, the return value of the method will be false.
     /// </remarks>
     /// <param name="configSelection">The expression to select the configuration class.</param>
-    /// <param name="propertyExpression">The expression to select the property within the configuration class.</param>
-    /// <param name="configMeta">The output parameter that will hold the configuration metadata if found.</param>
+    /// <param name="propertyExpression">The expression to select the property within the
+    /// configuration class.</param>
+    /// <param name="configMeta">The output parameter that will hold the configuration metadata
+    /// if found.</param>
     /// <typeparam name="TClass">The type of the configuration class.</typeparam>
     /// <typeparam name="TValue">The type of the property within the configuration class.</typeparam>
     /// <returns>True if the configuration metadata was found, otherwise false.</returns>
-    public static bool TryGet<TClass, TValue>(Expression<Func<Data, TClass>> configSelection, Expression<Func<TClass, TValue>> propertyExpression, out ConfigMeta<TClass, TValue> configMeta)
+    public static bool TryGet<TClass, TValue>(
+        Expression<Func<Data, TClass>> configSelection,
+        Expression<Func<TClass, TValue>> propertyExpression,
+        out ConfigMeta<TClass, TValue> configMeta)
+        where TValue : Enum
     {
         var configPath = Path(configSelection, propertyExpression);
         if (METADATA.TryGetValue(configPath, out var value) && value is ConfigMeta<TClass, TValue> meta)
@@ -77,77 +49,185 @@ public static class ManagedConfiguration
     }
 
     /// <summary>
-    /// Attempts to process the configuration settings from a Lua table.
+    /// Attempts to retrieve the configuration metadata for a given configuration selection and
+    /// property expression (string-based).
     /// </summary>
     /// <remarks>
-    /// When the configuration is successfully processed, it updates the configuration metadata with the configured value.
-    /// Furthermore, it locks the managed state of the configuration metadata to the provided configuration plugin ID.
-    /// The setting's value is set to the configured value.
+    /// When no configuration metadata is found, it returns a NoConfig instance with the default
+    /// value set to default(TValue). This allows the caller to handle the absence of configuration
+    /// gracefully. In such cases, the return value of the method will be false.
     /// </remarks>
-    /// <param name="configPluginId">The ID of the related configuration plugin.</param>
-    /// <param name="settings">The Lua table containing the settings to process.</param>
     /// <param name="configSelection">The expression to select the configuration class.</param>
-    /// <param name="propertyExpression">The expression to select the property within the configuration class.</param>
-    /// <param name="dryRun">When true, the method will not apply any changes, but only check if the configuration can be read.</param>
+    /// <param name="propertyExpression">The expression to select the property within the
+    /// configuration class.</param>
+    /// <param name="configMeta">The output parameter that will hold the configuration metadata
+    /// if found.</param>
     /// <typeparam name="TClass">The type of the configuration class.</typeparam>
-    /// <typeparam name="TValue">The type of the property within the configuration class.</typeparam>
-    /// <returns>True when the configuration was successfully processed, otherwise false.</returns>
-    public static bool TryProcessConfiguration<TClass, TValue>(Expression<Func<Data, TClass>> configSelection, Expression<Func<TClass, TValue>> propertyExpression, Guid configPluginId, LuaTable settings, bool dryRun)
+    /// <returns>True if the configuration metadata was found, otherwise false.</returns>
+    public static bool TryGet<TClass>(
+        Expression<Func<Data, TClass>> configSelection,
+        Expression<Func<TClass, string>> propertyExpression,
+        out ConfigMeta<TClass, string> configMeta)
     {
-        if(!TryGet(configSelection, propertyExpression, out var configMeta))
-            return false;
-        
-        var (configuredValue, successful) = configMeta.Default switch
+        var configPath = Path(configSelection, propertyExpression);
+        if (METADATA.TryGetValue(configPath, out var value) && value is ConfigMeta<TClass, string> meta)
         {
-            Enum => settings.TryGetValue(SettingsManager.ToSettingName(propertyExpression), out var configuredEnumValue) && configuredEnumValue.TryRead<string>(out var configuredEnumText) && Enum.TryParse(typeof(TValue), configuredEnumText, true, out var configuredEnum) ? ((TValue)configuredEnum, true) : (configMeta.Default, false),
-            Guid => settings.TryGetValue(SettingsManager.ToSettingName(propertyExpression), out var configuredGuidValue) && configuredGuidValue.TryRead<string>(out var configuredGuidText) && Guid.TryParse(configuredGuidText, out var configuredGuid) ? ((TValue)(object)configuredGuid, true) : (configMeta.Default, false),
-
-            string => settings.TryGetValue(SettingsManager.ToSettingName(propertyExpression), out var configuredTextValue) && configuredTextValue.TryRead<string>(out var configuredText) ? ((TValue)(object)configuredText, true) : (configMeta.Default, false),
-            bool => settings.TryGetValue(SettingsManager.ToSettingName(propertyExpression), out var configuredBoolValue) && configuredBoolValue.TryRead<bool>(out var configuredState) ? ((TValue)(object)configuredState, true) : (configMeta.Default, false),
-
-            int => settings.TryGetValue(SettingsManager.ToSettingName(propertyExpression), out var configuredIntValue) && configuredIntValue.TryRead<int>(out var configuredInt) ? ((TValue)(object)configuredInt, true) : (configMeta.Default, false),
-            double => settings.TryGetValue(SettingsManager.ToSettingName(propertyExpression), out var configuredDoubleValue) && configuredDoubleValue.TryRead<double>(out var configuredDouble) ? ((TValue)(object)configuredDouble, true) : (configMeta.Default, false),
-            float => settings.TryGetValue(SettingsManager.ToSettingName(propertyExpression), out var configuredFloatValue) && configuredFloatValue.TryRead<float>(out var configuredFloat) ? ((TValue)(object)configuredFloat, true) : (configMeta.Default, false),
-
-            _ => (configMeta.Default, false),
-        };
-
-        if(dryRun)
-            return successful;
-        
-        switch (successful)
-        {
-            case true:
-                //
-                // Case: the setting was configured, and we could read the value successfully.
-                //
-                configMeta.SetValue(configuredValue);
-                configMeta.LockManagedState(configPluginId);
-                break;
-
-            case false when configMeta.IsLocked && configMeta.MangedByConfigPluginId == configPluginId:
-                //
-                // Case: the setting was configured previously, but we could not read the value successfully.
-                // This happens when the setting was removed from the configuration plugin. We handle that
-                // case only when the setting was locked and managed by the same configuration plugin.
-                //
-                // The other case, when the setting was locked and managed by a different configuration plugin,
-                // is handled by the IsConfigurationLeftOver method, which checks if the configuration plugin
-                // is still available. If it is not available, it resets the managed state of the
-                // configuration setting, allowing it to be reconfigured by a different plugin or left unchanged.
-                //
-                configMeta.ResetManagedState();
-                break;
-            
-            case false:
-                //
-                // Case: the setting was not configured, or we could not read the value successfully.
-                // We do not change the setting, and it remains at whatever value it had before.
-                //
-                break;
+            configMeta = meta;
+            return true;
         }
 
-        return successful;
+        configMeta = new NoConfig<TClass, string>(configSelection, propertyExpression)
+        {
+            Default = string.Empty,
+        };
+        return false;
+    }
+
+    /// <summary>
+    /// Attempts to retrieve the configuration metadata for a given configuration selection and
+    /// property expression (ISpanParsable-based).
+    /// </summary>
+    /// <remarks>
+    /// When no configuration metadata is found, it returns a NoConfig instance with the default
+    /// value set to default(TValue). This allows the caller to handle the absence of configuration
+    /// gracefully. In such cases, the return value of the method will be false.
+    /// </remarks>
+    /// <param name="configSelection">The expression to select the configuration class.</param>
+    /// <param name="propertyExpression">The expression to select the property within the
+    /// configuration class.</param>
+    /// <param name="configMeta">The output parameter that will hold the configuration metadata
+    /// if found.</param>
+    /// <param name="_">An optional parameter to help with method overload resolution.</param>
+    /// <typeparam name="TClass">The type of the configuration class.</typeparam>
+    /// <typeparam name="TValue">The type of the property within the configuration class.</typeparam>
+    /// <returns>True if the configuration metadata was found, otherwise false.</returns>
+
+    // ReSharper disable MethodOverloadWithOptionalParameter
+    public static bool TryGet<TClass, TValue>(
+        Expression<Func<Data, TClass>> configSelection,
+        Expression<Func<TClass, TValue>> propertyExpression,
+        out ConfigMeta<TClass, TValue> configMeta,
+        ISpanParsable<TValue>? _ = null)
+        where TValue : struct, ISpanParsable<TValue>
+    {
+        var configPath = Path(configSelection, propertyExpression);
+        if (METADATA.TryGetValue(configPath, out var value) && value is ConfigMeta<TClass, TValue> meta)
+        {
+            configMeta = meta;
+            return true;
+        }
+
+        configMeta = new NoConfig<TClass, TValue>(configSelection, propertyExpression)
+        {
+            Default = default!,
+        };
+        return false;
+    }
+
+    // ReSharper restore MethodOverloadWithOptionalParameter
+
+    /// <summary>
+    /// Attempts to retrieve the configuration metadata for a list-based setting.
+    /// </summary>
+    /// <remarks>
+    /// When no configuration metadata is found, it returns a NoConfig instance with the default
+    /// value set to an empty list. This allows the caller to handle the absence of configuration
+    /// gracefully. In such cases, the return value of the method will be false.
+    /// </remarks>
+    /// <param name="configSelection">The expression to select the configuration class.</param>
+    /// <param name="propertyExpression">The expression to select the property within the
+    /// configuration class.</param>
+    /// <param name="configMeta">The output parameter that will hold the configuration metadata
+    /// if found.</param>
+    /// <typeparam name="TClass">The type of the configuration class.</typeparam>
+    /// <typeparam name="TValue">The type of the property within the configuration class.</typeparam>
+    /// <returns>True if the configuration metadata was found, otherwise false.</returns>
+    public static bool TryGet<TClass, TValue>(
+        Expression<Func<Data, TClass>> configSelection,
+        Expression<Func<TClass, IList<TValue>>> propertyExpression,
+        out ConfigMeta<TClass, IList<TValue>> configMeta)
+    {
+        var configPath = Path(configSelection, propertyExpression);
+        if (METADATA.TryGetValue(configPath, out var value) && value is ConfigMeta<TClass, IList<TValue>> meta)
+        {
+            configMeta = meta;
+            return true;
+        }
+
+        configMeta = new NoConfig<TClass, IList<TValue>>(configSelection, propertyExpression)
+        {
+            Default = [],
+        };
+        return false;
+    }
+
+    /// <summary>
+    /// Attempts to retrieve the configuration metadata for a set-based setting.
+    /// </summary>
+    /// <remarks>
+    /// When no configuration metadata is found, it returns a NoConfig instance with the default
+    /// value set to an empty set. This allows the caller to handle the absence of configuration
+    /// gracefully. In such cases, the return value of the method will be false.
+    /// </remarks>
+    /// <param name="configSelection">The expression to select the configuration class.</param>
+    /// <param name="propertyExpression">The expression to select the property within the
+    /// configuration class.</param>
+    /// <param name="configMeta">The output parameter that will hold the configuration metadata
+    /// if found.</param>
+    /// <typeparam name="TClass">The type of the configuration class.</typeparam>
+    /// <typeparam name="TValue">The type of the property within the configuration class.</typeparam>
+    /// <returns>True if the configuration metadata was found, otherwise false.</returns>
+    public static bool TryGet<TClass, TValue>(
+        Expression<Func<Data, TClass>> configSelection,
+        Expression<Func<TClass, ISet<TValue>>> propertyExpression,
+        out ConfigMeta<TClass, ISet<TValue>> configMeta)
+    {
+        var configPath = Path(configSelection, propertyExpression);
+        if (METADATA.TryGetValue(configPath, out var value) && value is ConfigMeta<TClass, ISet<TValue>> meta)
+        {
+            configMeta = meta;
+            return true;
+        }
+
+        configMeta = new NoConfig<TClass, ISet<TValue>>(configSelection, propertyExpression)
+        {
+            Default = new HashSet<TValue>(),
+        };
+        return false;
+    }
+    
+    /// <summary>
+    /// Attempts to retrieve the configuration metadata for a string dictionary-based setting.
+    /// </summary>
+    /// <remarks>
+    /// When no configuration metadata is found, it returns a NoConfig instance with the default
+    /// value set to an empty dictionary. This allows the caller to handle the absence of configuration
+    /// gracefully. In such cases, the return value of the method will be false.
+    /// </remarks>
+    /// <param name="configSelection">The expression to select the configuration class.</param>
+    /// <param name="propertyExpression">The expression to select the property within the
+    /// configuration class.</param>
+    /// <param name="configMeta">The output parameter that will hold the configuration metadata
+    /// if found.</param>
+    /// <typeparam name="TClass">The type of the configuration class.</typeparam>
+    /// <returns>True if the configuration metadata was found, otherwise false.</returns>
+    public static bool TryGet<TClass>(
+        Expression<Func<Data, TClass>> configSelection,
+        Expression<Func<TClass, IDictionary<string, string>>> propertyExpression,
+        out ConfigMeta<TClass, IDictionary<string, string>> configMeta)
+    {
+        var configPath = Path(configSelection, propertyExpression);
+        if (METADATA.TryGetValue(configPath, out var value) && value is ConfigMeta<TClass, IDictionary<string, string>> meta)
+        {
+            configMeta = meta;
+            return true;
+        }
+
+        configMeta = new NoConfig<TClass, IDictionary<string, string>>(configSelection, propertyExpression)
+        {
+            Default = new Dictionary<string, string>(),
+        };
+        return false;
     }
 
     /// <summary>
@@ -162,23 +242,135 @@ public static class ManagedConfiguration
     /// <typeparam name="TClass">The type of the configuration class.</typeparam>
     /// <typeparam name="TValue">The type of the property within the configuration class.</typeparam>
     /// <returns>True if the configuration setting is left over and was reset, otherwise false.</returns>
-    public static bool IsConfigurationLeftOver<TClass, TValue>(Expression<Func<Data, TClass>> configSelection, Expression<Func<TClass, TValue>> propertyExpression, IEnumerable<IAvailablePlugin> availablePlugins)
+    public static bool IsConfigurationLeftOver<TClass, TValue>(
+        Expression<Func<Data, TClass>> configSelection,
+        Expression<Func<TClass, TValue>> propertyExpression,
+        IEnumerable<IAvailablePlugin> availablePlugins)
+        where TValue : Enum
     {
         if (!TryGet(configSelection, propertyExpression, out var configMeta))
             return false;
 
-        if(configMeta.MangedByConfigPluginId == Guid.Empty || !configMeta.IsLocked)
+        if (configMeta.MangedByConfigPluginId == Guid.Empty || !configMeta.IsLocked)
             return false;
-        
-        // Check if the configuration plugin ID is valid against the available plugin IDs:
+
         var plugin = availablePlugins.FirstOrDefault(x => x.Id == configMeta.MangedByConfigPluginId);
         if (plugin is null)
         {
-            // Remove the locked state:
             configMeta.ResetManagedState();
             return true;
         }
-        
+
+        return false;
+    }
+
+    public static bool IsConfigurationLeftOver<TClass>(
+        Expression<Func<Data, TClass>> configSelection,
+        Expression<Func<TClass, string>> propertyExpression,
+        IEnumerable<IAvailablePlugin> availablePlugins)
+    {
+        if (!TryGet(configSelection, propertyExpression, out var configMeta))
+            return false;
+
+        if (configMeta.MangedByConfigPluginId == Guid.Empty || !configMeta.IsLocked)
+            return false;
+
+        var plugin = availablePlugins.FirstOrDefault(x => x.Id == configMeta.MangedByConfigPluginId);
+        if (plugin is null)
+        {
+            configMeta.ResetManagedState();
+            return true;
+        }
+
+        return false;
+    }
+
+    // ReSharper disable MethodOverloadWithOptionalParameter
+    public static bool IsConfigurationLeftOver<TClass, TValue>(
+        Expression<Func<Data, TClass>> configSelection,
+        Expression<Func<TClass, TValue>> propertyExpression,
+        IEnumerable<IAvailablePlugin> availablePlugins,
+        ISpanParsable<TValue>? _ = null)
+        where TValue : struct, ISpanParsable<TValue>
+    {
+        if (!TryGet(configSelection, propertyExpression, out var configMeta))
+            return false;
+
+        if (configMeta.MangedByConfigPluginId == Guid.Empty || !configMeta.IsLocked)
+            return false;
+
+        var plugin = availablePlugins.FirstOrDefault(x => x.Id == configMeta.MangedByConfigPluginId);
+        if (plugin is null)
+        {
+            configMeta.ResetManagedState();
+            return true;
+        }
+
+        return false;
+    }
+
+    // ReSharper restore MethodOverloadWithOptionalParameter
+
+    public static bool IsConfigurationLeftOver<TClass, TValue>(
+        Expression<Func<Data, TClass>> configSelection,
+        Expression<Func<TClass, IList<TValue>>> propertyExpression,
+        IEnumerable<IAvailablePlugin> availablePlugins)
+    {
+        if (!TryGet(configSelection, propertyExpression, out var configMeta))
+            return false;
+
+        if (configMeta.MangedByConfigPluginId == Guid.Empty || !configMeta.IsLocked)
+            return false;
+
+        var plugin = availablePlugins.FirstOrDefault(x => x.Id == configMeta.MangedByConfigPluginId);
+        if (plugin is null)
+        {
+            configMeta.ResetManagedState();
+            return true;
+        }
+
+        return false;
+    }
+
+    public static bool IsConfigurationLeftOver<TClass, TValue>(
+        Expression<Func<Data, TClass>> configSelection,
+        Expression<Func<TClass, ISet<TValue>>> propertyExpression,
+        IEnumerable<IAvailablePlugin> availablePlugins)
+    {
+        if (!TryGet(configSelection, propertyExpression, out var configMeta))
+            return false;
+
+        if (configMeta.MangedByConfigPluginId == Guid.Empty || !configMeta.IsLocked)
+            return false;
+
+        var plugin = availablePlugins.FirstOrDefault(x => x.Id == configMeta.MangedByConfigPluginId);
+        if (plugin is null)
+        {
+            configMeta.ResetManagedState();
+            return true;
+        }
+
+        return false;
+    }
+
+    public static bool IsConfigurationLeftOver<TClass>(
+        Expression<Func<Data, TClass>> configSelection,
+        Expression<Func<TClass, IDictionary<string, string>>> propertyExpression,
+        IEnumerable<IAvailablePlugin> availablePlugins)
+    {
+        if (!TryGet(configSelection, propertyExpression, out var configMeta))
+            return false;
+
+        if (configMeta.MangedByConfigPluginId == Guid.Empty || !configMeta.IsLocked)
+            return false;
+
+        var plugin = availablePlugins.FirstOrDefault(x => x.Id == configMeta.MangedByConfigPluginId);
+        if (plugin is null)
+        {
+            configMeta.ResetManagedState();
+            return true;
+        }
+
         return false;
     }