Imports System.Net.Http
Imports System.Text
Imports System.Text.Json
Imports System.Linq

Public Class PaymentMethodClient
    Private ReadOnly _httpClient As HttpClient
    Private ReadOnly _baseUrl As String
    Private ReadOnly _bearerToken As String

    Public Sub New(baseUrl As String, bearerToken As String)
        _baseUrl = baseUrl
        _bearerToken = bearerToken
        _httpClient = New HttpClient()
        _httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {bearerToken}")
    End Sub

    ' Delete a single saved payment method
    Public Async Function DeleteSavedPaymentMethodAsync(
        merchantId As String,
        payorId As String,
        savedPaymentMethodId As String) As Task(Of SavedPaymentMethodResponse)

        Dim endpoint As String = $"{_baseUrl}/v1/rest/merchants/{merchantId}/payors/{payorId}/savedPaymentMethods/{savedPaymentMethodId}"

        Dim response As HttpResponseMessage = Await _httpClient.DeleteAsync(endpoint)

        If response.StatusCode = Net.HttpStatusCode.NotFound Then
            Throw New Exception("Payment method not found. It may have already been deleted or does not exist.")
        End If

        response.EnsureSuccessStatusCode()

        Dim json As String = Await response.Content.ReadAsStringAsync()
        Return JsonSerializer.Deserialize(Of SavedPaymentMethodResponse)(json)
    End Function

    ' Helper: Get all active payment methods before deleting
    Public Async Function GetActiveSavedPaymentMethodsAsync(
        merchantId As String,
        payorId As String) As Task(Of List(Of SavedPaymentMethodResponse))

        Dim endpoint As String = $"{_baseUrl}/v1/rest/merchants/{merchantId}/payors/{payorId}/savedPaymentMethods"

        Dim response As HttpResponseMessage = Await _httpClient.GetAsync(endpoint)
        response.EnsureSuccessStatusCode()

        Dim json As String = Await response.Content.ReadAsStringAsync()
        Dim allMethods As List(Of SavedPaymentMethodResponse) = JsonSerializer.Deserialize(Of List(Of SavedPaymentMethodResponse))(json)

        ' Filter to only active (non-deleted) methods
        Return allMethods.Where(Function(m) Not m.IsDeleted).ToList()
    End Function

    ' Safe delete: Verify not the last payment method before deleting
    Public Async Function SafeDeleteSavedPaymentMethodAsync(
        merchantId As String,
        payorId As String,
        savedPaymentMethodId As String) As Task(Of SavedPaymentMethodResponse)

        ' First, get all active payment methods
        Dim activeMethods As List(Of SavedPaymentMethodResponse) = Await GetActiveSavedPaymentMethodsAsync(merchantId, payorId)

        If activeMethods.Count <= 1 Then
            Throw New InvalidOperationException(
                "Cannot delete the last remaining payment method. The payor must have at least one active payment method.")
        End If

        ' Safe to delete
        Return Await DeleteSavedPaymentMethodAsync(merchantId, payorId, savedPaymentMethodId)
    End Function
End Class

' Usage example
Module Program
    Sub Main()
        MainAsync().Wait()
    End Sub

    Async Function MainAsync() As Task
        Dim baseUrl As String = "https://api.example.com"
        Dim bearerToken As String = "your-oauth-token-here"
        Dim merchantId As String = "12345678901"
        Dim payorId As String = "550e8400-e29b-41d4-a716-446655440000"
        Dim paymentMethodToDelete As String = "7c9e6679-7425-40de-944b-e07fc1f90ae7"

        Dim client As New PaymentMethodClient(baseUrl, bearerToken)

        Try
            ' Safe delete with validation
            Dim result As SavedPaymentMethodResponse = Await client.SafeDeleteSavedPaymentMethodAsync(
                merchantId, payorId, paymentMethodToDelete)

            Console.WriteLine($"Payment method deleted: {result.MaskedAccountNumber}")
            Console.WriteLine($"Account type: {result.AccountType}")
            Console.WriteLine($"Is deleted: {result.IsDeleted}")

        Catch ex As InvalidOperationException
            Console.WriteLine($"Cannot delete: {ex.Message}")
        Catch ex As Exception
            Console.WriteLine($"Error: {ex.Message}")
        End Try
    End Function
