using DigitalData.Core.Abstraction.Application.Repository;
using EnvelopeGenerator.Application.Common.Extensions;
using EnvelopeGenerator.Application.Common.Query;
using EnvelopeGenerator.Domain.Entities;
using MediatR;
using Microsoft.EntityFrameworkCore;
using System.Dynamic;
using System.Text.Json;
using System.Text.Json.Serialization;

namespace EnvelopeGenerator.Application.Annotations.Commands;

/// <summary>
/// 
/// </summary>
public record CreateAnnotationCommand : EnvelopeReceiverQueryBase, IRequest<IEnumerable<Signature>>
{
    private static readonly JsonSerializerOptions SerializerOptions = new()
    {
        PropertyNameCaseInsensitive = true,
        PropertyNamingPolicy = null
    };

    /// <summary>
    /// 
    /// </summary>
    [JsonIgnore]
    public string PSPDFKitInstantJSON 
    {
        set => PSPDFKitInstant = JsonSerializer.Deserialize<dynamic>(value, SerializerOptions) ?? new ExpandoObject();
    }

    /// <summary>
    /// 
    /// </summary>
    [JsonIgnore]
    public ExpandoObject PSPDFKitInstant { get; set; } = null!;
}

/// <summary>
/// 
/// </summary>
public static class CreateAnnotationCommandExtensions
{
    /// <summary>
    /// 
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="envelopeKey"></param>
    /// <param name="cancel"></param>
    /// <returns></returns>
    public static Task<IEnumerable<Signature>> CreateAnnotation(this ISender sender, string envelopeKey, CancellationToken cancel = default) 
        => sender.Send(new CreateAnnotationCommand() { Key = envelopeKey }, cancel);
}

/// <summary>
/// 
/// </summary>
public class CreateAnnotationCommandHandler : IRequestHandler<CreateAnnotationCommand, IEnumerable<Signature>>
{
    /// <summary>
    /// 
    /// </summary>
    private readonly IRepository<Signature> _signRepo;

    /// <summary>
    /// 
    /// </summary>
    private readonly IRepository<Annotation> _annotRepo;

    /// <summary>
    /// 
    /// </summary>
    /// <param name="signRepo"></param>
    /// <param name="annotRepo"></param>
    public CreateAnnotationCommandHandler(IRepository<Signature> signRepo, IRepository<Annotation> annotRepo)
    {
        _signRepo = signRepo;
        _annotRepo = annotRepo;
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="request"></param>
    /// <param name="cancel"></param>
    /// <returns></returns>
    public async Task<IEnumerable<Signature>> Handle(CreateAnnotationCommand request, CancellationToken cancel)
    {
        var query = _signRepo.Query;

        #region Envelope Query
        if (request.Envelope.Id is int envelopeId)
            query = query.Where(annot => annot.Document.EnvelopeId == envelopeId);
        
        if (request.Envelope.Uuid is string envelopeUuid)
            query = query.Where(annot => annot.Document.Envelope!.Uuid == envelopeUuid);
        #endregion

        // Receiver Query
        query = query.Where(request.Receiver);

        var elements = await query.ToListAsync(cancel);        

        foreach (var element in elements)
        {
            var annots = ParsePSPDFKitInstant(request.PSPDFKitInstant, element.Id)
                .Select(annot => new Annotation()
                {
                    ElementId = element.Id,
                    Name = annot.Key,
                    Value = annot.Value,
                    AddedWhen = DateTime.UtcNow
                });

            element.Annotations = await _annotRepo.CreateAsync(annots, cancel);
        }

        return elements;
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="instant"></param>
    /// <param name="elementId"></param>
    /// <returns></returns>
    public static Dictionary<string, string> ParsePSPDFKitInstant(ExpandoObject instant, int elementId)
    {
        Dictionary<string, string> annots = new();

        // parse json here

        return annots;
    }
}