using DigitalData.Core.Abstraction.Application.Repository;
using DigitalData.Core.Exceptions;
using EnvelopeGenerator.Domain.Constants;
using EnvelopeGenerator.Domain.Entities;
using MediatR;
using Microsoft.EntityFrameworkCore;

namespace EnvelopeGenerator.Application.Histories.Queries;

//TODO: Add sender query
/// <summary>
/// Repräsentiert eine Abfrage für die Verlaufshistorie eines Umschlags.
/// </summary>
public record CountHistoryQuery : HistoryQueryBase, IRequest<int>;

/// <summary>
/// 
/// </summary>
public static class CountHistoryQueryExtensions
{
    /// <summary>
    /// 
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="uuid"></param>
    /// <param name="statuses"></param>
    /// <param name="cancel"></param>
    /// <returns></returns>
    public static async Task<bool> AnyHistoryAsync(this ISender sender, string uuid, IEnumerable<EnvelopeStatus> statuses, CancellationToken cancel)
    {
        var count = await sender.Send(new CountHistoryQuery
        {
            Envelope = new() { Uuid = uuid },
            Statuses = new() { Include = statuses }
        }, cancel);
        return count > 0;
    }
}

/// <summary>
/// 
/// </summary>
public class CountHistoryQueryHandler : IRequestHandler<CountHistoryQuery, int>
{
    private readonly IRepository<History> _repo;

    /// <summary>
    /// 
    /// </summary>
    /// <param name="repo"></param>
    public CountHistoryQueryHandler(IRepository<History> repo)
    {
        _repo = repo;
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="request"></param>
    /// <param name="cancel"></param>
    /// <returns></returns>
    /// <exception cref="NotFoundException"></exception>
    public Task<int> Handle(CountHistoryQuery request, CancellationToken cancel = default)
    {
        var query = _repo.Query;

        if (request.Envelope.Id is int envId)
            query = query.Where(e => e.Id == envId);
        else if (request.Envelope.Uuid is string uuid)
            query = query.Where(e => e.Envelope!.Uuid == uuid);
#pragma warning disable CS0618 // Type or member is obsolete
        else if (request.EnvelopeId is not null)
            query = query.Where(h => h.EnvelopeId == request.EnvelopeId);
#pragma warning restore CS0618 // Type or member is obsolete
        else
            throw new BadRequestException("Invalid request: An Envelope object or a valid EnvelopeId/UUID must be supplied.");

#pragma warning disable CS0618 // Type or member is obsolete
        if (request.Status is not null)
            query = query.Where(h => h.Status == request.Status);
#pragma warning restore CS0618 // Type or member is obsolete

        if (request.Statuses is not null)
        {
            var status = request.Statuses;
            if (status.Min is not null)
                query = query.Where(er => er.Envelope!.Status >= status.Min);

            if (status.Max is not null)
                query = query.Where(er => er.Envelope!.Status <= status.Max);

            if (status.Include?.Count() > 0)
                query = query.Where(er => status.Include.Contains(er.Envelope!.Status));

            if (status.Ignore is not null)
                query = query.Where(er => !status.Ignore.Contains(er.Envelope!.Status));
        }

        return query.CountAsync(cancel);
    }
}