Cancel Pending Transfer

// Cancel a transfer you no longer want to send
const cancelGiftTransfer = async (transferId: string) => {
  try {
    const response = await fetch(`/api/members/me/transfers/${transferId}/cancel`, {
      method: 'POST'
    });
    
    if (response.ok) {
      const result = await response.json();
      console.log('Transfer cancelled:', result.message);
      
      // Refresh pending transfers list
      refreshPendingTransfers();
      
      // Refresh wallet balance
      refreshWalletBalance();
      
      // Show success message
      showNotification('Gift transfer cancelled. Points returned to your account.');
    }
  } catch (error) {
    console.error('Failed to cancel transfer:', error);
  }
};

// Cancel multiple pending transfers
const cancelMultipleTransfers = async (transferIds: string[]) => {
  const results = [];
  
  for (const transferId of transferIds) {
    try {
      const response = await fetch(`/api/members/me/transfers/${transferId}/cancel`, {
        method: 'POST'
      });
      
      const result = await response.json();
      results.push({
        transferId,
        success: response.ok,
        message: result.message
      });
    } catch (error) {
      results.push({
        transferId,
        success: false,
        error: error.message
      });
    }
  }
  
  const successful = results.filter(r => r.success).length;
  console.log(`Cancelled ${successful}/${transferIds.length} transfers`);
  
  return results;
};

// Cancel transfers that are about to expire
const cancelExpiringTransfers = async () => {
  const pendingTransfers = await getPendingTransfers('sent');
  const expiringThreshold = new Date(Date.now() + 24 * 60 * 60 * 1000); // 24 hours
  
  const expiringTransfers = pendingTransfers.items.filter(transfer => {
    const expiryDate = new Date(transfer.expiresAt);
    return expiryDate <= expiringThreshold && transfer.status === 'PENDING';
  });
  
  if (expiringTransfers.length > 0) {
    const shouldCancel = confirm(
      `You have ${expiringTransfers.length} transfers expiring soon. Cancel them to recover points?`
    );
    
    if (shouldCancel) {
      const results = await cancelMultipleTransfers(
        expiringTransfers.map(t => t.transferId)
      );
      
      const totalRecovered = expiringTransfers
        .filter((_, index) => results[index].success)
        .reduce((sum, transfer) => sum + transfer.amount, 0);
      
      showNotification(`Recovered ${totalRecovered} points from ${results.filter(r => r.success).length} cancelled transfers`);
    }
  }
};

const handleCancellationError = (error: any, transferId: string) => {
  switch (error.error) {
    case 'TRANSFER_NOT_CANCELLABLE':
      if (error.message.includes('claimed')) {
        showMessage('This transfer has already been claimed by the recipient.');
      } else if (error.message.includes('expired')) {
        showMessage('This transfer has expired and cannot be cancelled.');
      } else {
        showMessage('This transfer cannot be cancelled.');
      }
      break;
      
    case 'UNAUTHORIZED':
      showMessage('You can only cancel transfers that you sent.');
      break;
      
    case 'NOT_FOUND':
      showMessage('Transfer not found. It may have already been processed.');
      break;
      
    default:
      showMessage('Unable to cancel transfer. Please try again later.');
  }
};

const cancelWithRetry = async (transferId: string, maxRetries = 2) => {
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      const response = await fetch(`/api/members/me/transfers/${transferId}/cancel`, {
        method: 'POST'
      });
      
      if (response.ok) {
        return await response.json();
      }
      
      if (response.status === 403 && attempt < maxRetries) {
        // Might be reverification required - wait and retry
        await new Promise(resolve => setTimeout(resolve, 1000));
        continue;
      }
      
      throw new Error(`HTTP ${response.status}: ${await response.text()}`);
    } catch (error) {
      if (attempt === maxRetries) throw error;
      
      // Wait before retry
      await new Promise(resolve => setTimeout(resolve, Math.pow(2, attempt) * 1000));
    }
  }
};