ScriptsRepository.cs

using System;
using System.Collections.Generic;
using System.IO;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.NamingConventions;

namespace WebToolsDataMonitor
{
    public class ScriptsRepository
    {
        private static readonly Lazy<ScriptsRepository> _instance = new Lazy<ScriptsRepository>(() => new ScriptsRepository());
        public static ScriptsRepository Instance => _instance.Value;

        private readonly object _lock = new object();
        private Dictionary<string, ScrapScript> _scripts = new Dictionary<string, ScrapScript>(StringComparer.OrdinalIgnoreCase);

        private ScriptsRepository() { LoadScriptsFromYamlDirectory(_scripts); }

        // Re-reads every script file from disk, replacing the in-memory set. See ToolRepository.Reload -
        // called alongside it at the start of every single run and every continuous-loop cycle, so a tweak
        // to a script's scriptText/DelaySeconds/etc. takes effect on the next run without an app restart.
        public void Reload()
        {
            var freshScripts = new Dictionary<string, ScrapScript>(StringComparer.OrdinalIgnoreCase);
            LoadScriptsFromYamlDirectory(freshScripts);

            lock (_lock)
            {
                _scripts = freshScripts;
            }
        }

        private void LoadScriptsFromYamlDirectory(Dictionary<string, ScrapScript> targetScripts)
        {
            string scriptsDirectory = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "tools", "scripts");
            Logger.Instance.Info("SCRIPTS_REPO", $"Scanning workspace path: {scriptsDirectory}");

            try
            {
                if (!Directory.Exists(scriptsDirectory))
                {
                    Directory.CreateDirectory(scriptsDirectory);
                    Logger.Instance.Warn("SCRIPTS_REPO", "Target folder missing. Generated empty container directory.");
                    return;
                }

                var deserializer = new DeserializerBuilder().WithNamingConvention(CamelCaseNamingConvention.Instance).IgnoreUnmatchedProperties().Build();
                string[] files = Directory.GetFiles(scriptsDirectory, "*.y*ml");
                Logger.Instance.Debug("SCRIPTS_REPO", $"Found ({files.Length}) candidate files target parsing.");

                foreach (string filePath in files)
                {
                    try
                    {
                        string yamlContent = File.ReadAllText(filePath);
                        var parsedScripts = deserializer.Deserialize<List<ScrapScript>>(yamlContent);
                        if (parsedScripts == null) continue;

                        int fileScriptCount = 0;
                        foreach (var script in parsedScripts)
                        {
                            if (script != null && !string.IsNullOrWhiteSpace(script.Name))
                            {
                                targetScripts[script.Name] = script;
                                fileScriptCount++;
                            }
                        }
                        Logger.Instance.Info("SCRIPTS_REPO", $"Ingested ({fileScriptCount}) standalone script assets out of: '{Path.GetFileName(filePath)}'");
                    }
                    catch (Exception fileEx)
                    {
                        Logger.Instance.Error("SCRIPTS_REPO", $"Fault parsing scripts inside '{Path.GetFileName(filePath)}': {fileEx.Message}");
                    }
                }
                Logger.Instance.Info("SCRIPTS_REPO", $"Cache completed. Inventory size: {targetScripts.Count} active entries.");
            }
            catch (Exception dirEx)
            {
                Logger.Instance.Critical("SCRIPTS_REPO", $"Directory discovery collapse: {dirEx.Message}");
            }
        }

        public ScrapScript GetScript(string name)
        {
            lock (_lock)
            {
                return _scripts.TryGetValue(name, out var script) ? script : null;
            }
        }
    }
}