using AutoMapper;
using DigitalData.Core.Abstraction.Application.Repository;
using EnvelopeGenerator.Application.Dto.EnvelopeReceiver;
using EnvelopeGenerator.Domain.Entities;
using MediatR;
using Microsoft.EntityFrameworkCore;

namespace EnvelopeGenerator.Application.EnvelopeReceivers.Queries;

/// <summary>
/// 
/// </summary>
public class ReadEnvelopeReceiverQueryHandler : IRequestHandler<ReadEnvelopeReceiverQuery, EnvelopeReceiverDto?>
{
    private readonly IRepository<EnvelopeReceiver> _repo;

    private readonly IMapper _mapper;

    /// <summary>
    /// 
    /// </summary>
    /// <param name="envelopeReceiver"></param>
    /// <param name="mapper"></param>
    public ReadEnvelopeReceiverQueryHandler(IRepository<EnvelopeReceiver> envelopeReceiver, IMapper mapper)
    {
        _repo = envelopeReceiver;
        _mapper = mapper;
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="request"></param>
    /// <param name="cancel"></param>
    /// <returns></returns>
    /// <exception cref="NotImplementedException"></exception>
    public async Task<EnvelopeReceiverDto?> Handle(ReadEnvelopeReceiverQuery request, CancellationToken cancel)
    {
        var q = _repo.Read();

        if(request.Envelope is not null)
        {
            var env = request.Envelope;
            if (env.Id is not null)
                q = q.Where(er => er.EnvelopeId == env.Id);

            if (env.StatusQ is not null)
            {
                if(env.StatusQ.MinStatus is not null)
                    q = q.Where(er => er.Envelope.Status >= env.StatusQ.MinStatus);

                if(env.StatusQ.MaxStatus is not null)
                    q = q.Where(er => er.Envelope.Status <= env.StatusQ.MaxStatus);

                if(env.StatusQ .Status?.Length > 0)
                    q = q.Where(er => env.StatusQ.Status.Contains(er.Envelope.Status));

                if(env.StatusQ.IgnoredStatus is not null)
                    q = q.Where(er => !env.StatusQ.IgnoredStatus.Contains(er.Envelope.Status));
            }

            if (env.Uuid is not null)
                q = q.Where(er => er.Envelope.Uuid == env.Uuid);
        }

        if (request.Receiver is not null)
        {
            var rcv = request.Receiver;
            if (rcv.Id is not null)
                q = q.Where(r => r.ReceiverId == rcv.Id);

            if (rcv.EmailAddress is not null)
                q = q.Where(r => r.Receiver.EmailAddress == rcv.EmailAddress);

            if (rcv.Signature is not null)
                q = q.Where(er => er.Receiver.Signature == rcv.Signature);
        }

        var er = await q.Include(er => er.Envelope).ThenInclude(e => e.Documents).ThenInclude(d => d.Elements)
                        .Include(er => er.Envelope).ThenInclude(e => e.History)
                        .Include(er => er.Envelope).ThenInclude(e => e.User)
                        .Include(er => er.Receiver)
                        .FirstOrDefaultAsync(cancel);

        return er is null ? null : _mapper.Map<EnvelopeReceiverDto>(er);
    } 
}