End Module

Public Class SavedPaymentMethodResponse
    Public Property PayorId As String
    Public Property SavedPaymentMethodId As String
    Public Property MaskedAccountNumber As String
    Public Property AccountType As String
    Public Property IsDefault As Boolean
    Public Property IsDeleted As Boolean
    Public Property SponsorKey As String
End Class
    

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.List;
import java.util.stream.Collectors;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.core.type.TypeReference;

public class PaymentMethodClient {
    private final HttpClient httpClient;
    private final String baseUrl;
    private final String bearerToken;
    private final ObjectMapper objectMapper;

    public PaymentMethodClient(String baseUrl, String bearerToken) {
        this.baseUrl = baseUrl;
        this.bearerToken = bearerToken;
        this.httpClient = HttpClient.newHttpClient();
        this.objectMapper = new ObjectMapper();
    }

    // Delete a single saved payment method
    public SavedPaymentMethodResponse deleteSavedPaymentMethod(
            String merchantId,
            String payorId,
            String savedPaymentMethodId) throws IOException, InterruptedException {

        String endpoint = String.format("%s/v1/rest/merchants/%s/payors/%s/savedPaymentMethods/%s",
                baseUrl, merchantId, payorId, savedPaymentMethodId);

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(endpoint))
                .header("Authorization", "Bearer " + bearerToken)
                .DELETE()
                .build();

        HttpResponse response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());

        if (response.statusCode() == 404) {
            throw new RuntimeException("Payment method not found. It may have already been deleted or does not exist.");
        }

        if (response.statusCode() != 200) {
            throw new RuntimeException("Failed to delete payment method: " + response.statusCode() +
                    " - " + response.body());
        }

        return objectMapper.readValue(response.body(), SavedPaymentMethodResponse.class);
    }

    // Helper: Get all active payment methods before deleting
    public List getActiveSavedPaymentMethods(
            String merchantId,
            String payorId) throws IOException, InterruptedException {

        String endpoint = String.format("%s/v1/rest/merchants/%s/payors/%s/savedPaymentMethods",
                baseUrl, merchantId, payorId);

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(endpoint))
                .header("Authorization", "Bearer " + bearerToken)
                .GET()
                .build();

        HttpResponse response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());

        if (response.statusCode() != 200) {
            throw new RuntimeException("Failed to get payment methods: " + response.statusCode());
        }

        List allMethods = objectMapper.readValue(
                response.body(),
                new TypeReference>() {}
        );

        // Filter to only active (non-deleted) methods
        return allMethods.stream()
                .filter(m -> !m.isDeleted())
                .collect(Collectors.toList());
    }

    // Safe delete: Verify not the last payment method before deleting
    public SavedPaymentMethodResponse safeDeleteSavedPaymentMethod(
            String merchantId,
            String payorId,
            String savedPaymentMethodId) throws IOException, InterruptedException {

        // First, get all active payment methods
        List activeMethods = getActiveSavedPaymentMethods(merchantId, payorId);

        if (activeMethods.size() <= 1) {
            throw new IllegalStateException(
                    "Cannot delete the last remaining payment method. The payor must have at least one active payment method.");
        }

        // Safe to delete
        return deleteSavedPaymentMethod(merchantId, payorId, savedPaymentMethodId);
    }

    // Usage example
    public static void main(String[] args) {
        try {
            String baseUrl = "https://api.example.com";
            String bearerToken = "your-oauth-token-here";
            String merchantId = "12345678901";
            String payorId = "550e8400-e29b-41d4-a716-446655440000";
            String paymentMethodToDelete = "7c9e6679-7425-40de-944b-e07fc1f90ae7";

            PaymentMethodClient client = new PaymentMethodClient(baseUrl, bearerToken);

            // Safe delete with validation
            SavedPaymentMethodResponse result = client.safeDeleteSavedPaymentMethod(
                    merchantId, payorId, paymentMethodToDelete);

            System.out.println("Payment method deleted: " + result.getMaskedAccountNumber());
            System.out.println("Account type: " + result.getAccountType());
            System.out.println("Is deleted: " + result.isDeleted());

        } catch (IllegalStateException ex) {
            System.out.println("Cannot delete: " + ex.getMessage());
        } catch (Exception ex) {
            System.out.println("Error: " + ex.getMessage());
            ex.printStackTrace();
        }
    }
}

