hrynco-notification-service/HrynCo.NotificationService.DAL.EF/Repositories/NotificationServiceRepository.cs

using HrynCo.NotificationService.DAL.Abstract.Repositories;
using HrynCo.NotificationService.DAL.Abstract.Templates;
using HrynCo.NotificationService.DAL.EF.Entities;
using Microsoft.EntityFrameworkCore;

namespace HrynCo.NotificationService.DAL.EF.Repositories;

internal sealed class NotificationServiceRepository(NotificationDbContext db, TemplateMutationRunner mutations) : INotificationServiceRepository
{
    public async Task<IReadOnlyList<NotificationServiceInfo>> GetAllAsync(CancellationToken ct = default)
    {
        var services = await db.Services.AsNoTracking().Include(s => s.Languages).OrderBy(s => s.Name).ToListAsync(ct);
        var counts = await VersionCountsAsync(ct);
        return services.Select(s => Map(s, counts)).ToList();
    }

    public async Task<NotificationServiceInfo?> GetAsync(Guid id, CancellationToken ct = default)
    {
        var service = await db.Services.AsNoTracking().Include(s => s.Languages).SingleOrDefaultAsync(s => s.Id == id, ct);
        return service is null ? null : Map(service, await VersionCountsAsync(ct));
    }

    public async Task<NotificationServiceInfo?> GetByNameAsync(string name, CancellationToken ct = default)
    {
        var service = await db.Services.AsNoTracking().Include(s => s.Languages).SingleOrDefaultAsync(s => s.Name == name, ct);
        return service is null ? null : Map(service, await VersionCountsAsync(ct));
    }

    public async Task<bool> DeleteAsync(Guid id, Guid revision, CancellationToken ct = default)
    {
        var removed = false;
        await mutations.ExecuteAsync(async () =>
        {
            if (revision == Guid.Empty)
                throw new EmailTemplateWriteException("A nonempty service revision is required.", false);
            var service = await db.Services.Include(s => s.Languages).SingleOrDefaultAsync(s => s.Id == id, ct);
            if (service is null)
                return;
            if (service.Revision != revision)
                throw new EmailTemplateWriteException("The service revision changed. Read it again before deleting.");
            await EnsureServiceIsEmptyAsync(id, ct);
            db.ServiceLanguages.RemoveRange(service.Languages);
            db.Services.Remove(service);
            removed = true;
        }, ct);
        return removed;
    }

    private async Task EnsureServiceIsEmptyAsync(Guid id, CancellationToken ct)
    {
        if (await db.TemplateDefinitions.AnyAsync(d => d.ServiceId == id, ct))
            throw new EmailTemplateWriteException("Remove every template definition before deleting this service, including definitions without translations.");
        if (await db.Providers.AnyAsync(c => c.ServiceId == id, ct) || await db.PushChannels.AnyAsync(c => c.ServiceId == id, ct))
            throw new EmailTemplateWriteException("Reassign or remove every notification channel before deleting this service.");
    }

    public Task SaveAsync(NotificationServiceInfo model, bool isNew, CancellationToken ct = default) => mutations.ExecuteAsync(async () =>
    {
        Validate(model);
        var service = await LoadForSaveAsync(model, isNew, ct);
        await ValidateLanguageChangesAsync(service, model, ct);
        await StageLanguageCodeChangesAsync(service, model.Languages, ct);
        service.Name = model.Name;
        SynchronizeLanguages(service, model.Languages);
        Touch(service);
        await TouchDefinitionsAsync(service.Id, ct);
        model.Id = service.Id;
        model.Revision = service.Revision;
    }, ct);

    public Task RemoveLanguageAsync(Guid serviceId, Guid languageId, int expectedVersionCount, Guid expectedRevision, CancellationToken ct = default) =>
        mutations.ExecuteAsync(async () =>
        {
            var service = await db.Services.Include(s => s.Languages).SingleOrDefaultAsync(s => s.Id == serviceId, ct)
                ?? throw new EmailTemplateWriteException("Service no longer exists. Reload services.");
            var language = service.Languages.SingleOrDefault(l => l.Id == languageId)
                ?? throw new EmailTemplateWriteException("Language no longer exists. Reload the service.");
            var versions = await db.Templates.Where(t => t.ServiceLanguageId == languageId).ToListAsync(ct);
            if (service.Revision != expectedRevision || versions.Count != expectedVersionCount)
                throw new EmailTemplateWriteException("The service or affected version count changed. Review the current count and confirm again.");
            db.Templates.RemoveRange(versions);
            // Save dependent removals first because language deletion is restricted by its FK.
            await db.SaveChangesAsync(ct);
            db.ServiceLanguages.Remove(language);
            Touch(service);
            await TouchDefinitionsAsync(serviceId, ct);
        }, ct);

    private async Task<ServiceEntity> LoadForSaveAsync(NotificationServiceInfo model, bool isNew, CancellationToken ct)
    {
        if (await db.Services.AnyAsync(s => s.Name == model.Name && s.Id != model.Id, ct))
            throw new EmailTemplateWriteException("A service with this name already exists.");
        if (isNew)
        {
            var created = new ServiceEntity { Name = model.Name, Created = DateTimeOffset.UtcNow };
            db.Services.Add(created);
            return created;
        }
        var service = await db.Services.Include(s => s.Languages).SingleOrDefaultAsync(s => s.Id == model.Id, ct);
        if (service is null || service.Revision != model.Revision)
            throw new EmailTemplateWriteException("This service changed after you opened it. Reload before saving.");
        return service;
    }

