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

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

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

public class ActivityDetailService : IActivityDetailService
{
    private readonly IActivityDetailUpdateRepository _activityDetailUpdateRepository;
    private readonly IUnitOfWork _unitOfWork;
    private readonly IDnaService _dnaService;

    public ActivityDetailService(
        IActivityDetailUpdateRepository activityDetailUpdateRepository,
        IUnitOfWork unitOfWork,
        IDnaService dnaService
    )
    {
        _activityDetailUpdateRepository = activityDetailUpdateRepository;
        _unitOfWork = unitOfWork;
        _dnaService = dnaService;
    }

    public async Task<List<ActivityDetailUpdate>> GetAllActivityDetailUpdates(int activityDetailId)
    {
        return await _activityDetailUpdateRepository.GetActivityDetailUpdatesByActivityDetailId(activityDetailId);
    }

    public async Task<List<Activity>> TryUpdateActivityAccountDetails(List<Activity> activities)
    {
        var accountDetails = await _dnaService.GetNewAccountDetailsForActivities(activities);

        var updates = new List<Activity>();
        if (!activities.Any() || !accountDetails.Any())
        {
            return updates;
        }

        foreach (var activity in activities)
        {
            var updateDetails = accountDetails.Where(x => x.AccountNumber.ToString()
                    .Equals(activity.Detail.AccountNumber, StringComparison.InvariantCultureIgnoreCase))
                .ToList();

            if (!updateDetails.Any())
            {
                continue;
            }

            foreach (var detail in updateDetails.Where(detail =>
                         detail.CurrentAccountStatus != null &&
                         detail.CurrentAccountStatus != activity.Detail.AccountStatus))
            {
                await _activityDetailUpdateRepository.SaveActivityDetailUpdate(new ActivityDetailUpdate
                {
                    ActivityDetailId = activity.Detail.Id,
                    Note =
                        $"The Account Status has changed from {activity.Detail.AccountStatus} to {detail.CurrentAccountStatus}"
                });

                activity.Detail.AccountStatus = detail.CurrentAccountStatus;
                updates.Add(activity);
            }
        }

        await _unitOfWork.CompleteAsync();
        return updates;
    }

    public async Task<List<Activity>> TryUpdateLicReferralStationDetail(List<Activity> activities)
    {
        var activityManagerReferrals =
            await _dnaService.QueryActivityManagerForActivities(activities.Select(x => x.SourceId).ToList());

        var updates = new List<Activity>();
        if (!activityManagerReferrals.Any() || !activities.Any())
        {
            return updates;
        }

        foreach (var activity in activities)
        {
            var updateDetails = activityManagerReferrals.Where(x =>
                    x.ActivityId.ToString().Equals(activity.SourceId, StringComparison.InvariantCultureIgnoreCase))
                .ToList();

            if (!updateDetails.Any())
            {
                continue;
            }

            foreach (var detail in updateDetails.Where(detail => detail.ReferralStation != null && activity.Detail.StationName != detail.ReferralStation))
            {
                await _activityDetailUpdateRepository.SaveActivityDetailUpdate(new ActivityDetailUpdate
                {
                    ActivityDetailId = activity.Detail.Id,
                    Note =
                        $"The StationName has changed from {activity.Detail.StationName} to {detail.ReferralStation}"
                });

                activity.Detail.StationName = detail.ReferralStation;

                if (detail.ReferralStation == "LIC Referral-Qualified" || detail.ReferralStation == "LIC Referral- Not Qualified") {
                    activity.Accepted = detail.StationDateTime;
                }

                updates.Add(activity);
            }
        }

        await _unitOfWork.CompleteAsync();
        return updates;
    }

    public async Task<Activity> TryUpdateDpAccessory(Activity saleActivity, Activity dpAccessoryActivity)
    {
        var updatedActivity = await MapAndExecuteActivityDetailUpdate(
            dpAccessoryActivity,
            saleActivity.Detail.DebtProtectionAddDate,
            saleActivity.Detail.DebtProtectionRemoveDate
        );

        await _unitOfWork.CompleteAsync();
        return updatedActivity;
    }