// Response model
class SavedPaymentMethodResponse {
    @JsonProperty("payorId")
    private String payorId;

    @JsonProperty("savedPaymentMethodId")
    private String savedPaymentMethodId;

    @JsonProperty("maskedAccountNumber")
    private String maskedAccountNumber;

    @JsonProperty("accountType")
    private String accountType;

    @JsonProperty("isDefault")
    private boolean isDefault;

    @JsonProperty("isDeleted")
    private boolean isDeleted;

    @JsonProperty("sponsorKey")
    private String sponsorKey;

    public String getPayorId() { return payorId; }
    public String getSavedPaymentMethodId() { return savedPaymentMethodId; }
    public String getMaskedAccountNumber() { return maskedAccountNumber; }
    public String getAccountType() { return accountType; }
    public boolean isDefault() { return isDefault; }
    public boolean isDeleted() { return isDeleted; }
    public String getSponsorKey() { return sponsorKey; }
}
    

require 'net/http'
require 'json'

class PaymentMethodClient
  def initialize(base_url, bearer_token)
    @base_url = base_url
    @bearer_token = bearer_token
  end

  # Delete a single saved payment method
  def delete_saved_payment_method(merchant_id:, payor_id:, saved_payment_method_id:)
    uri = URI("#{@base_url}/v1/rest/merchants/#{merchant_id}/payors/#{payor_id}/savedPaymentMethods/#{saved_payment_method_id}")
    request = Net::HTTP::Delete.new(uri)
    request['Authorization'] = "Bearer #{@bearer_token}"

    response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
      http.request(request)
    end

    if response.code == '404'
      raise "Payment method not found. It may have already been deleted or does not exist."
    end

    raise "Failed to delete payment method: #{response.code} - #{response.body}" unless response.code == '200'

    JSON.parse(response.body)
  end

  # Helper: Get all active payment methods before deleting
  def get_active_saved_payment_methods(merchant_id:, payor_id:)
    uri = URI("#{@base_url}/v1/rest/merchants/#{merchant_id}/payors/#{payor_id}/savedPaymentMethods")
    request = Net::HTTP::Get.new(uri)
    request['Authorization'] = "Bearer #{@bearer_token}"

    response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
      http.request(request)
    end

    raise "Failed to get payment methods: #{response.code}" unless response.code == '200'

    all_methods = JSON.parse(response.body)

    # Filter to only active (non-deleted) methods
    all_methods.select { |m| !m['isDeleted'] }
  end

  # Safe delete: Verify not the last payment method before deleting
  def safe_delete_saved_payment_method(merchant_id:, payor_id:, saved_payment_method_id:)
    # First, get all active payment methods
    active_methods = get_active_saved_payment_methods(merchant_id: merchant_id, payor_id: payor_id)

    if active_methods.length <= 1
      raise ArgumentError, "Cannot delete the last remaining payment method. The payor must have at least one active payment method."
    end

    # Safe to delete
    delete_saved_payment_method(
      merchant_id: merchant_id,
      payor_id: payor_id,
      saved_payment_method_id: saved_payment_method_id
    )
  end
end

# Usage example
if __FILE__ == $0
  base_url = 'https://api.example.com'
  bearer_token = 'your-oauth-token-here'
  merchant_id = '12345678901'
  payor_id = '550e8400-e29b-41d4-a716-446655440000'
  payment_method_to_delete = '7c9e6679-7425-40de-944b-e07fc1f90ae7'

  client = PaymentMethodClient.new(base_url, bearer_token)

  begin
    # Safe delete with validation
    result = client.safe_delete_saved_payment_method(
      merchant_id: merchant_id,
      payor_id: payor_id,
      saved_payment_method_id: payment_method_to_delete
    )

    puts "Payment method deleted: #{result['maskedAccountNumber']}"
    puts "Account type: #{result['accountType']}"
    puts "Is deleted: #{result['isDeleted']}"

  rescue ArgumentError => e
    puts "Cannot delete: #{e.message}"
  rescue => e
    puts "Error: #{e.message}"
  end
end