    private async Task ValidateLanguageChangesAsync(ServiceEntity service, NotificationServiceInfo model, CancellationToken ct)
    {
        var ids = service.Languages.Select(l => l.Id).ToHashSet();
        if (model.Languages.Any(l => l.Id != Guid.Empty && !ids.Contains(l.Id)))
            throw new EmailTemplateWriteException("A language changed or was removed. Reload the service.");
        ValidateChangedCodes(service, model.Languages);
        var retained = model.Languages.Select(l => l.Id).ToHashSet();
        var removed = service.Languages.Where(l => !retained.Contains(l.Id)).ToList();
        foreach (var language in removed)
        {
            var count = await db.Templates.CountAsync(t => t.ServiceLanguageId == language.Id, ct);
            if (count > 0)
                throw new EmailTemplateWriteException($"Cannot remove language '{language.Code}': {count} version(s) use it. Use the separate delete-with-versions confirmation.");
        }
    }

    private async Task StageLanguageCodeChangesAsync(ServiceEntity service, IReadOnlyList<ServiceLanguageInfo> languages, CancellationToken ct)
    {
        var requested = languages.Where(l => l.Id != Guid.Empty).ToDictionary(l => l.Id, l => l.Code);
        var removed = service.Languages.Where(l => !requested.ContainsKey(l.Id)).ToList();
        var changed = service.Languages.Where(l => requested.TryGetValue(l.Id, out var code) && code != l.Code).ToList();
        if (removed.Count == 0 && changed.Count == 0)
            return;
        foreach (var language in removed)
        {
            db.ServiceLanguages.Remove(language);
            service.Languages.Remove(language);
        }
        var reserved = service.Languages.Select(l => l.Code).Concat(languages.Select(l => l.Code)).ToHashSet(StringComparer.Ordinal);
        foreach (var language in changed)
            language.Code = TemporaryCode(reserved);
        // Free old codes before final assignments, supporting swaps and replacing unused rows.
        // These temporary identifiers remain invisible outside this transaction.
        await db.SaveChangesAsync(ct);
    }

    private static string TemporaryCode(HashSet<string> reserved)
    {
        string code;
        do { code = "~" + Guid.NewGuid().ToString("N")[..9]; }
        while (!reserved.Add(code));
        return code;
    }

    private void SynchronizeLanguages(ServiceEntity service, IReadOnlyList<ServiceLanguageInfo> languages)
    {
        var retained = languages.Select(l => l.Id).ToHashSet();
        db.ServiceLanguages.RemoveRange(service.Languages.Where(l => !retained.Contains(l.Id)));
        foreach (var model in languages)
        {
            var entity = service.Languages.SingleOrDefault(l => l.Id == model.Id);
            if (entity is null)
                db.ServiceLanguages.Add(new ServiceLanguageEntity { Service = service, Code = model.Code, Created = DateTimeOffset.UtcNow });
            else
                entity.Code = model.Code;
        }
    }

    private async Task TouchDefinitionsAsync(Guid serviceId, CancellationToken ct)
    {
        var definitions = await db.TemplateDefinitions.Where(d => d.ServiceId == serviceId).ToListAsync(ct);
        foreach (var definition in definitions)
        {
            definition.Revision = Guid.NewGuid();
            definition.Updated = DateTimeOffset.UtcNow;
        }
    }

    private Task<Dictionary<Guid, int>> VersionCountsAsync(CancellationToken ct) => db.Templates.AsNoTracking()
        .GroupBy(t => t.ServiceLanguageId).Select(g => new { Id = g.Key, Count = g.Count() })
        .ToDictionaryAsync(g => g.Id, g => g.Count, ct);

    private static void Validate(NotificationServiceInfo service)
    {
        if (string.IsNullOrWhiteSpace(service.Name) || service.Name.Length > 100)
            throw new EmailTemplateWriteException("Service name is required and must be at most 100 characters.", false);
        foreach (var language in service.Languages)
            ValidateCode(language.Code);
        if (service.Languages.Select(l => l.Code).Distinct(StringComparer.Ordinal).Count() != service.Languages.Count)
            throw new EmailTemplateWriteException("Language codes must be unique within the service.", false);
        var ids = service.Languages.Where(l => l.Id != Guid.Empty).Select(l => l.Id).ToList();
        if (ids.Distinct().Count() != ids.Count)
            throw new EmailTemplateWriteException("Each service language can appear only once.", false);
    }

    private static void ValidateCode(string code)
    {
        if (string.IsNullOrWhiteSpace(code) || code.Length > 10)
            throw new EmailTemplateWriteException("Language codes are required and must be at most 10 characters.", false);
    }

    private static void ValidateChangedCodes(ServiceEntity service, IReadOnlyList<ServiceLanguageInfo> languages)
    {
        var persisted = service.Languages.ToDictionary(l => l.Id, l => l.Code);
        foreach (var language in languages)
        {
            if (persisted.TryGetValue(language.Id, out var original) && original == language.Code)
                continue;
            if (!System.Text.RegularExpressions.Regex.IsMatch(language.Code, "^[A-Za-z0-9]+(-[A-Za-z0-9]+)*$"))
                throw new EmailTemplateWriteException("Use letters, numbers and hyphens in new or renamed language codes, without spaces. Codes are case-sensitive.", false);
        }
    }

    private static void Touch(ServiceEntity service)
    {
        service.Revision = Guid.NewGuid();
        service.Updated = DateTimeOffset.UtcNow;
    }

    private static NotificationServiceInfo Map(ServiceEntity service, IReadOnlyDictionary<Guid, int> counts) => new()
    {
        Id = service.Id, Name = service.Name, Revision = service.Revision,
        Languages = service.Languages.OrderBy(l => l.Code).Select(l => new ServiceLanguageInfo
        {
            Id = l.Id, Code = l.Code, VersionCount = counts.GetValueOrDefault(l.Id)
        }).ToList()
    };
}