monorepo/LCU.API.Operations.IncentiveAPI/LCU.API.Internal.Operations.IncentiveApi/Services/EStatementService.cs

using LCU.API.Internal.Operations.IncentiveApi.Exceptions;
using LCU.Library.Internal.IncentiveApiModels.Entities;
using LCU.Library.Internal.IncentiveApiModels.Enums;
using LCU.API.Internal.Operations.IncentiveApiLib.Repositories;
using LCU.API.Internal.Operations.IncentiveApiLib.Services;
using LCU.API.Internal.Operations.IncentiveApi.Services.MicroApiServices;

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

public class EStatementService : IEStatementService
{
    private readonly IProcessorHistoryService _processorHistoryService;
    private readonly ICoreApiWrapperService _coreApiWrapperService;
    private readonly IActivityService _activityService;
    private readonly IActivityRepository _activityRepository;

    public EStatementService(
        IProcessorHistoryService processorHistoryService,
        ICoreApiWrapperService coreApiWrapperService,
        IActivityService activityService,
        IActivityRepository activityRepository
    )
    {
        _processorHistoryService = processorHistoryService;
        _coreApiWrapperService = coreApiWrapperService;
        _activityService = activityService;
        _activityRepository = activityRepository;
    }

    public async Task<IReadOnlyCollection<ActivityStateChange>> UpdateOrExpireEStatementReferral()
    {
        var deliveryMethods = await GetEStatementDeliveryMethods();
        var eStatementReferrals = await _activityRepository.FindPendingEStatementsReferrals();
        var changes = new List<ActivityStateChange>();
        var matchedDeliveryMethods = new List<EStatementDeliveryMethod>();

        foreach (var referral in eStatementReferrals)
        {
            var matchedDeliveryMethod = _activityRepository.FindDeliveryMethodForEStatement(referral, deliveryMethods);

            if (matchedDeliveryMethod != null)
            {
                var change = new ActivityStateChange
                {
                    ActivityId = referral.Id,
                    State = ActivityState.Accepted,
                    Note = $"Delivery method is www for account number {matchedDeliveryMethod.AccountNumber}"
                };

                await _activityService.ApplyStateChange(change);
                changes.Add(change);
                matchedDeliveryMethods.Add(matchedDeliveryMethod);
                await UpdateReferralProperties(referral, matchedDeliveryMethod);
                
                continue;
            }

            var expireRange = DateTime.Today.Subtract(TimeSpan.FromDays(60));
            if (referral.SourceCreated < expireRange)
            {
                var change = new ActivityStateChange
                {
                    ActivityId = referral.Id,
                    State = ActivityState.Rejected,
                    Note = "Referral has expired."
                };
                await _activityService.ApplyStateChange(change);
                changes.Add(change);
            }
        }

        if (matchedDeliveryMethods.Count > 0)
        {
            await UpdateProcessorHistory(matchedDeliveryMethods);                
        }

        return changes;
    }

    private async Task UpdateProcessorHistory(List<EStatementDeliveryMethod> matchedDeliveryMethods)
    {
        await _processorHistoryService.SaveProcessorHistory(new ProcessorHistoryRecord()
        {
            Process = Process.GetDeliveryMethodsFromDna,
            LastSuccessfulRunTime = DateTime.UtcNow,
            LastProcessedRecordId = matchedDeliveryMethods.OrderByDescending(x => x.ActivityNumber).First().ActivityNumber,
            LastProcessedRecordTimestamp = matchedDeliveryMethods.OrderByDescending(x => x.ActivityDateTime).First().ActivityDateTime
        });
    }

    private async Task UpdateReferralProperties(Activity referral, EStatementDeliveryMethod matchedDeliveryMethod)
    {
        referral.MetaData = matchedDeliveryMethod.MetaData.UnionBy(referral.MetaData, x => x.MetaData).ToList();

        referral.Detail.AccountNumber = string.IsNullOrEmpty(referral.Detail.AccountNumber)
            ? matchedDeliveryMethod.AccountNumber.ToString() : referral.Detail.AccountNumber;

        _activityRepository.UpdateActivityRangeAsync(new List<Activity>() { referral });
    }

    private async Task<List<EStatementDeliveryMethod>> GetEStatementDeliveryMethods()
    {
        var lastRun = await _processorHistoryService.GetProcessorHistory(Process.GetDeliveryMethodsFromDna);
        var listDeliveryMethods = new List<EStatementDeliveryMethod>();

        if (lastRun == null)
        {
            throw new MissingProcessorRunHistoryException(Process.GetDeliveryMethodsFromDna);
        }

        var deliveryMethods = await _coreApiWrapperService.GetEStatmentDeliveryMethods(lastRun.LastProcessedRecordTimestamp);
        foreach ( var deliveryMethod in deliveryMethods )
        {
            if ( deliveryMethod != null )
            {
                deliveryMethod.MetaData = SetMetaData(deliveryMethod.PhoneNumbers, deliveryMethod.EmailAddresses);
                listDeliveryMethods.Add( deliveryMethod );
            }
        }
        return listDeliveryMethods;
    }

    public List<ActivityMetaData> SetMetaData(string phoneNumbers, string emailAddresses)
    {
        return DataParsingService.MapActivityMetaData(new List<string> { phoneNumbers, emailAddresses });
    }
}