public async Task <BulkRegistrationResponse> ProcessBulkRegistrationsAsync(BulkRegistrationRequest request)
        {
            var response = new BulkRegistrationResponse();

            try
            {
                long ukprn       = 10009696;            /*NCFE*/
                var  performedBy = "*****@*****.**"; // Todo: pass-through model or azure-blob

                //await _registrationService.CompareRegistrations();
                //await _registrationService.CompareAndProcessRegistrations();

                using (var fileStream = await _blobStorageService.DownloadFileAsync(_configuration.BlobStorageConnectionString, "registrations", $"{request.Ukprn}/processing/{request.BlobReferencePath}"))
                {
                    if (fileStream == null)
                    {
                        return(response);                    // need to handle response when null
                    }
                    var documentUploadHistory = new DocumentUploadHistory
                    {
                        TlAwardingOrganisationId = 1,
                        FileName      = "Hello",
                        BlobReference = request.BlobReferencePath,
                        DocumentType  = 1,
                        FileType      = 1,
                        Status        = 1, // 1- success , 2 - failed // need to be Enum
                        CreatedBy     = request.performedBy,
                        CreatedOn     = DateTime.UtcNow
                    };


                    var validationResponse = await _csvParserService.ValidateAndParseFileAsync(new RegistrationCsvRecord { FileStream = fileStream });

                    // Stage 2 validation
                    //var validationResponse = await _csvParserService.ValidateAndParseFileAsync(new RegistrationCsvRecord { FileStream = fileStream });

                    if (validationResponse.ResponseModel.Any(x => x.IsFileReadDirty))
                    {
                        response.ValidationErrors = validationResponse.ResponseModel
                                                    .Where(x => x.IsFileReadDirty)
                                                    .Select(x => x.ValidationErrors)
                                                    .FirstOrDefault().ToList();

                        // We are here when unexpected error while reading file, so filedirty is set(above) and add if any half-way row-levels errors(below)
                        // Todo: force test is required or unit-test must check this.
                        response.Registrations = validationResponse.ResponseModel.Where(x => !x.IsValid && !x.IsFileReadDirty);
                        //response.ValidationErrors.AddRange(response.ValidationMessages);

                        documentUploadHistory.Status = 2; // update status to failed
                        await SaveValidationErrorsToBlobStorage(request.Ukprn, request.BlobReferencePath, response.ValidationErrors);
                        await MoveFileAsync($"{request.Ukprn}/processing/{request.BlobReferencePath}", $"{request.Ukprn}/failed/{request.BlobReferencePath}");
                        await CreateDocumentUploadHistory(documentUploadHistory);

                        return(response);
                    }

                    // Stage 3 validation.
                    await _registrationService.ValidateRegistrationTlevelsAsync(ukprn, validationResponse.ResponseModel.Where(x => x.IsValid));

                    if (validationResponse.ResponseModel.Any(x => !x.IsValid))
                    {
                        // Merge both Stage2 and Stage3 validations and return.
                        var invalidRegistrations = validationResponse.ResponseModel.Where(x => !x.IsValid);

                        response.Registrations    = invalidRegistrations;
                        response.ValidationErrors = response.ValidationMessages; // copy
                        response.ErrorFileBytes   = await _csvParserService.WriteErrorFile(response.ValidationErrors);

                        documentUploadHistory.Status = 2;
                        await SaveValidationErrorsToBlobStorage(request.Ukprn, request.BlobReferencePath, response.ValidationErrors);
                        await MoveFileAsync($"{request.Ukprn}/processing/{request.BlobReferencePath}", $"{request.Ukprn}/failed/{request.BlobReferencePath}");
                        await CreateDocumentUploadHistory(documentUploadHistory);

                        return(response);
                    }

                    // Step: Map data to DB model type.
                    var tqRegistrations = _registrationService.TransformRegistrationModel(validationResponse.ResponseModel, performedBy).ToList();

                    // Step: Process DB operation
                    var result = await _registrationService.CompareAndProcessRegistrations(tqRegistrations);

                    if (result.IsSuccess)
                    {
                        await MoveFileAsync($"{request.Ukprn}/processing/{request.BlobReferencePath}", $"{request.Ukprn}/processed/{request.BlobReferencePath}");
                        await CreateDocumentUploadHistory(documentUploadHistory);
                    }
                }
            }
            catch (Exception ex)
            {
                await MoveFileAsync($"{request.Ukprn}/processing/{request.BlobReferencePath}", $"{request.Ukprn}/failed/{request.BlobReferencePath}");
            }

            return(response);
        }