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

namespace Processor;

public static class TranslationProcessor
{
    public static async Task<List<Translation>> GetTranslations(TextElement textElement)
    {
        await using var db = ProcessorMeta.ServiceProvider.GetRequiredService<DataContext>();
        var missedTranslations = new List<Translation>();
        var cultureInfos = await AppSettings.GetCultureInfos();
        foreach (var cultureInfo in cultureInfos)
        {
            if(!await db.Translations.AnyAsync(n => n.TextElement == textElement && n.Culture == cultureInfo.Code))
                missedTranslations.Add(new Translation
                {
                    TranslateManual = false,
                    Culture = cultureInfo.Code,
                    Text = string.Empty,
                });
        }
        
        if(missedTranslations.Count > 0)
        {
            textElement.Translations.AddRange(missedTranslations);
            db.TextElements.Update(textElement);
            await db.SaveChangesAsync();
        }

        return await db.Translations.Where(n => n.TextElement == textElement).ToListAsync();
    }
    
    public static async Task<ProcessorResult<Translation>> SaveChangedTranslation(int translationId, string text, bool manualFLag)
    {
        await using var db = ProcessorMeta.ServiceProvider.GetRequiredService<DataContext>();
        var dbTranslation = await db.Translations.FirstAsync(n => n.Id == translationId);
        dbTranslation.Text = text;
        dbTranslation.TranslateManual = manualFLag;
        
        try
        {
            // Save the changes:
            await db.SaveChangesAsync();
            return new ProcessorResult<Translation>(dbTranslation);
        }
        catch (DbUpdateException updateException)
        {
            return updateException.ToProcessorResult<Translation>();
        }
    }
    
    public static async Task<ProcessorResult<int>> CalculateTranslationProgress()
    {
        await using var db = ProcessorMeta.ServiceProvider.GetRequiredService<DataContext>();
        var numCultures = (await AppSettings.GetCultureIndices()).Count;
        var numTextElements = await db.TextElements.CountAsync();
        var numTotalTranslations = numCultures * numTextElements;
        var numTextElementsTranslated = await db.Translations.CountAsync(n => !string.IsNullOrWhiteSpace(n.Text));
        
        return new ProcessorResult<int>(numTextElementsTranslated * 100 / numTotalTranslations);
    }
}