Finlytic/FinlyticAnalyzer/Services/SettingsDbService.cs

using FinlyticAnalyzer.Database;
using FinlyticAnalyzer.Entities;
using Microsoft.EntityFrameworkCore;

namespace FinlyticAnalyzer.Services;

public interface ISettingsDbService
{
    /// <summary>
    /// Gets the analyzer settings asynchronously.
    /// </summary>
    Task<AnalyzerSettingsEntity> GetSettingsAsync();
    
    /// <summary>
    /// Saves the analyzer settings asynchronously.
    /// </summary>
    Task<AnalyzerSettingsEntity> SaveSettingsAsync(AnalyzerSettingsEntity settings);
    
    /// <summary>
    /// Updates settings from a dictionary asynchronously.
    /// </summary>
    Task UpdateSettingsFromDictionaryAsync(Dictionary<string, string> dictionary);
}

public class SettingsDbService : ISettingsDbService
{
    private readonly AnalyzerDbContext _context;

    public SettingsDbService(AnalyzerDbContext context)
    {
        _context = context;
    }

    /// <summary>
    /// Gets the analyzer settings asynchronously.
    /// </summary>
    public async Task<AnalyzerSettingsEntity> GetSettingsAsync()
    {
        var settings = await _context.Settings.AsNoTracking().FirstOrDefaultAsync();
        if (settings == null)
        {
            settings = new AnalyzerSettingsEntity { Id = Guid.NewGuid(), UpdatedAt = DateTime.UtcNow };
            _context.Settings.Add(settings);
            await _context.SaveChangesAsync();
            _context.ChangeTracker.Clear();
        }

        // Synchronize in-memory static filter values on get
        SyncLogFilters(settings);

        return settings;
    }

    /// <summary>
    /// Saves the analyzer settings asynchronously.
    /// </summary>
    public async Task<AnalyzerSettingsEntity> SaveSettingsAsync(AnalyzerSettingsEntity settings)
    {
        var existing = await _context.Settings.FirstOrDefaultAsync(s => s.Id == settings.Id) 
                       ?? await _context.Settings.FirstOrDefaultAsync();

        if (existing == null)
        {
            if (settings.Id == Guid.Empty) settings.Id = Guid.NewGuid();
            settings.UpdatedAt = DateTime.UtcNow;
            _context.Settings.Add(settings);
        }
        else
        {
            existing.ScanCronSchedule = settings.ScanCronSchedule;
            existing.MinSignalScore = settings.MinSignalScore;
            existing.EnableLogMqttHealthPing = settings.EnableLogMqttHealthPing;
            existing.EnableLogMqttGeneral = settings.EnableLogMqttGeneral;
            existing.EnableLogAnalyzerAuto = settings.EnableLogAnalyzerAuto;
            existing.EnableLogAnalyzerManual = settings.EnableLogAnalyzerManual;
            existing.EnableLogDatabaseOps = settings.EnableLogDatabaseOps;
            existing.UpdatedAt = DateTime.UtcNow;
        }

        await _context.SaveChangesAsync();

        SyncLogFilters(settings);

        return settings;
    }

    private static void SyncLogFilters(AnalyzerSettingsEntity settings)
    {
        LogCategoryFilter.EnableLogMqttHealthPing = settings.EnableLogMqttHealthPing;
        LogCategoryFilter.EnableLogMqttGeneral = settings.EnableLogMqttGeneral;
        LogCategoryFilter.EnableLogAnalyzerAuto = settings.EnableLogAnalyzerAuto;
        LogCategoryFilter.EnableLogAnalyzerManual = settings.EnableLogAnalyzerManual;
        LogCategoryFilter.EnableLogDatabaseOps = settings.EnableLogDatabaseOps;
    }

    /// <summary>
    /// Updates settings from a dictionary asynchronously.
    /// </summary>
    public async Task UpdateSettingsFromDictionaryAsync(Dictionary<string, string> dictionary)
    {
        var settings = await GetSettingsAsync();

        foreach (var (key, value) in dictionary)
        {
            if (string.Equals(key, "ScanCronSchedule", StringComparison.OrdinalIgnoreCase) && !string.IsNullOrWhiteSpace(value))
                settings.ScanCronSchedule = value.Trim();
            else if (string.Equals(key, "MinSignalScore", StringComparison.OrdinalIgnoreCase) && double.TryParse(value, out var score))
                settings.MinSignalScore = score;
            else if (string.Equals(key, "EnableLog_MqttHealthPing", StringComparison.OrdinalIgnoreCase) && bool.TryParse(value, out var b1))
                settings.EnableLogMqttHealthPing = b1;
            else if (string.Equals(key, "EnableLog_MqttGeneral", StringComparison.OrdinalIgnoreCase) && bool.TryParse(value, out var b2))
                settings.EnableLogMqttGeneral = b2;
            else if (string.Equals(key, "EnableLog_AnalyzerAuto", StringComparison.OrdinalIgnoreCase) && bool.TryParse(value, out var b3))
                settings.EnableLogAnalyzerAuto = b3;
            else if (string.Equals(key, "EnableLog_AnalyzerManual", StringComparison.OrdinalIgnoreCase) && bool.TryParse(value, out var b4))
                settings.EnableLogAnalyzerManual = b4;
            else if (string.Equals(key, "EnableLog_DatabaseOps", StringComparison.OrdinalIgnoreCase) && bool.TryParse(value, out var b5))
                settings.EnableLogDatabaseOps = b5;
        }

        settings.UpdatedAt = DateTime.UtcNow;
        await SaveSettingsAsync(settings);
    }
}