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 PushTemplateDefinitionRepository(NotificationDbContext db, TemplateMutationRunner mutations)
    : IPushTemplateDefinitionRepository
{
    private IQueryable<PushTemplateDefinitionEntity> Definitions => db.PushTemplateDefinitions
        .Include(d => d.Languages).ThenInclude(l => l.ServiceLanguage);

    public async Task<IReadOnlyList<PushTemplateDefinition>> GetDefinitionsAsync(Guid serviceId, CancellationToken ct = default) =>
        (await Definitions.AsNoTracking().Where(d => d.ServiceId == serviceId).OrderBy(d => d.Key).ToListAsync(ct)).Select(Map).ToList();

    public async Task<PushTemplateDefinition?> GetAsync(Guid serviceId, string key, CancellationToken ct = default)
    {
        var entity = await Definitions.AsNoTracking().SingleOrDefaultAsync(d => d.ServiceId == serviceId && d.Key == key, ct);
        return entity is null ? null : Map(entity);
    }

    public Task SaveAsync(PushTemplateDefinition definition, bool isNew, CancellationToken ct = default) =>
        mutations.ExecuteAsync(() => SaveCoreAsync(definition, isNew, ct), ct);

    private async Task SaveCoreAsync(PushTemplateDefinition definition, bool isNew, CancellationToken ct)
    {
        PushTemplateValidation.Validate(definition);
        var service = await db.Services.Include(s => s.Languages).SingleOrDefaultAsync(s => s.Id == definition.ServiceId, ct)
            ?? throw new EmailTemplateWriteException("Service no longer exists. Reload services.");
        if (definition.Languages.Any(l => !service.Languages.Any(s => s.Code == l.LanguageCode)))
            throw new EmailTemplateWriteException("Every language must exactly match this service's catalog.", false);
        var entity = await LoadForSaveAsync(definition, service, isNew, ct);
        entity.Variables = definition.Variables.Select(v => new PushTemplateVariableData { Name = v.Name, Required = v.Required }).ToList();
        SynchronizeLanguages(entity, service, definition.Languages);
        entity.Revision = Guid.NewGuid();
        entity.Updated = DateTimeOffset.UtcNow;
        definition.Id = entity.Id;
        definition.Revision = entity.Revision;
    }

    public async Task<PushTemplateDefinition?> UpsertDefinitionAsync(PushTemplateDefinitionPatch patch, CancellationToken ct = default)
    {
        PushTemplateDefinition? saved = null;
        await mutations.ExecuteAsync(async () =>
        {
            var service = await db.Services.Include(s => s.Languages).SingleOrDefaultAsync(s => s.Id == patch.ServiceId, ct);
            if (service is null) return;
            ValidatePatch(patch, service);
            var current = await GetAsync(patch.ServiceId, patch.Key, ct);
            var supplied = patch.Translations.Select(t => t.LanguageCode).ToHashSet(StringComparer.Ordinal);
            var removed = patch.RemoveLanguageCodes.ToHashSet(StringComparer.Ordinal);
            saved = new PushTemplateDefinition
            {
                Id = current?.Id ?? Guid.Empty, ServiceId = patch.ServiceId, Key = patch.Key,
                Revision = patch.Revision ?? Guid.Empty, Variables = patch.Variables,
                Languages = (current?.Languages ?? []).Where(l => !supplied.Contains(l.LanguageCode) && !removed.Contains(l.LanguageCode))
                    .Concat(patch.Translations).OrderBy(l => l.LanguageCode, StringComparer.Ordinal).ToList()
            };
            await SaveCoreAsync(saved, patch.Revision is null, ct);
        }, ct);
        return saved;
    }

    private static void ValidatePatch(PushTemplateDefinitionPatch patch, ServiceEntity service)
    {
        PushTemplateValidation.Validate(new PushTemplateDefinition
        {
            ServiceId = patch.ServiceId, Key = patch.Key, Variables = patch.Variables, Languages = patch.Translations
        });
        if (patch.Revision == Guid.Empty)
            throw new EmailTemplateWriteException("Revision must be null for creation or a nonempty revision from the last read for update.", false);
        var removed = patch.RemoveLanguageCodes;
        if (removed.Any(string.IsNullOrWhiteSpace) || removed.Distinct(StringComparer.Ordinal).Count() != removed.Count)
            throw new EmailTemplateWriteException("removeLanguageCodes must contain unique nonblank language codes.", false);
        var supplied = patch.Translations.Select(t => t.LanguageCode).ToHashSet(StringComparer.Ordinal);
        if (removed.Any(supplied.Contains))
            throw new EmailTemplateWriteException("A language cannot be supplied and removed in the same request.", false);
        var supported = service.Languages.Select(l => l.Code).ToHashSet(StringComparer.Ordinal);
        if (supplied.Concat(removed).Any(code => !supported.Contains(code)))
            throw new EmailTemplateWriteException("Every supplied or removed language must exactly match a code in this service's catalog.", false);
    }

    private async Task<PushTemplateDefinitionEntity> LoadForSaveAsync(PushTemplateDefinition model, ServiceEntity service, bool isNew, CancellationToken ct)
    {
        var entity = await Definitions.SingleOrDefaultAsync(d => d.ServiceId == service.Id && d.Key == model.Key, ct);
        if (!isNew)
        {
            if (entity is null || entity.Id != model.Id || entity.Revision != model.Revision)
                throw new EmailTemplateWriteException("This push template changed after you opened it. Reload before saving; your entered values are retained.");
            return entity;
        }
        if (entity is not null)
            throw new EmailTemplateWriteException("A push template with this key already exists.");
        var template = await db.TemplateCatalog.SingleOrDefaultAsync(t => t.ServiceId == service.Id && t.Key == model.Key, ct)
            ?? new TemplateEntity { Service = service, ServiceId = service.Id, Key = model.Key, Created = DateTimeOffset.UtcNow };
        entity = new PushTemplateDefinitionEntity { Template = template, ServiceId = service.Id, Key = model.Key, Created = DateTimeOffset.UtcNow };
        db.PushTemplateDefinitions.Add(entity);
        return entity;
    }

    private void SynchronizeLanguages(PushTemplateDefinitionEntity definition, ServiceEntity service, IReadOnlyList<PushTemplateTranslation> translations)
    {
        var codes = translations.Select(l => l.LanguageCode).ToHashSet(StringComparer.Ordinal);
        db.PushTemplates.RemoveRange(definition.Languages.Where(l => !codes.Contains(l.ServiceLanguage.Code)));
        foreach (var translation in translations)
        {
            var entity = definition.Languages.SingleOrDefault(l => l.ServiceLanguage.Code == translation.LanguageCode);
            if (entity is null)
            {
                entity = new PushTemplateEntity
                {
                    Definition = definition, ServiceId = service.Id,
                    ServiceLanguage = service.Languages.Single(l => l.Code == translation.LanguageCode),
                    Title = translation.Title, Body = translation.Body, Created = DateTimeOffset.UtcNow
                };
                definition.Languages.Add(entity);
                db.PushTemplates.Add(entity);
            }
            entity.Title = translation.Title;
            entity.Body = translation.Body;
            entity.ActionsJson = translation.ActionsJson;
            entity.Updated = DateTimeOffset.UtcNow;
        }
    }

    public async Task<bool> DeleteAsync(Guid serviceId, string key, Guid revision, CancellationToken ct = default)
    {
        if (string.IsNullOrWhiteSpace(key) || key.Length > 100 || revision == Guid.Empty)
            throw new EmailTemplateWriteException("An exact key (at most 100 characters) and a nonempty revision are required.", false);
        var removed = false;
        await mutations.ExecuteAsync(async () => removed = await DeleteCoreAsync(serviceId, key, revision, ct), ct);
        return removed;
    }

    private async Task<bool> DeleteCoreAsync(Guid serviceId, string key, Guid revision, CancellationToken ct)
    {
        var entity = await Definitions.SingleOrDefaultAsync(d => d.ServiceId == serviceId && d.Key == key, ct);
        if (entity is null) return false;
        if (entity.Revision != revision)
            throw new EmailTemplateWriteException("The push template revision changed. Reload before deleting.");
        db.PushTemplateDefinitions.Remove(entity);
        if (!await db.TemplateDefinitions.AnyAsync(d => d.ServiceId == serviceId && d.Key == key, ct))
            db.TemplateCatalog.Remove(await db.TemplateCatalog.SingleAsync(t => t.ServiceId == serviceId && t.Key == key, ct));
        return true;
    }

    private static PushTemplateDefinition Map(PushTemplateDefinitionEntity entity) => new()
    {
        Id = entity.Id, ServiceId = entity.ServiceId, Key = entity.Key, Revision = entity.Revision,
        Variables = entity.Variables.Select(v => new EmailTemplateVariable { Name = v.Name, Required = v.Required }).ToList(),
        Languages = entity.Languages.OrderBy(l => l.ServiceLanguage.Code).Select(l => new PushTemplateTranslation
        {
            LanguageCode = l.ServiceLanguage.Code, Title = l.Title, Body = l.Body, ActionsJson = l.ActionsJson
        }).ToList()
    };
}