ToolRepository.cs

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

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

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

        private ToolRepository()
        {
            LoadAllConfiguredTools();
        }

        // Re-reads every tool/page config file from disk, replacing the in-memory set. Lets an edit to
        // tools/*.yaml or tools/pages/*.yaml (a fixed destinationUrl, a new tool, an addr change) take effect
        // on the next run without restarting the whole application - see Form1.RunSelectedToolsOnceAsync,
        // which calls this at the start of every single run and every continuous-loop cycle.
        public void Reload()
        {
            var freshTools = new Dictionary<string, ToolConfig>(StringComparer.OrdinalIgnoreCase);
            LoadAllConfiguredTools(freshTools);

            lock (_lock)
            {
                _registeredTools = freshTools;
            }
        }

        private void LoadAllConfiguredTools() => LoadAllConfiguredTools(_registeredTools);

        private void LoadAllConfiguredTools(Dictionary<string, ToolConfig> targetTools)
        {
            string toolsDir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "tools");
            string pagesDir = Path.Combine(toolsDir, "pages");

            Logger.Instance.Info("TOOL_REPO", $"Initializing engine configuration path mapping fields under: {toolsDir}");

            if (!Directory.Exists(toolsDir)) Directory.CreateDirectory(toolsDir);
            if (!Directory.Exists(pagesDir)) Directory.CreateDirectory(pagesDir);

            var deserializer = new DeserializerBuilder().WithNamingConvention(CamelCaseNamingConvention.Instance).IgnoreUnmatchedProperties().Build();

            try
            {
                string[] toolManifestFiles = Directory.GetFiles(toolsDir, "*.yaml");
                Logger.Instance.Debug("TOOL_REPO", $"Discovered ({toolManifestFiles.Length}) base tool profiles.");

                foreach (string toolFilePath in toolManifestFiles)
                {
                    if (Path.GetFileName(toolFilePath).Equals("logger_config.yaml", StringComparison.OrdinalIgnoreCase)) continue;

                    try
                    {
                        string toolYaml = File.ReadAllText(toolFilePath);
                        var tool = deserializer.Deserialize<ToolConfig>(toolYaml);

                        if (tool == null || string.IsNullOrWhiteSpace(tool.ToolName)) continue;

                        Logger.Instance.Info("TOOL_REPO", $"Processing profile: '{tool.ToolName}' targeting endpoint -> {tool.Addr}");

                        foreach (string pattern in tool.PageFilePatterns)
                        {
                            string[] matchedPageFiles = Directory.GetFiles(pagesDir, pattern);
                            foreach (string pageFilePath in matchedPageFiles)
                            {
                                try
                                {
                                    string pageYaml = File.ReadAllText(pageFilePath);
                                    var pageConfigsList = deserializer.Deserialize<List<ScrapPageConfig>>(pageYaml);

                                    if (pageConfigsList != null)
                                    {
                                        // destinationUrl may be a relative path ("/status/acts") - resolve it
                                        // against this tool's addr, same convention as pageLogin/BaseLoginUrl.
                                        // Already-absolute URLs (older configs) pass through unchanged.
                                        foreach (var pageConfig in pageConfigsList)
                                        {
                                            pageConfig.DestinationUrl = tool.ResolveUrl(pageConfig.DestinationUrl);
                                        }

                                        tool.ScrapPages.AddRange(pageConfigsList);
                                        Logger.Instance.Debug("TOOL_REPO", $" -> File '{Path.GetFileName(pageFilePath)}' mapped {pageConfigsList.Count} destination page URLs to '{tool.ToolName}'.");
                                    }
                                }
                                catch (Exception pEx)
                                {
                                    Logger.Instance.Error("TOOL_REPO", $"Failed compiling pages block inside file {Path.GetFileName(pageFilePath)}: {pEx.Message}");
                                }
                            }
                        }

                        targetTools[tool.ToolName] = tool;
                    }
                    catch (Exception tEx)
                    {
                        Logger.Instance.Error("TOOL_REPO", $"Corrupt master manifest layout on {Path.GetFileName(toolFilePath)}: {tEx.Message}");
                    }
                }
                Logger.Instance.Info("TOOL_REPO", $"Cache fully built. System profile orchestrators ready: {targetTools.Count}");
            }
            catch (Exception ex)
            {
                Logger.Instance.Critical("TOOL_REPO", $"Internal tool mapping layer faulted: {ex.Message}");
            }
        }

        public ToolConfig GetTool(string toolName)
        {
            lock (_lock)
            {
                return _registeredTools.TryGetValue(toolName, out var config) ? config : null;
            }
        }

        public IEnumerable<ToolConfig> GetAllTools()
        {
            lock (_lock)
            {
                return new List<ToolConfig>(_registeredTools.Values);
            }
        }
    } // Closes class ToolRepository
} // Closes namespace WebToolsDataMonitor