using MediatR;
using cuqmbr.TravelGuide.Application.Common.Persistence;
using AutoMapper;
using cuqmbr.TravelGuide.Application.Common.Models;
using cuqmbr.TravelGuide.Application.Common.Extensions;

namespace cuqmbr.TravelGuide.Application.Employees.Queries.GetEmployeesPage;

public class GetEmployeesPageQueryHandler :
    IRequestHandler<GetEmployeesPageQuery, PaginatedList<EmployeeDto>>
{
    private readonly UnitOfWork _unitOfWork;
    private readonly IMapper _mapper;

    public GetEmployeesPageQueryHandler(
        UnitOfWork unitOfWork,
        IMapper mapper)
    {
        _unitOfWork = unitOfWork;
        _mapper = mapper;
    }

    public async Task<PaginatedList<EmployeeDto>> Handle(
        GetEmployeesPageQuery request,
        CancellationToken cancellationToken)
    {
        var paginatedList = await _unitOfWork.EmployeeRepository.GetPageAsync(
            e =>
                (e.FirstName.ToLower().Contains(request.Search.ToLower()) ||
                e.LastName.ToLower().Contains(request.Search.ToLower()) ||
                e.Patronymic.ToLower().Contains(request.Search.ToLower()) ||
                e.Documents
                    .Select(d => d.Information.ToLower())
                    .Contains(request.Search.ToLower())) &&
                (request.CompanyGuid != null
                    ? e.Company.Guid == request.CompanyGuid
                    : true) &&
                (request.Sex != null
                    ? e.Sex == request.Sex
                    : true) &&
                (request.BirthDateLessThanOrEqualTo != null
                    ? e.BirthDate <= request.BirthDateLessThanOrEqualTo
                    : true) &&
                (request.BirthDateGreaterThanOrEqualTo != null
                    ? e.BirthDate >= request.BirthDateGreaterThanOrEqualTo
                    : true),
            e => e.Documents,
            request.PageNumber, request.PageSize,
            cancellationToken);


        // Hydrate employees

        var companies = await _unitOfWork.CompanyRepository.GetPageAsync(
            e => paginatedList.Items.Select(e => e.CompanyId).Contains(e.Id),
            1, paginatedList.Items.Count, cancellationToken);

        foreach (var employee in paginatedList.Items)
        {
            employee.Company = 
                companies.Items.First(c => c.Id == employee.CompanyId);
        }

        var accountIds = paginatedList.Items.Select(e => e.AccountId);
        var accounts = await _unitOfWork.AccountRepository.GetPageAsync(
            e => accountIds.Contains(e.Id),
            1, paginatedList.Items.Count, cancellationToken);

        foreach (var employee in paginatedList.Items)
        {
            employee.Account = 
                accounts.Items.First(a => a.Id == employee.AccountId);
        }


        var mappedItems = _mapper
            .ProjectTo<EmployeeDto>(paginatedList.Items.AsQueryable());

        mappedItems = QueryableExtension<EmployeeDto>
            .ApplySort(mappedItems, request.Sort);

        _unitOfWork.Dispose();

        return new PaginatedList<EmployeeDto>(
            mappedItems.ToList(),
            paginatedList.TotalCount, request.PageNumber,
            request.PageSize);
    }
}