using LCU.API.Internal.Operations.IncentiveApi.Exceptions;
using LCU.API.Internal.Operations.IncentiveApiLib.Repositories;
using LCU.Library.Internal.IncentiveApiModels.Entities;
using LCU.Library.Internal.IncentiveApiModels.Common;

namespace LCU.API.Internal.Operations.IncentiveApi.Services;

public class DeadActivityService : IDeadActivityService
{
    private readonly IDeadActivityRepository _deadActivityRepository;
    private readonly IUnitOfWork _unitOfWork;

    public DeadActivityService(IDeadActivityRepository deadActivityRepository, IUnitOfWork unitOfWork)
    {
        _deadActivityRepository = deadActivityRepository;
        _unitOfWork = unitOfWork;
    }

    public async Task<DeadActivity> SaveDeadActivity(DeadActivity newDeadActivity)
    {
       var deadActivity = await SaveDeadActivityRange(new List<DeadActivity>() { newDeadActivity });
       await _unitOfWork.CompleteAsync();
       return deadActivity.FirstOrDefault();
    }

    public async Task<List<DeadActivity>> SaveDeadActivityRange(List<DeadActivity> newDeadActivities)
    {
        var saved = new List<DeadActivity>() { };
        if (!newDeadActivities.Any())
        {
            return  saved;
        }

        var uniqueDeadActivities = await FilterActivitiesByIdentifyingFields(newDeadActivities);
        if (uniqueDeadActivities.Any())
        {
            saved = await _deadActivityRepository.SaveDeadActivityRange(uniqueDeadActivities);
        }
        await _unitOfWork.CompleteAsync();
        return saved;
    }

    public async Task<DeadActivity> GetDeadActivity(int activityId)
    {

        var result = await _deadActivityRepository.GetDeadActivityById(activityId);
        if (result == null)
        {
            throw new NotFoundException("Could not find dead activity with that id");
        }

        return result;
    }

    public async Task<DeadActivity> ProcessDeadActivity(int deadActivityId, int activityRefId)
    {
        var result = await GetDeadActivity(deadActivityId);
        result.LivingActivityId = activityRefId;
        await _unitOfWork.CompleteAsync();
        return result;
    }

    public async Task<List<DeadActivity>> FilterActivitiesByIdentifyingFields(List<DeadActivity> incomingDeadActivities)
    {
        var existingDeadActivity =
            await _deadActivityRepository.GetDeadActivitiesBySourceIds(incomingDeadActivities.Select(x => x.SourceId)
                .Where(x => !string.IsNullOrWhiteSpace(x)).ToList());

        if (existingDeadActivity!= null && existingDeadActivity.Any())
        {
            return incomingDeadActivities
                .Where(newDeadActivity => !existingDeadActivity.Any(existing =>
                    newDeadActivity.Product == existing.Product &&
                    newDeadActivity.Type == existing.Type &&
                    newDeadActivity.SourceId  == existing.SourceId &&
                    newDeadActivity.SourceSystem == existing.SourceSystem  &&
                    newDeadActivity.EmployeeId == existing.EmployeeId &&
                    newDeadActivity.EmployeeEmail?.ToLowerInvariant() == existing.EmployeeEmail?.ToLowerInvariant() &&
                    newDeadActivity.DepartmentId  == existing.DepartmentId  &&
                    newDeadActivity.DeadDetail?.AccountNumber == existing.DeadDetail?.AccountNumber)).ToList();
        }

        return incomingDeadActivities;
    }

    public async Task<PagedResult<DeadActivity>> ListByFilterAsync(DeadActivityFilter filter)
    {
        try
        {
            return await _deadActivityRepository.GetFilteredDeadActivities(filter);
        }
        catch (Exception ex)
        {
            Log.Error(ex, $"Failed to retrieve filtered Actions limit: {filter.Limit}, page: {filter.Page}");
            throw new ServerErrorException();
        }
    }
}