monorepo/LCU.API.Internal.MemberPreferencesApi/LCU.API.Internal.MemberPreferencesApi/Services/XdiServices/XdiBatchService.cs

using LCU.API.Internal.MemberPreferencesApi.MicroApiServices;
using LCU.API.Internal.MemberPreferencesApi.Models;
using LCU.API.Internal.MemberPreferencesApiLib.Repositories;
using LCU.Library.Internal.MemberPreferencesApiModels.Entities;
using LCU.Library.Internal.MemberPreferencesApiModels.Enums;
using LCU.Library.Internal.MemberPreferencesApiModels.Responses;
using FileOperationsModels = LCU.Library.Internal.FileOperationsModels.Models;

namespace LCU.API.Internal.MemberPreferencesApi.Services.XdiServices
{
    public class XdiBatchService : IXdiBatchService
    {
        private readonly IXdiBatchItemsRepository _xdiBatchItemsRepository;
        private readonly IUnifiedOptInRepository _unifiedOptInRepository;
        private readonly IMemberPreferenceRepository _memberPreferenceRepository;
        private readonly IUnitOfWork _unitOfWork;
        private readonly IFileOperationsApiService _fileOperationsApiService;
        private const string XdiBatchProcessOperatorName = "XdiBatchProcess";

        public XdiBatchService(IXdiBatchItemsRepository xdiBatchItemsRepository,
            IUnitOfWork unitOfWork, IUnifiedOptInRepository unifiedOptInRepository,
            IMemberPreferenceRepository memberPreferencesRepository, IFileOperationsApiService fileOperationsApiService) 
        {
            _xdiBatchItemsRepository = xdiBatchItemsRepository;
            _unitOfWork = unitOfWork;
            _memberPreferenceRepository = memberPreferencesRepository;
            _unifiedOptInRepository = unifiedOptInRepository;
            _fileOperationsApiService = fileOperationsApiService;
        }

        public async Task<RequestResponse> CreateXdiBatchFiles(XdiBatchRequest request)
        {
            var requestResponse = new RequestResponse();
            try
            {
               request = await BuildXdiBatchRequest(request);
               requestResponse = await CreateXdiExportFileRequest(request);
            }
            catch (Exception ex)
            {
                var batchUserIds = string.Join(",", request.XdiBatchItems.Select(c => c.UserId).ToList());
                var errorMessage = $"Failed to Create XDI Batch Files for UserId(s): {batchUserIds} Error: { ex.Message}";
                Log.Error(errorMessage);
                requestResponse.MessageStack.Add(errorMessage);
                requestResponse.IsSuccessful = false;
            }
            return requestResponse;
        }

        public async Task<XdiBatchRequest> BuildXdiBatchRequest(XdiBatchRequest request)
        {
            foreach (var item in request.XdiBatchItems)
            {
                var currentSettings = await _unifiedOptInRepository.GetMemberOptInSettings(item.UserId);
                if (currentSettings != null)
                {
                    var result = request.XdiBatch.ProcessItem(item, currentSettings);
                    if (result == true)
                    {
                        _xdiBatchItemsRepository.Delete(item);
                        await _xdiBatchItemsRepository.SaveAsync(new XdiBatchItem()
                        {
                            UserId = item.UserId,
                            Created = item.Created,
                            BatchState = BatchState.TransferPending,
                            LastUpdated = DateTime.UtcNow
                        });
                        Log.Information($"XdiBatchService processed batch item with UserId: {item.UserId}");
                    }
                    else
                    {
                        Log.Error($"No XdiBatchRow or XDI File was processed based on current member UserId: {item.UserId} Opt In Settings, marking complete.");
                        _xdiBatchItemsRepository.Delete(item);
                    }
                }
                ;
            }
            ;

            await _unitOfWork.CompleteAsync(XdiBatchProcessOperatorName, DateTime.UtcNow, UserType.System);

            return request;
        }

        public async Task<RequestResponse> CreateXdiExportFileRequest(XdiBatchRequest request)
        {
            var requestResponse = new RequestResponse();
            try
            {
                IReadOnlyCollection<XdiBatchFile> batchFiles = request.XdiBatch.GetNonEmptyFiles();
                var batchFilesMessage = ($"XdiBatchService produced {batchFiles.Count} file(s)");
                Log.Information(batchFilesMessage);

                foreach (var xdiBatchFile in batchFiles)
                {
                    var xdiBatchFileExport = await BuildXdiFiles(xdiBatchFile, request.XdiAppendFileRootBasePath);
                    if (xdiBatchFileExport != null)
                    {
                        await MarkPendingSuccessful(xdiBatchFileExport);
                    }
                }
                requestResponse.IsSuccessful = true;
                requestResponse.MessageStack.Add(batchFilesMessage);
             }
            catch (Exception ex)
            {
                var errorMessage = $"Failed to Create the XDI File to export. {ex.Message}";
                Log.Error(errorMessage);
                requestResponse.MessageStack.Add(errorMessage);
                requestResponse.IsSuccessful = false;
            }
            return requestResponse;
        }

