/**
   * Performs some static checks and loads the transfers to be chargedback by the bulk reverse
   * operation.
   *
   * @param ids: Could be trace numbers or transfer ids.
   * @param loader: The object responsible for loading the transfer by trace number or transferId.
   */
  private <V> List<ChargebackResult> doBulkChargeback(
      final List<V> ids, final TransferLoader<V> loader) {
    final List<Transfer> transfers = new LinkedList<Transfer>();
    final List<AccountDTO> allAccounts = new LinkedList<AccountDTO>();
    final Member member = WebServiceContext.getMember();
    final List<ChargebackResult> result = new LinkedList<ChargebackResult>();
    boolean failed = false;

    for (final V id : ids) {
      Transfer transfer = null;
      try {
        transfer = loader.load(id);
        transfers.add(transfer);
        if (member != null && !transfer.getToOwner().equals(member)) {
          throw new EntityNotFoundException();
        }
        result.add(new ChargebackResult(ChargebackStatus.NOT_PERFORMED, null, null));
        allAccounts.add(new AccountDTO(transfer.getFrom()));
        allAccounts.add(new AccountDTO(transfer.getTo()));
      } catch (final EntityNotFoundException e) {
        failed = true;
        result.add(new ChargebackResult(ChargebackStatus.TRANSFER_NOT_FOUND, null, null));
        webServiceHelper.error(
            new Exception(
                "Bulk status [Id=" + id + "]: " + ChargebackStatus.TRANSFER_NOT_FOUND, e));
      }
    }

    if (failed) {
      return result;
    }

    return bulkReverse(transfers, allAccounts);
  }
  private ChargebackResult doChargeback(final Transfer transfer) {
    ChargebackStatus status = null;
    Transfer chargebackTransfer = null;

    // Check if the transfer can be charged back
    if (!paymentService.canChargeback(transfer, false)) {
      if (transfer.getChargedBackBy() != null) {
        chargebackTransfer = transfer.getChargedBackBy();
        status = ChargebackStatus.TRANSFER_ALREADY_CHARGEDBACK;
      } else {
        if (transfer.getStatus() == Payment.Status.PENDING) {
          final TransferAuthorizationDTO transferAuthorizationDto = new TransferAuthorizationDTO();
          transferAuthorizationDto.setTransfer(transfer);
          transferAuthorizationDto.setShowToMember(false);
          chargebackTransfer =
              transferAuthorizationService.cancelFromMemberAsReceiver(transferAuthorizationDto);
          status = ChargebackStatus.SUCCESS;
        } else {
          status = ChargebackStatus.TRANSFER_CANNOT_BE_CHARGEDBACK;
        }
      }
    }

    // Do the chargeback
    if (status == null) {
      chargebackTransfer =
          paymentService.chargeback(transfer, WebServiceContext.getClient().getId());
      status = ChargebackStatus.SUCCESS;
    }

    if (!status.isSuccessful()) {
      webServiceHelper.error("Chargeback result: " + status);
    }

    final Member member = WebServiceContext.getMember();
    // Build the result
    if (status == ChargebackStatus.SUCCESS
        || status == ChargebackStatus.TRANSFER_ALREADY_CHARGEDBACK) {
      final AccountOwner owner = member == null ? transfer.getToOwner() : member;
      final AccountHistoryTransferVO originalVO = accountHelper.toVO(owner, transfer, null);
      final AccountHistoryTransferVO chargebackVO =
          accountHelper.toVO(owner, chargebackTransfer, null);
      return new ChargebackResult(status, originalVO, chargebackVO);
    } else {
      return new ChargebackResult(status, null, null);
    }
  }
  @Override
  protected void prepareForm(final ActionContext context) throws Exception {
    final Transfer transfer = resolveTransfer(context);

    // Check for transaction password
    final HttpServletRequest request = context.getRequest();
    final boolean requestTransactionPassword = shouldValidateTransactionPassword(context, transfer);
    if (requestTransactionPassword) {
      context.validateTransactionPassword();
    }
    request.setAttribute("requestTransactionPassword", requestTransactionPassword);
    request.setAttribute(
        "wouldRequireAuthorization", paymentService.wouldRequireAuthorization(transfer));

    // Transfer number and number of transfers
    final int transferNumber = getTransferNumber(transfer);
    final int numberOfTransfers = getNumberOfTransfer(transfer);
    request.setAttribute("transferNumber", transferNumber);
    request.setAttribute("numberOfTransfers", numberOfTransfers);

    // Fetch related data
    final AccountOwner from = transfer.getFromOwner();
    final AccountOwner to = transfer.getToOwner();
    final TransferType transferType =
        transferTypeService.load(
            transfer.getType().getId(),
            RelationshipHelper.nested(
                TransferType.Relationships.FROM, AccountType.Relationships.CURRENCY),
            TransferType.Relationships.TO);
    final BigDecimal amount = transfer.getAmount();
    if (from instanceof Member) {
      request.setAttribute("fromMember", from);
    }
    if (to instanceof Member) {
      request.setAttribute("toMember", to);
    }
    transfer.setType(transferType);
    request.setAttribute("unitsPattern", transferType.getFrom().getCurrency().getPattern());

    // Store the transaction fees
    final TransactionFeePreviewDTO preview =
        transactionFeeService.preview(from, to, transferType, amount);
    request.setAttribute("finalAmount", preview.getFinalAmount());
    request.setAttribute("fees", preview.getFees());
    request.setAttribute("transfer", transfer);
  }
  private <V> ChargebackResult reverse(final V transferId, final TransferLoader<V> loader) {
    Exception errorException = null;
    ChargebackStatus status = null;
    Transfer transfer = null;

    try {
      transfer = loader.load(transferId);
      // Ensure the member is the one who received the payment
      final Member member = WebServiceContext.getMember();
      if (member != null && !transfer.getToOwner().equals(member)) {
        throw new EntityNotFoundException();
      } else {
        final Collection<TransferType> possibleTypes =
            fetchService
                .fetch(
                    WebServiceContext.getClient(),
                    ServiceClient.Relationships.CHARGEBACK_PAYMENT_TYPES)
                .getChargebackPaymentTypes();
        if (!possibleTypes.contains(transfer.getType())) {
          throw new EntityNotFoundException();
        }
      }
    } catch (final EntityNotFoundException e) {
      errorException = e;
      status = ChargebackStatus.TRANSFER_NOT_FOUND;
    }

    if (status == null) {
      try {
        return doChargeback(transfer);
      } catch (final Exception e) {
        webServiceHelper.error(e);
        return new ChargebackResult(ChargebackStatus.TRANSFER_CANNOT_BE_CHARGEDBACK, null, null);
      }
    } else {
      if (!status.isSuccessful()) {
        webServiceHelper.error(
            errorException != null
                ? errorException
                : new Exception("Chargeback status: " + status));
      }
      return new ChargebackResult(status, null, null);
    }
  }