using DigitalData.Core.Abstraction.Application.Repository;
using DigitalData.EmailProfilerDispatcher.Abstraction.Entities;
using EnvelopeGenerator.Application.Common.Configurations;
using EnvelopeGenerator.Application.Common.Extensions;
using EnvelopeGenerator.Application.Signatures.Commands;
using EnvelopeGenerator.Domain.Constants;
using EnvelopeGenerator.Domain.Entities;
using EnvelopeGenerator.Domain.Interfaces;
using MediatR;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Options;
using Newtonsoft.Json;

namespace EnvelopeGenerator.Application.Signatures.Behaviors;

/// <summary>
/// Pipeline behavior that sends signed mail notification.
/// Executes LAST in the signing process - only if all previous behaviors succeed.
/// </summary>
public class SendSignedMailBehavior : IPipelineBehavior<SignCommand, Unit>
{
    private readonly IRepository<EmailTemplate> _tempRepo;
    private readonly IRepository<EmailOut> _emailOutRepo;
    private readonly MailParams _mailParams;
    private readonly DispatcherParams _dispatcherParams;

    /// <summary>
    /// 
    /// </summary>
    /// <param name="tempRepo"></param>
    /// <param name="emailOutRepo"></param>
    /// <param name="mailParamsOptions"></param>
    /// <param name="dispatcherParamsOptions"></param>
    public SendSignedMailBehavior(
        IRepository<EmailTemplate> tempRepo,
        IRepository<EmailOut> emailOutRepo,
        IOptions<MailParams> mailParamsOptions,
        IOptions<DispatcherParams> dispatcherParamsOptions)
    {
        _tempRepo = tempRepo;
        _emailOutRepo = emailOutRepo;
        _mailParams = mailParamsOptions.Value;
        _dispatcherParams = dispatcherParamsOptions.Value;
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="request"></param>
    /// <param name="next"></param>
    /// <param name="cancellationToken"></param>
    /// <returns></returns>
    public async Task<Unit> Handle(SignCommand request, RequestHandlerDelegate<Unit> next, CancellationToken cancellationToken)
    {
        var placeHolders = CreatePlaceHolders(request);

        var temp = await _tempRepo
            .Where(x => x.Name == EmailTemplateType.DocumentSigned.ToString())
            .SingleOrDefaultAsync(cancellationToken)
                ?? throw new InvalidOperationException($"Email template not found. SignCommand:\n {request.ToJson(Format.Json.ForDiagnostics)}");

        temp.Subject = ReplacePlaceHolders(temp.Subject, placeHolders, _mailParams.Placeholders);
        temp.Body = ReplacePlaceHolders(temp.Body, placeHolders, _mailParams.Placeholders);

        var emailOut = new EmailOut
        {
            EmailAddress = request.EmailAddress,
            EmailBody = temp.Body,
            EmailSubj = temp.Subject,
            AddedWhen = DateTime.Now,
            AddedWho = _dispatcherParams.AddedWho,
            SendingProfile = _dispatcherParams.SendingProfile,
            ReminderTypeId = _dispatcherParams.ReminderTypeId,
            EmailAttmt1 = _dispatcherParams.EmailAttmt1,
            WfId = (int)EnvelopeStatus.MessageConfirmationSent,
            ReferenceString = request.EmailAddress,
            ReferenceId = request.EnvelopeReceiver.ReceiverId
        };

        await _emailOutRepo.CreateAsync(emailOut, cancellationToken);

        return await next(cancellationToken);
    }

    private Dictionary<string, string> CreatePlaceHolders(SignCommand request)
    {
        var placeHolders = new Dictionary<string, string>()
        {
            { "[NAME_RECEIVER]", request.EnvelopeReceiver.Name ?? string.Empty },
            { "[DOCUMENT_TITLE]", request.EnvelopeReceiver.Envelope?.Title ?? string.Empty },
        };

        if (request.EnvelopeReceiver.Envelope.IsReadAndConfirm())
        {
            placeHolders["[SIGNATURE_TYPE]"] = "Lesen und bestätigen";
            placeHolders["[DOCUMENT_PROCESS]"] = string.Empty;
            placeHolders["[FINAL_STATUS]"] = "Lesebestätigung";
            placeHolders["[FINAL_ACTION]"] = "Empfänger bestätigt";
            placeHolders["[REJECTED_BY_OTHERS]"] = "anderen Empfänger abgelehnt!";
            placeHolders["[RECEIVER_ACTION]"] = "bestätigt";
        }
        else
        {
            placeHolders["[SIGNATURE_TYPE]"] = "Signieren";
            placeHolders["[DOCUMENT_PROCESS]"] = " und elektronisch unterschreiben";
            placeHolders["[FINAL_STATUS]"] = "Signatur";
            placeHolders["[FINAL_ACTION]"] = "Vertragspartner unterzeichnet";
            placeHolders["[REJECTED_BY_OTHERS]"] = "anderen Vertragspartner abgelehnt! Ihre notwendige Unterzeichnung wurde verworfen.";
            placeHolders["[RECEIVER_ACTION]"] = "unterschrieben";
        }

        return placeHolders;
    }

    private static string ReplacePlaceHolders(string text, params Dictionary<string, string>[] placeHoldersList)
    {
        foreach (var placeHolders in placeHoldersList)
            foreach (var ph in placeHolders)
                text = text.Replace(ph.Key, ph.Value);
        return text;
    }
}