FileTranslator.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;

namespace MN.L10n.JavascriptTranslationMiddleware
{
    public class FileTranslator
    {
        private readonly string _languageId;
        private readonly IJavascriptTranslationL10nLanguageProvider _languageProvider;
        private readonly IFileHandle _fileHandle;
        private readonly Lazy<TranslatedFileInformation> _lazyFileInformation; 
        private readonly SemaphoreSlim _translateSemaphor = new(1);
        private readonly SemaphoreSlim _fileVersionSemaphore = new(1);
        private readonly ILogger _logger;
        private readonly bool _enableFileVersionGeneration;
        private string? _computedFileVersion;

        public FileTranslator(IJavascriptTranslationL10nLanguageProvider languageProvider, IFileHandle fileHandle, string languageId, ILogger<FileTranslator> logger, bool enableFileVersionGeneration)
        {
            _languageId = languageId;
            _logger = logger;
            _fileHandle = fileHandle;
            _languageProvider = languageProvider;
            _lazyFileInformation = new Lazy<TranslatedFileInformation>(GetFileInformation);
            L10n.TranslationsReloaded += L10nOnTranslationsReloaded;
            _logger = logger;
            _enableFileVersionGeneration = enableFileVersionGeneration;
        }

        private void L10nOnTranslationsReloaded(object? sender, EventArgs e)
        {
            HandleTranslationsChangedAsync().GetAwaiter();
        }
        
        public async Task<TranslationResult> TranslateFile(bool reuseExisting)
        {
            var fileInformation = _lazyFileInformation.Value;
            await _translateSemaphor.WaitAsync();

            try
            {
                if (File.Exists(fileInformation.FilePath) && reuseExisting)
                {
                    _logger.LogTrace("File already exists, reusing it");
                    return new TranslationResult
                    {
                        FileInformation = fileInformation,
                        FileVersion = await GetFileVersionAsync(fileInformation)
                    };
                }

                await TranslateAndWriteTranslatedFileAsync(fileInformation);
                return new TranslationResult
                {
                    FileInformation = fileInformation,
                    FileVersion = await GetFileVersionAsync(fileInformation)
                };
            }
            finally
            {
                _translateSemaphor.Release();
            }
        }

        private async Task<string?> GetFileVersionAsync(TranslatedFileInformation fileInformation)
        {
            if (!_enableFileVersionGeneration)
            {
                return null;
            }

            if (_computedFileVersion != null)
            {
                return _computedFileVersion;
            }

            try
            {
                await _fileVersionSemaphore.WaitAsync();
                if (_computedFileVersion != null)
                {
                    return _computedFileVersion;
                }

                await using var stream = File.OpenRead(fileInformation.FilePath);
                return await ComputeFileVersionFromStreamAsync(stream);
            }
            finally
            {
                _fileVersionSemaphore.Release();
            }
        }

        private async Task<string> ComputeFileVersionFromStreamAsync(Stream stream)
        {
            using var md5 = MD5.Create();
            var hash = await md5.ComputeHashAsync(stream);
            var fileVersion = BitConverter.ToString(hash).Replace("-", "").ToLowerInvariant();
            return _computedFileVersion = fileVersion;
        }

        private static string? GetEscapedTranslation(string? translation, char stringContainer)
        {
            if (translation == null)
            {
                return null;
            }

            var quote = stringContainer == '\'' ? '\'' : '"';
            
            //This escapes quotes / special characters and adds surrounding quotes.
            //We remove the surrounding quotes since the source already contain them. 
            var quotedAndEscaped = JsonConvert.ToString(translation, quote);
            return quotedAndEscaped[1..^1];
        }
        