    public async Task<List<Activity>> TryUpdateDpEligibleLoanDetail(List<Activity> existingActivities)
    {
        var updateOrders = new List<ActivityDetailUpdateOrder>();
        var updateActivities = await _dnaService.GetNewAccountDetailsForActivities(existingActivities);

        var updatedActivities = new List<Activity>();
        if (!existingActivities.Any() || !updateActivities.Any())
        {
            return updatedActivities;
        }

        foreach (var activity in existingActivities)
        {
            updateOrders.Add(
                new ActivityDetailUpdateOrder
                {
                    ExistingActivity = activity,
                    DetailUpdates = updateActivities.Where(x => x.AccountNumber.ToString()
                            .Equals(activity.Detail.AccountNumber, StringComparison.InvariantCultureIgnoreCase))
                        .ToList()
                }
            );
        }

        foreach (var updateOrder in updateOrders)
        {
            try
            {
                if (updateOrder.DetailUpdates.Count == 0)
                {
                    continue;
                }

                var latestDpAdded = updateOrder.DetailUpdates.MaxBy(x => x.DebtProtectionEffectiveDate)?.DebtProtectionEffectiveDate;
                var latestDpRemoved = updateOrder.DetailUpdates.OrderByDescending(x => x.DebtProtectionInactiveDate == null)
                    .ThenByDescending(x => x.DebtProtectionInactiveDate)
                    .FirstOrDefault()
                    ?.DebtProtectionInactiveDate;


                if (IsDebtProtectionUpdateNeeded(updateOrder.ExistingActivity, latestDpAdded, latestDpRemoved))
                {
                    updatedActivities.Add(await MapAndExecuteActivityDetailUpdate(updateOrder.ExistingActivity, latestDpAdded, latestDpRemoved));
                }
            }
            catch (Exception ex)
            {
                Log.Error(ex, $"Failed to update activity details for activity ID:{updateOrder.ExistingActivity.Id}");
            }
        }

        await _unitOfWork.CompleteAsync();
        return updatedActivities;
    }

    private static bool IsDebtProtectionUpdateNeeded(Activity activity, DateTime? latestDpAdded, DateTime? latestDpRemoved)
    {
        return activity.Detail.DebtProtectionAddDate?.Date != latestDpAdded?.Date
               || activity.Detail.DebtProtectionRemoveDate?.Date != latestDpRemoved?.Date;
    }

    private async Task<Activity> MapAndExecuteActivityDetailUpdate(Activity activity, DateTime? latestDpAdded, DateTime? latestDpRemoved)
    {
        try
        {
            if (activity.Detail.DebtProtectionAddDate?.Date != latestDpAdded?.Date)
            {
                activity.Detail.DebtProtectionAddDate = latestDpAdded?.Date.AddHours(12);
                await _activityDetailUpdateRepository.SaveActivityDetailUpdate(new ActivityDetailUpdate
                {
                    ActivityDetailId = activity.Detail.Id,
                    Note = $"DebtProtectionAddDate has changed from {activity.Detail.DebtProtectionAddDate?.Date} to {latestDpAdded?.Date}"
                });
            }

            if (activity.Detail.DebtProtectionRemoveDate?.Date != latestDpRemoved?.Date)
            {
                activity.Detail.DebtProtectionRemoveDate = latestDpRemoved?.Date.AddHours(12);
                await _activityDetailUpdateRepository.SaveActivityDetailUpdate(new ActivityDetailUpdate
                {
                    ActivityDetailId = activity.Detail.Id,
                    Note = $"DebtProtectionRemoveDate has changed from {activity.Detail.DebtProtectionRemoveDate?.Date} to {latestDpRemoved?.Date}"
                });
            }
        }
        catch (Exception ex)
        {
            Log.Error(ex, $"Failed to update activity details for activity ID:{activity.Id}");
        }

        return activity;
    }

    public async Task<ActivityDetailUpdate> SaveActivityDetailUpdate(ActivityDetailUpdate activityDetailUpdate)
    {
        return await _activityDetailUpdateRepository.SaveActivityDetailUpdate(activityDetailUpdate);
    }
}