        public async Task<List<XdiBatchFileExport>> BuildXdiFiles(XdiBatchFile batchFile, string filePath)
        {
            FileOperationsModels.AppendFileRequest request = BuildFileOperationsRequest(batchFile, filePath);
            var xdiBatchFileExport = await CreateDirectoryXdiFiles(batchFile);
            var result = await _fileOperationsApiService.AppendFile(request);
            if (!result.IsSuccessful)
            {
                throw new Exception($"Failed to Append File: {batchFile.GetFileName}");
            }

            return xdiBatchFileExport;
        }

        private FileOperationsModels.AppendFileRequest BuildFileOperationsRequest(XdiBatchFile xdiBatchFile, string filePath)
        {
            var request = new FileOperationsModels.AppendFileRequest()
            {
                DestinationPath = filePath,
                Extension = ".txt",
                FileData = xdiBatchFile.ConvertToDataFile(),
                FileName = xdiBatchFile.GetFileName()
            };
            return request;
        }

        public async Task<List<XdiBatchFileExport>> CreateDirectoryXdiFiles(XdiBatchFile xdiBatchFile)
        {
            List<XdiBatchFileExport> batchFileExportList = new List<XdiBatchFileExport>();
            var userIds = xdiBatchFile.Data.Select(x => x.UserId).ToList();

            foreach (var userId in userIds)
            {
                var settings = await _unifiedOptInRepository.GetMemberOptInSettingsNoTracking(userId);
                if (settings != null)
                {
                    batchFileExportList.Add(new XdiBatchFileExport
                    {
                        UserId = userId,
                        Value = settings.UniversalOptIn == DeliveryPreference.Electronic
                            ? settings.UnifiedOptInEmail
                            : DeliveryPreference.Paper
                    });
                }
            }
            return batchFileExportList;
        }

        public async Task AddXdiBatchItem(XdiBatchItem newItem)
        {
            try
            {
                var existing = await _xdiBatchItemsRepository.FindExistingItem(newItem.UserId, BatchState.New);
                if (existing != null)
                {
                    existing.LastUpdated = newItem.Created;
                    _xdiBatchItemsRepository.Update(existing);
                }
                else
                {
                    await _xdiBatchItemsRepository.SaveAsync(newItem);
                }

                await _unitOfWork.CompleteAsync();
            }
            catch (Exception ex)
            {
                Log.Error($"AddXdiBatchItem userId {newItem.UserId} error: " + ex.Message);
            }
        }

        public async Task SaveRangeAsync(List<XdiBatchItem> xdiBatchItemList)
        {
            try
            {
                await _xdiBatchItemsRepository.SaveRangeAsync(xdiBatchItemList);
                await _unitOfWork.CompleteAsync();
            }
            catch (Exception ex)
            {
                Log.Error($"SaveRangeAsync method error: " + ex.Message);
            }
        }

        public async Task<bool> DoesMemberHavePendingXdiChange(string userId)
        {
            return await _xdiBatchItemsRepository.FindExistingItem(userId, BatchState.TransferPending) != null;
        }

        public async Task<bool> MarkPendingSuccessful(List<XdiBatchFileExport> batchFileExportList)
        {
            try
            {
                Log.Information($"Marking {batchFileExportList.Count} Batch Items Successful.");
                var memberIds = batchFileExportList.Select(x => x.UserId);
                var pendingComplete = await _xdiBatchItemsRepository.MarkPendingSuccessful(memberIds.ToList());

                if (pendingComplete)
                {
                    await UpdateMemberPreferenceEntries(batchFileExportList);
                }

                await _unitOfWork.CompleteAsync(XdiBatchProcessOperatorName, DateTime.UtcNow, UserType.System);
                return pendingComplete;
            }
            catch (Exception ex)
            {
                Log.Error(ex, $"Unexpected Error attempting to Mark Pending Items Successful.");
                throw;
            }
        }

        private async Task UpdateMemberPreferenceEntries(List<XdiBatchFileExport> batchFileExport)
        {
            foreach (var item in batchFileExport)
            {
                var settings = await _unifiedOptInRepository.GetOrCreateMemberOptinSettings(item.UserId);

                if (item.Value == DeliveryPreference.Paper)
                {
                    var paperPreference = new MemberPreference
                    {
                        UserId = item.UserId,
                        LegalReference = DateTime.Now.ToString("s"),
                        Preference = PreferenceType.ENotification,
                        Value = DeliveryPreference.Paper
                    };

                    await _memberPreferenceRepository.SaveMemberPreferenceAsync(paperPreference);
                    settings.Apply(paperPreference);
                }
                else
                {
                    await _memberPreferenceRepository.BulkSaveMemberPreferenceAsync(new List<MemberPreference>()
                    {
                        new MemberPreference()
                        {
                            UserId = item.UserId,
                            LegalReference = DateTime.Now.ToString("s"),
                            Preference = PreferenceType.ENotification,
                            Value = DeliveryPreference.Electronic
                        },
                        new MemberPreference()
                        {
                            UserId = item.UserId,
                            LegalReference = DateTime.Now.ToString("s"),
                            Preference = PreferenceType.ENotificationsEmail,
                            Value = item.Value
                        }
                    });
                }
            }
        }
    }
}