        public string TranslateFileContents(string contents)
        {
            if (!_languageProvider.TryGetLanguage(_languageId, out var language)) return contents;

            var parser = new L10nParser();
            List<L10nParser.PhraseInvocation>? invocations = parser.Parse(contents, true);
            Dictionary<int, L10nParser.PhraseInvocation>? starts = invocations.ToDictionary(i => i.StartChar);

            var pluralPhrases = new Dictionary<string, L10nPhraseObject>();

            StringBuilder translationBuilder = new();
            for (var i = 0; i < contents.Length; i++)
            {
                if (starts.TryGetValue(i + 1, out var invocation) &&
                    language.Phrases.TryGetValue(invocation.Phrase, out var languagePhrase))
                {
                    if (languagePhrase.r.Count > 1)
                    {
                        // Om översättningen innehåller pluralizering behöver vi ha kvar originalet och översätta runtime
                        pluralPhrases[invocation.Phrase] = languagePhrase;
                    }
                    else
                    {
                        var translation = languagePhrase.r.First().Value;
                        translationBuilder.Append(GetEscapedTranslation(translation, invocation.StringContainer));

                        if (invocation.IsEscaped) translationBuilder.Append('\\');

                        i = invocation.EndChar - 1;

                        continue;
                    }
                }

                translationBuilder.Append(contents[i]);
            }

            var translatedCode = translationBuilder.ToString();
            if (pluralPhrases.Count == 0) return translatedCode;

            StringBuilder addPhrasesCode = new("var x = l10n.Phrases;");
            foreach (var (key, value) in pluralPhrases)
                addPhrasesCode.Append($"x[\"{key}\"] = {JsonConvert.SerializeObject(value)};");

            return $@"(function(){{ {addPhrasesCode} }})();{Environment.NewLine}{translatedCode}";
        }

        private async Task HandleTranslationsChangedAsync()
        {
            _logger.LogTrace("Updating translated file because of translations change");
            await _translateSemaphor.WaitAsync();
            await _fileVersionSemaphore.WaitAsync();
            try
            {
                var translatedContents = await TranslateAndWriteTranslatedFileAsync(_lazyFileInformation.Value);
                if (_enableFileVersionGeneration)
                {
                    await ComputeFileVersionFromStreamAsync(new MemoryStream(Encoding.UTF8.GetBytes(translatedContents)));
                }
                else
                {
                    _computedFileVersion = null;
                }
            }
            finally
            {
                _translateSemaphor.Release();
                _fileVersionSemaphore.Release();
            }
        }

        private async Task<string> TranslateAndWriteTranslatedFileAsync(TranslatedFileInformation fileInfo)
        {
            var contents = await _fileHandle.GetFileContentsAsync();
            _logger.LogTrace("Translating file contents");
            var translatedContents = TranslateFileContents(contents);
            await using var fileWriter = File.CreateText(fileInfo.FilePath);
            _logger.LogTrace($"Writing translated contents to disk at {fileInfo.FilePath}");
            await fileWriter.WriteAsync(translatedContents);
            return translatedContents;
        }

        private TranslatedFileInformation GetFileInformation()
        {
            var parts = _fileHandle.Path.Split(Path.DirectorySeparatorChar);
            var tmpNameParts = _fileHandle.FileName.Split(".");
            
            var extension = tmpNameParts[^1];
            var fileName = string.Join(".", tmpNameParts.SkipLast(1));

            var newFileName = fileName + $"__{_languageId}.{extension}";

            var filePath = string.Join(Path.DirectorySeparatorChar, parts.SkipLast(1).Append(newFileName));
            var relativePath = string.Join("/", _fileHandle.RelativeRequestPath.Split("/").SkipLast(1).Append(newFileName));

            return new TranslatedFileInformation(filePath, relativePath);
        }

        ~FileTranslator()
        {
            L10n.TranslationsReloaded -= L10nOnTranslationsReloaded;
        }
    }

    public class TranslationResult
    {
        public string? FileVersion { get; set; }
        public required TranslatedFileInformation FileInformation { get; set; }
    }

    public class TranslatedFileInformation
    {
        public string FilePath { get; }
        public string RelativeRequestPath { get; }
        public TranslatedFileInformation(string filePath, string relativeRequestPath)
        {
            FilePath = filePath;
            RelativeRequestPath = relativeRequestPath;
        }
    }
}