using DataModel.Database;
using DataModel.Database.Common;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;

namespace Processor;

public static class AppSettings
{
    #region DeepL Settings

    #region DeepL Mode

    private static SettingDeepLMode CACHE_DEEPL_MODE = SettingDeepLMode.DISABLED;
    private static bool CACHE_DEEPL_MODE_IS_LOADED = false;
    
    public static async Task SetDeepLMode(SettingDeepLMode mode)
    {
        // Convert the enum to its int value:
        var intValue = (int)mode;
        
        // Update the cache:
        CACHE_DEEPL_MODE = mode;
        CACHE_DEEPL_MODE_IS_LOADED = true;
        
        // Get the database:
        await using var db = ProcessorMeta.ServiceProvider.GetRequiredService<DataContext>();
        
        // Check, if the setting is already set:
        if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.DEEPL_MODE) is {} existingSetting)
        {
            existingSetting.IntegerValue = intValue;
            await db.SaveChangesAsync();
        }
        
        // Does not exist, so create it:
        else
        {
            var setting = new Setting
            {
                Code = SettingNames.DEEPL_MODE,
                IntegerValue = intValue,
            };
            
            await db.Settings.AddAsync(setting);
            await db.SaveChangesAsync();
        }
    }

    public static async Task<SettingDeepLMode> GetDeepLMode()
    {
        if (CACHE_DEEPL_MODE_IS_LOADED)
            return CACHE_DEEPL_MODE;

        var mode = SettingDeepLMode.DISABLED;
        try
        {
            // Get the database:
            await using var db = ProcessorMeta.ServiceProvider.GetRequiredService<DataContext>();

            // Check, if the setting is already set:
            if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.DEEPL_MODE) is { } existingSetting)
            {
                mode = (SettingDeepLMode) existingSetting.IntegerValue;
                return mode;
            }

            // Does not exist, so create it:
            var setting = new Setting
            {
                Code = SettingNames.DEEPL_MODE,
                IntegerValue = (int) mode,
            };

            await db.Settings.AddAsync(setting);
            await db.SaveChangesAsync();
            return mode;
        }
        finally
        {
            CACHE_DEEPL_MODE = mode;
            CACHE_DEEPL_MODE_IS_LOADED = true;
        }
    }

    #endregion
    
    #region DeepL API Key
    
    private static string CACHE_DEEPL_API_KEY = string.Empty;
    private static bool CACHE_DEEPL_API_KEY_IS_LOADED = false;
    
    public static async Task SetDeepLAPIKey(string apiKey)
    {
        // Update the cache:
        CACHE_DEEPL_API_KEY = apiKey;
        CACHE_DEEPL_API_KEY_IS_LOADED = true;
        
        // Get the database:
        await using var db = ProcessorMeta.ServiceProvider.GetRequiredService<DataContext>();
        
        // Check, if the setting is already set:
        if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.DEEPL_API_KEY) is {} existingSetting)
        {
            existingSetting.TextValue = apiKey;
            await db.SaveChangesAsync();
        }
        
        // Does not exist, so create it:
        else
        {
            var setting = new Setting
            {
                Code = SettingNames.DEEPL_API_KEY,
                TextValue = apiKey,
            };
            
            await db.Settings.AddAsync(setting);
            await db.SaveChangesAsync();
        }
    }
    
    public static async Task<string> GetDeepLAPIKey()
    {
        // Check the cache:
        if (CACHE_DEEPL_API_KEY_IS_LOADED)
            return CACHE_DEEPL_API_KEY;

        var key = string.Empty;
        try
        {
            // Get the database:
            await using var db = ProcessorMeta.ServiceProvider.GetRequiredService<DataContext>();

            // Check, if the setting is already set:
            if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.DEEPL_API_KEY) is { } existingSetting)
            {
                key = existingSetting.TextValue;
                return key;
            }

            // Does not exist, so create it:
            var setting = new Setting
            {
                Code = SettingNames.DEEPL_API_KEY,
                TextValue = key,
            };

            await db.Settings.AddAsync(setting);
            await db.SaveChangesAsync();
            return key;
        }
        finally
        {
            CACHE_DEEPL_API_KEY = key;
            CACHE_DEEPL_API_KEY_IS_LOADED = true;
        }
    }
    
    #endregion
    
    #region DeepL Action
    
    private static SettingDeepLAction CACHE_DEEPL_ACTION = SettingDeepLAction.MANUAL;
    private static bool CACHE_DEEPL_ACTION_IS_LOADED = false;

    public static async Task SetDeepLAction(SettingDeepLAction action)
    {
        // Convert the enum to its int value:
        var intValue = (int)action;
        
        // Update the cache:
        CACHE_DEEPL_ACTION = action;
        CACHE_DEEPL_ACTION_IS_LOADED = true;
        
        // Get the database:
        await using var db = ProcessorMeta.ServiceProvider.GetRequiredService<DataContext>();
        
        // Check, if the setting is already set:
        if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.DEEPL_ACTION) is {} existingSetting)
        {
            existingSetting.IntegerValue = intValue;
            await db.SaveChangesAsync();
        }
        
        // Does not exist, so create it:
        else
        {
            var setting = new Setting
            {
                Code = SettingNames.DEEPL_ACTION,
                IntegerValue = intValue,
            };
            
            await db.Settings.AddAsync(setting);
            await db.SaveChangesAsync();
        }
    }
    
    public static async Task<SettingDeepLAction> GetDeepLAction()
    {
        // Check the cache:
        if (CACHE_DEEPL_ACTION_IS_LOADED)
            return CACHE_DEEPL_ACTION;
        
        var action = SettingDeepLAction.MANUAL;
        try
        {
            // Get the database:
            await using var db = ProcessorMeta.ServiceProvider.GetRequiredService<DataContext>();

            // Check, if the setting is already set:
            if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.DEEPL_ACTION) is { } existingSetting)
            {
                action = (SettingDeepLAction) existingSetting.IntegerValue;
                return action;
            }

            // Does not exist, so create it:
            var setting = new Setting
            {
                Code = SettingNames.DEEPL_ACTION,
                IntegerValue = (int) action,
            };

            await db.Settings.AddAsync(setting);
            await db.SaveChangesAsync();
            return action;
        }
        finally
        {
            CACHE_DEEPL_ACTION = action;
            CACHE_DEEPL_ACTION_IS_LOADED = true;
        }
    }
    
    #endregion

    #region DeepL Source Culture
    
    private static int CACHE_DEEPL_SOURCE_CULTURE = -1;
    private static bool CACHE_DEEPL_SOURCE_CULTURE_IS_LOADED = false;
    
    public static async Task SetDeepLSourceCultureIndex(int cultureIndex)
    {
        // Update the cache:
        CACHE_DEEPL_SOURCE_CULTURE = cultureIndex;
        CACHE_DEEPL_SOURCE_CULTURE_IS_LOADED = true;
        
        // Get the database:
        await using var db = ProcessorMeta.ServiceProvider.GetRequiredService<DataContext>();
        
        // Check, if the setting is already set:
        if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.DEEPL_SOURCE_CULTURE) is {} existingSetting)
        {
            existingSetting.IntegerValue = cultureIndex;
            await db.SaveChangesAsync();
        }
        
        // Does not exist, so create it:
        else
        {
            var setting = new Setting
            {
                Code = SettingNames.DEEPL_SOURCE_CULTURE,
                IntegerValue = cultureIndex,
            };
            
            await db.Settings.AddAsync(setting);
            await db.SaveChangesAsync();
        }
    }
    
    public static async Task<int> GetDeepLSourceCultureIndex()
    {
        // Check the cache:
        if (CACHE_DEEPL_SOURCE_CULTURE_IS_LOADED)
            return CACHE_DEEPL_SOURCE_CULTURE;
        
        var cultureIndex = -1;
        try
        {
            // Get the database:
            await using var db = ProcessorMeta.ServiceProvider.GetRequiredService<DataContext>();

            // Check, if the setting is already set:
            if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.DEEPL_SOURCE_CULTURE) is { } existingSetting)
            {
                cultureIndex = existingSetting.IntegerValue;
                return cultureIndex;
            }

            // Does not exist, so create it:
            var setting = new Setting
            {
                Code = SettingNames.DEEPL_SOURCE_CULTURE,
                IntegerValue = cultureIndex,
            };

            await db.Settings.AddAsync(setting);
            await db.SaveChangesAsync();
            return cultureIndex;
        }
        finally
        {
            CACHE_DEEPL_SOURCE_CULTURE = cultureIndex;
            CACHE_DEEPL_SOURCE_CULTURE_IS_LOADED = true;
        }
    }
    
    #endregion
    
    #endregion

    #region Translation Settings

    #region List of culture indices
    
    private static List<int> CACHE_CULTURES_INDICES = new();

    public static async Task<List<int>> GetCultureIndices()
    {
        // When possible, use the cache:
        if (CACHE_CULTURES_INDICES.Count > 0)
            return CACHE_CULTURES_INDICES;
        
        // Get the database:
        await using var db = ProcessorMeta.ServiceProvider.GetRequiredService<DataContext>();
        
        // Count the number of cultures:
        var list = await db.Settings.Where(n => n.Code.StartsWith(SettingNames.CULTURE)).OrderBy(n => n.IntegerValue).Select(n => n.IntegerValue).ToListAsync();
        
        // We have at least one default culture:
        if(list.Count == 0)
        {
            // Add the default culture, which is en-US:
            await AppSettings.SetCultureCode(1, "en-US");
        }
        else
            CACHE_CULTURES_INDICES = list;
        
        return CACHE_CULTURES_INDICES;
    }

    #endregion
    
    #region Get a culture
    
    // Cache the cultures:
    private static readonly Dictionary<int, string> CACHE_CULTURES = new();

    public static async Task<string> GetCultureCode(int index)
    {
        // Check the cache:
        if (CACHE_CULTURES.TryGetValue(index, out var cultureCode))
            return cultureCode;
        
        // Get the database:
        await using var db = ProcessorMeta.ServiceProvider.GetRequiredService<DataContext>();
        
        // Get the culture code:
        var code = await db.Settings.FirstOrDefaultAsync(n => n.Code.StartsWith(SettingNames.CULTURE) && n.IntegerValue == index);
        
        // When the culture code is not set & index = 1, use the default culture en-US:
        if(code is null && index == 1)
        {
            CACHE_CULTURES.Add(index, "en-US");
            return "en-US";
        }

        // Update the cache & return the code:
        var codeText = code?.TextValue ?? string.Empty;
        CACHE_CULTURES[index] = codeText;
        return codeText;
    }
    
    #endregion
    
    #region Set a culture
    
    public static async Task SetCultureCode(int index, string code)
    {
        // Update the cache:
        CACHE_CULTURES[index] = code;
        
        // Get the database:
        await using var db = ProcessorMeta.ServiceProvider.GetRequiredService<DataContext>();
        
        // Check, if the setting is already set:
        if (await db.Settings.FirstOrDefaultAsync(n => n.Code.StartsWith(SettingNames.CULTURE) && n.IntegerValue == index) is {} existingSetting)
        {
            existingSetting.TextValue = code;
            await db.SaveChangesAsync();
        }
        
        // Does not exist, so create it:
        else
        {
            var setting = new Setting
            {
                Code = $"{SettingNames.CULTURE} {index}",
                IntegerValue = index,
                TextValue = code,
            };
            
            await db.Settings.AddAsync(setting);
            await db.SaveChangesAsync();
            
            // Update the list of cultures indices:
            CACHE_CULTURES_INDICES.Add(index);
        }
    }
    
    #endregion

    #region Delete a culture
    
    public static async Task DeleteCulture(int index)
    {
        // Get the database:
        await using var db = ProcessorMeta.ServiceProvider.GetRequiredService<DataContext>();
        
        // Check, if the setting is already set:
        if (await db.Settings.FirstOrDefaultAsync(n => n.Code.StartsWith(SettingNames.CULTURE) && n.IntegerValue == index) is {} existingSetting)
        {
            db.Settings.Remove(existingSetting);
            await db.SaveChangesAsync();
        }
        
        // Update the list of cultures indices:
        CACHE_CULTURES_INDICES.Remove(index);

        // Update the cache:
        CACHE_CULTURES.Remove(index);
    }

    #endregion

    #region Get a list of cultures

    public readonly record struct CultureInfo(string Code, int Index);

    public static async Task<List<CultureInfo>> GetCultureInfos()
    {
        // Get the number of cultures:
        var cultureIndices = await AppSettings.GetCultureIndices();
        
        // Get the culture codes:
        var cultureInfos = new List<CultureInfo>();
        foreach (var cultureIndex in cultureIndices)
            cultureInfos.Add(new CultureInfo
            {
                Code = await AppSettings.GetCultureCode(cultureIndex),
                Index = cultureIndex,
            });
        
        return cultureInfos;
    }

    #endregion

    #endregion

    #region Generator Settings

    #region Generator Mode
    
    private static SettingGeneratorMode CACHE_GENERATOR_MODE = SettingGeneratorMode.MANUAL;
    private static bool CACHE_GENERATOR_MODE_IS_LOADED = false;

    public static async Task<SettingGeneratorMode> GetGeneratorMode()
    {
        // When possible, use the cache:
        if (CACHE_GENERATOR_MODE_IS_LOADED)
            return CACHE_GENERATOR_MODE;

        var generatorMode = SettingGeneratorMode.MANUAL;
        try
        {
            // Get the database:
            await using var db = ProcessorMeta.ServiceProvider.GetRequiredService<DataContext>();

            // Check, if the setting is already set:
            if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.GENERATOR_MODE) is { } existingSetting)
            {
                generatorMode = (SettingGeneratorMode) existingSetting.IntegerValue;
                return generatorMode;
            }

            // Does not exist, so create it:
            var setting = new Setting
            {
                Code = SettingNames.GENERATOR_MODE,
                IntegerValue = (int) generatorMode,
            };

            await db.Settings.AddAsync(setting);
            await db.SaveChangesAsync();
            return generatorMode;
        }
        finally
        {
            CACHE_GENERATOR_MODE_IS_LOADED = true;
            CACHE_GENERATOR_MODE = generatorMode;
        }
    }
    
    public static async Task SetGeneratorMode(SettingGeneratorMode mode)
    {
        // Update the cache:
        CACHE_GENERATOR_MODE = mode;
        CACHE_GENERATOR_MODE_IS_LOADED = true;
        
        // Get the database:
        await using var db = ProcessorMeta.ServiceProvider.GetRequiredService<DataContext>();
        
        // Check, if the setting is already set:
        if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.GENERATOR_MODE) is { } existingSetting)
        {
            existingSetting.IntegerValue = (int) mode;
            await db.SaveChangesAsync();
        }
        
        // Does not exist, so create it:
        else
        {
            var setting = new Setting
            {
                Code = SettingNames.GENERATOR_MODE,
                IntegerValue = (int) mode,
            };
            
            await db.Settings.AddAsync(setting);
            await db.SaveChangesAsync();
        }
    }
    
    #endregion

    #region .NET Generator Enabled/Disabled
    
    private static bool CACHE_GENERATOR_DOTNET_ENABLED = true;
    private static bool CACHE_GENERATOR_DOTNET_ENABLED_IS_LOADED = false;
    
    public static async Task<bool> GetGeneratorDotnetEnabled()
    {
        // When possible, use the cache:
        if (CACHE_GENERATOR_DOTNET_ENABLED_IS_LOADED)
            return CACHE_GENERATOR_DOTNET_ENABLED;

        var generatorDotnetEnabled = false;
        try
        {
            // Get the database:
            await using var db = ProcessorMeta.ServiceProvider.GetRequiredService<DataContext>();

            // Check, if the setting is already set:
            if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.GENERATOR_DOTNET_ENABLED) is { } existingSetting)
            {
                generatorDotnetEnabled = existingSetting.BoolValue;
                return generatorDotnetEnabled;
            }

            // Does not exist, so create it:
            var setting = new Setting
            {
                Code = SettingNames.GENERATOR_DOTNET_ENABLED,
                BoolValue = generatorDotnetEnabled,
            };

            await db.Settings.AddAsync(setting);
            await db.SaveChangesAsync();
            return generatorDotnetEnabled;
        }
        finally
        {
            CACHE_GENERATOR_DOTNET_ENABLED_IS_LOADED = true;
            CACHE_GENERATOR_DOTNET_ENABLED = generatorDotnetEnabled;
        }
    }
    
    public static async Task SetGeneratorDotnetEnabled(bool enabled)
    {
        // Update the cache:
        CACHE_GENERATOR_DOTNET_ENABLED = enabled;
        CACHE_GENERATOR_DOTNET_ENABLED_IS_LOADED = true;
        
        // Get the database:
        await using var db = ProcessorMeta.ServiceProvider.GetRequiredService<DataContext>();
        
        // Check, if the setting is already set:
        if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.GENERATOR_DOTNET_ENABLED) is { } existingSetting)
        {
            existingSetting.BoolValue = enabled;
            await db.SaveChangesAsync();
        }
        
        // Does not exist, so create it:
        else
        {
            var setting = new Setting
            {
                Code = SettingNames.GENERATOR_DOTNET_ENABLED,
                BoolValue = enabled,
            };
            
            await db.Settings.AddAsync(setting);
            await db.SaveChangesAsync();
        }
    }

    #endregion

    #region .NET Generator Destination Path
    
    private static string CACHE_GENERATOR_DOTNET_DESTINATION_PATH = string.Empty;
    private static bool CACHE_GENERATOR_DOTNET_DESTINATION_PATH_IS_LOADED = false;
    
    public static async Task<string> GetGeneratorDotnetDestinationPath()
    {
        // When possible, use the cache:
        if (CACHE_GENERATOR_DOTNET_DESTINATION_PATH_IS_LOADED)
            return CACHE_GENERATOR_DOTNET_DESTINATION_PATH;

        var generatorDotnetDestinationPath = string.Empty;
        try
        {
            // Get the database:
            await using var db = ProcessorMeta.ServiceProvider.GetRequiredService<DataContext>();

            // Check, if the setting is already set:
            if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.GENERATOR_DOTNET_DESTINATION_PATH) is { } existingSetting)
            {
                generatorDotnetDestinationPath = existingSetting.TextValue;
                return generatorDotnetDestinationPath;
            }

            // Does not exist, so create it:
            var setting = new Setting
            {
                Code = SettingNames.GENERATOR_DOTNET_DESTINATION_PATH,
                TextValue = generatorDotnetDestinationPath,
            };

            await db.Settings.AddAsync(setting);
            await db.SaveChangesAsync();
            return generatorDotnetDestinationPath;
        }
        finally
        {
            CACHE_GENERATOR_DOTNET_DESTINATION_PATH_IS_LOADED = true;
            CACHE_GENERATOR_DOTNET_DESTINATION_PATH = generatorDotnetDestinationPath;
        }
    }
    
    public static async Task SetGeneratorDotnetDestinationPath(string path)
    {
        // Update the cache:
        CACHE_GENERATOR_DOTNET_DESTINATION_PATH = path;
        CACHE_GENERATOR_DOTNET_DESTINATION_PATH_IS_LOADED = true;
        
        // Get the database:
        await using var db = ProcessorMeta.ServiceProvider.GetRequiredService<DataContext>();
        
        // Check, if the setting is already set:
        if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.GENERATOR_DOTNET_DESTINATION_PATH) is { } existingSetting)
        {
            existingSetting.TextValue = path;
            await db.SaveChangesAsync();
        }
        
        // Does not exist, so create it:
        else
        {
            var setting = new Setting
            {
                Code = SettingNames.GENERATOR_DOTNET_DESTINATION_PATH,
                TextValue = path,
            };
            
            await db.Settings.AddAsync(setting);
            await db.SaveChangesAsync();
        }
    }
    
    #endregion

    #region .NET Generator Namespace
    
    private static string CACHE_GENERATOR_DOTNET_NAMESPACE = string.Empty;
    private static bool CACHE_GENERATOR_DOTNET_NAMESPACE_IS_LOADED = false;
    
    public static async Task<string> GetGeneratorDotnetNamespace()
    {
        // When possible, use the cache:
        if (CACHE_GENERATOR_DOTNET_NAMESPACE_IS_LOADED)
            return CACHE_GENERATOR_DOTNET_NAMESPACE;

        var generatorDotnetNamespace = "I18N";
        try
        {
            // Get the database:
            await using var db = ProcessorMeta.ServiceProvider.GetRequiredService<DataContext>();

            // Check, if the setting is already set:
            if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.GENERATOR_DOTNET_NAMESPACE) is { } existingSetting)
            {
                generatorDotnetNamespace = existingSetting.TextValue;
                return generatorDotnetNamespace;
            }

            // Does not exist, so create it:
            var setting = new Setting
            {
                Code = SettingNames.GENERATOR_DOTNET_NAMESPACE,
                TextValue = generatorDotnetNamespace,
            };

            await db.Settings.AddAsync(setting);
            await db.SaveChangesAsync();
            return generatorDotnetNamespace;
        }
        finally
        {
            CACHE_GENERATOR_DOTNET_NAMESPACE_IS_LOADED = true;
            CACHE_GENERATOR_DOTNET_NAMESPACE = generatorDotnetNamespace;
        }
    }
    
    public static async Task SetGeneratorDotnetNamespace(string updatedNamespace)
    {
        // Update the cache:
        CACHE_GENERATOR_DOTNET_NAMESPACE = updatedNamespace;
        CACHE_GENERATOR_DOTNET_NAMESPACE_IS_LOADED = true;
        
        // Get the database:
        await using var db = ProcessorMeta.ServiceProvider.GetRequiredService<DataContext>();
        
        // Check, if the setting is already set:
        if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.GENERATOR_DOTNET_NAMESPACE) is { } existingSetting)
        {
            existingSetting.TextValue = updatedNamespace;
            await db.SaveChangesAsync();
        }
        
        // Does not exist, so create it:
        else
        {
            var setting = new Setting
            {
                Code = SettingNames.GENERATOR_DOTNET_NAMESPACE,
                TextValue = updatedNamespace,
            };
            
            await db.Settings.AddAsync(setting);
            await db.SaveChangesAsync();
        }
    }

    #endregion
    
    #region .NET Generator Default Culture
    
    private static int CACHE_GENERATOR_DOTNET_DEFAULT_CULTURE = -1;
    private static bool CACHE_GENERATOR_DOTNET_DEFAULT_CULTURE_IS_LOADED = false;
    
    public static async Task<int> GetGeneratorDotnetDefaultCultureIndex()
    {
        // When possible, use the cache:
        if (CACHE_GENERATOR_DOTNET_DEFAULT_CULTURE_IS_LOADED)
            return CACHE_GENERATOR_DOTNET_DEFAULT_CULTURE;

        var generatorDotnetDefaultCulture = 0;
        try
        {
            // Get the database:
            await using var db = ProcessorMeta.ServiceProvider.GetRequiredService<DataContext>();

            // Check, if the setting is already set:
            if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.GENERATOR_DOTNET_DEFAULT_CULTURE) is { } existingSetting)
            {
                generatorDotnetDefaultCulture = existingSetting.IntegerValue;
                return generatorDotnetDefaultCulture;
            }

            // Does not exist, so create it:
            var setting = new Setting
            {
                Code = SettingNames.GENERATOR_DOTNET_DEFAULT_CULTURE,
                IntegerValue = generatorDotnetDefaultCulture,
            };

            await db.Settings.AddAsync(setting);
            await db.SaveChangesAsync();
            return generatorDotnetDefaultCulture;
        }
        finally
        {
            CACHE_GENERATOR_DOTNET_DEFAULT_CULTURE_IS_LOADED = true;
            CACHE_GENERATOR_DOTNET_DEFAULT_CULTURE = generatorDotnetDefaultCulture;
        }
    }
    
    public static async Task SetGeneratorDotnetDefaultCultureIndex(int updatedCulture)
    {
        // Update the cache:
        CACHE_GENERATOR_DOTNET_DEFAULT_CULTURE = updatedCulture;
        CACHE_GENERATOR_DOTNET_DEFAULT_CULTURE_IS_LOADED = true;
        
        // Get the database:
        await using var db = ProcessorMeta.ServiceProvider.GetRequiredService<DataContext>();
        
        // Check, if the setting is already set:
        if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.GENERATOR_DOTNET_DEFAULT_CULTURE) is { } existingSetting)
        {
            existingSetting.IntegerValue = updatedCulture;
            await db.SaveChangesAsync();
        }
        
        // Does not exist, so create it:
        else
        {
            var setting = new Setting
            {
                Code = SettingNames.GENERATOR_DOTNET_DEFAULT_CULTURE,
                IntegerValue = updatedCulture,
            };
            
            await db.Settings.AddAsync(setting);
            await db.SaveChangesAsync();
        }
    }
    
    #endregion

    #region Godot Generator Enabled/Disabled
    
    private static bool CACHE_GENERATOR_GODOT_ENABLED = true;
    private static bool CACHE_GENERATOR_GODOT_ENABLED_IS_LOADED = false;
    
    public static async Task<bool> GetGeneratorGodotEnabled()
    {
        // When possible, use the cache:
        if (CACHE_GENERATOR_GODOT_ENABLED_IS_LOADED)
            return CACHE_GENERATOR_GODOT_ENABLED;

        var generatorGodotEnabled = false;
        try
        {
            // Get the database:
            await using var db = ProcessorMeta.ServiceProvider.GetRequiredService<DataContext>();

            // Check, if the setting is already set:
            if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.GENERATOR_GODOT_ENABLED) is { } existingSetting)
            {
                generatorGodotEnabled = existingSetting.BoolValue;
                return generatorGodotEnabled;
            }

            // Does not exist, so create it:
            var setting = new Setting
            {
                Code = SettingNames.GENERATOR_GODOT_ENABLED,
                BoolValue = generatorGodotEnabled,
            };

            await db.Settings.AddAsync(setting);
            await db.SaveChangesAsync();
            return generatorGodotEnabled;
        }
        finally
        {
            CACHE_GENERATOR_GODOT_ENABLED_IS_LOADED = true;
            CACHE_GENERATOR_GODOT_ENABLED = generatorGodotEnabled;
        }
    }
    
    public static async Task SetGeneratorGodotEnabled(bool enabled)
    {
        // Update the cache:
        CACHE_GENERATOR_GODOT_ENABLED = enabled;
        CACHE_GENERATOR_GODOT_ENABLED_IS_LOADED = true;
        
        // Get the database:
        await using var db = ProcessorMeta.ServiceProvider.GetRequiredService<DataContext>();
        
        // Check, if the setting is already set:
        if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.GENERATOR_GODOT_ENABLED) is { } existingSetting)
        {
            existingSetting.BoolValue = enabled;
            await db.SaveChangesAsync();
        }
        
        // Does not exist, so create it:
        else
        {
            var setting = new Setting
            {
                Code = SettingNames.GENERATOR_GODOT_ENABLED,
                BoolValue = enabled,
            };
            
            await db.Settings.AddAsync(setting);
            await db.SaveChangesAsync();
        }
    }

    #endregion

    #region Godot Generator Destination Path
    
    private static string CACHE_GENERATOR_GODOT_DESTINATION_PATH = string.Empty;
    private static bool CACHE_GENERATOR_GODOT_DESTINATION_PATH_IS_LOADED = false;
    
    public static async Task<string> GetGeneratorGodotDestinationPath()
    {
        // When possible, use the cache:
        if (CACHE_GENERATOR_GODOT_DESTINATION_PATH_IS_LOADED)
            return CACHE_GENERATOR_GODOT_DESTINATION_PATH;

        var generatorGodotDestinationPath = string.Empty;
        try
        {
            // Get the database:
            await using var db = ProcessorMeta.ServiceProvider.GetRequiredService<DataContext>();

            // Check, if the setting is already set:
            if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.GENERATOR_GODOT_DESTINATION_PATH) is { } existingSetting)
            {
                generatorGodotDestinationPath = existingSetting.TextValue;
                return generatorGodotDestinationPath;
            }

            // Does not exist, so create it:
            var setting = new Setting
            {
                Code = SettingNames.GENERATOR_GODOT_DESTINATION_PATH,
                TextValue = generatorGodotDestinationPath,
            };

            await db.Settings.AddAsync(setting);
            await db.SaveChangesAsync();
            return generatorGodotDestinationPath;
        }
        finally
        {
            CACHE_GENERATOR_GODOT_DESTINATION_PATH_IS_LOADED = true;
            CACHE_GENERATOR_GODOT_DESTINATION_PATH = generatorGodotDestinationPath;
        }
    }
    
    public static async Task SetGeneratorGodotDestinationPath(string path)
    {
        // Update the cache:
        CACHE_GENERATOR_GODOT_DESTINATION_PATH = path;
        CACHE_GENERATOR_GODOT_DESTINATION_PATH_IS_LOADED = true;
        
        // Get the database:
        await using var db = ProcessorMeta.ServiceProvider.GetRequiredService<DataContext>();
        
        // Check, if the setting is already set:
        if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.GENERATOR_GODOT_DESTINATION_PATH) is { } existingSetting)
        {
            existingSetting.TextValue = path;
            await db.SaveChangesAsync();
        }
        
        // Does not exist, so create it:
        else
        {
            var setting = new Setting
            {
                Code = SettingNames.GENERATOR_GODOT_DESTINATION_PATH,
                TextValue = path,
            };
            
            await db.Settings.AddAsync(setting);
            await db.SaveChangesAsync();
        }
    }

    #endregion
    
    #endregion
}