Imports System.Collections.Generic
Imports System.Linq
Imports System.Net.Http
Imports System.Net.Http.Headers
Imports System.Threading.Tasks
Imports Newtonsoft.Json

Public Class SavedPaymentMethodResponse
    <JsonProperty("savedPaymentMethodId")>
    Public Property SavedPaymentMethodId As String

    <JsonProperty("accountType")>
    Public Property AccountType As String

    <JsonProperty("maskedAccountNumber")>
    Public Property MaskedAccountNumber As String

    <JsonProperty("lastFour")>
    Public Property LastFour As String

    <JsonProperty("cardExpiry")>
    Public Property CardExpiry As String

    <JsonProperty("isDeleted")>
    Public Property IsDeleted As Boolean

    <JsonProperty("isDefaultAccount")>
    Public Property IsDefaultAccount As Boolean?
End Class

Public Class SavedPaymentMethodsClient
    Private ReadOnly _httpClient As HttpClient
    Private ReadOnly _baseUrl As String = "https://your-api-domain.com"
    Private ReadOnly _bearerToken As String

    Public Sub New(bearerToken As String)
        _bearerToken = bearerToken
        _httpClient = New HttpClient()
        _httpClient.BaseAddress = New Uri(_baseUrl)
        _httpClient.DefaultRequestHeaders.Authorization = _
            New AuthenticationHeaderValue("Bearer", _bearerToken)
    End Sub

    Public Async Function GetSavedPaymentMethodsAsync(
        merchantId As String,
        payorId As String) As Task(Of List(Of SavedPaymentMethodResponse))

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

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

            Dim responseBody As String = Await response.Content.ReadAsStringAsync()
            Return JsonConvert.DeserializeObject(Of List(Of SavedPaymentMethodResponse))(responseBody)
        Catch ex As HttpRequestException
            Console.WriteLine($"Request error: {ex.Message}")
            Throw
        End Try
    End Function

    ' Helper: Get only active payment methods
    Public Async Function GetActivePaymentMethodsAsync(
        merchantId As String,
        payorId As String) As Task(Of List(Of SavedPaymentMethodResponse))

        Dim allMethods = Await GetSavedPaymentMethodsAsync(merchantId, payorId)
        Return allMethods.Where(Function(m) Not m.IsDeleted).ToList()
    End Function
End Class

' Example usage
Dim client As New SavedPaymentMethodsClient("your-bearer-token-here")

Dim paymentMethods As List(Of SavedPaymentMethodResponse) = _
    Await client.GetSavedPaymentMethodsAsync("12345678901", "payor123")

For Each method In paymentMethods
    If Not method.IsDeleted Then
        Console.WriteLine($"{method.AccountType} ending in {method.LastFour}")
        If method.IsDefaultAccount Then
            Console.WriteLine("  [Default]")
        End If
    End If
Next

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.google.gson.Gson;
import com.google.gson.annotations.SerializedName;
import com.google.gson.reflect.TypeToken;

class SavedPaymentMethodResponse {
    @SerializedName("savedPaymentMethodId")
    private String savedPaymentMethodId;

    @SerializedName("accountType")
    private String accountType;

    @SerializedName("maskedAccountNumber")
    private String maskedAccountNumber;

    @SerializedName("lastFour")
    private String lastFour;

    @SerializedName("cardExpiry")
    private String cardExpiry;

    @SerializedName("isDeleted")
    private boolean isDeleted;

    @SerializedName("isDefaultAccount")
    private Boolean isDefaultAccount;

    // Getters
    public String getSavedPaymentMethodId() { return savedPaymentMethodId; }
    public String getAccountType() { return accountType; }
    public String getMaskedAccountNumber() { return maskedAccountNumber; }
    public String getLastFour() { return lastFour; }
    public String getCardExpiry() { return cardExpiry; }
    public boolean isDeleted() { return isDeleted; }
    public Boolean getIsDefaultAccount() { return isDefaultAccount; }
}

public class SavedPaymentMethodsClient {
    private final HttpClient httpClient;
    private final String baseUrl;
    private final String bearerToken;
    private final Gson gson;

    public SavedPaymentMethodsClient(String bearerToken) {
        this.bearerToken = bearerToken;
        this.baseUrl = "https://your-api-domain.com";
        this.httpClient = HttpClient.newHttpClient();
        this.gson = new Gson();
    }

    public List getSavedPaymentMethods(
            String merchantId,
            String payorId) throws Exception {

        String endpoint = baseUrl + "/v1/rest/merchants/" + merchantId +
                         "/payors/" + payorId + "/savedPaymentMethods";

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

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

        if (response.statusCode() == 200) {
            return gson.fromJson(response.body(),
                new TypeToken>(){}.getType());
        } else if (response.statusCode() == 404) {
            throw new Exception("Payor not found");
        } else {
            throw new Exception("Request failed with status: " + response.statusCode());
        }
    }

    // Helper: Get only active payment methods
    public List getActivePaymentMethods(
            String merchantId,
            String payorId) throws Exception {

        List allMethods =
            getSavedPaymentMethods(merchantId, payorId);

        return allMethods.stream()
            .filter(m -> !m.isDeleted())
            .collect(Collectors.toList());
    }

    // Helper: Get default payment method
    public SavedPaymentMethodResponse getDefaultPaymentMethod(
            String merchantId,
            String payorId) throws Exception {

        List allMethods =
            getSavedPaymentMethods(merchantId, payorId);

        return allMethods.stream()
            .filter(m -> !m.isDeleted() && Boolean.TRUE.equals(m.getIsDefaultAccount()))
            .findFirst()
            .orElse(null);
    }

    public static void main(String[] args) {
        try {
            SavedPaymentMethodsClient client =
                new SavedPaymentMethodsClient("your-bearer-token-here");

            List methods =
                client.getSavedPaymentMethods("12345678901", "payor123");

            for (SavedPaymentMethodResponse method : methods) {
                if (!method.isDeleted()) {
                    System.out.println(method.getAccountType() +
                                     " ending in " + method.getLastFour());
                    if (Boolean.TRUE.equals(method.getIsDefaultAccount())) {
                        System.out.println("  [Default]");
                    }
                }
            }

            // Get default method
            SavedPaymentMethodResponse defaultMethod =
                client.getDefaultPaymentMethod("12345678901", "payor123");

            if (defaultMethod != null) {
                System.out.println("\nDefault: " + defaultMethod.getAccountType() +
                                 " ****" + defaultMethod.getLastFour());
            }
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

require 'net/http'
require 'uri'
require 'json'

class SavedPaymentMethodsClient
  def initialize(bearer_token, base_url = 'https://your-api-domain.com')
    @bearer_token = bearer_token
    @base_url = base_url
  end

  def get_saved_payment_methods(merchant_id, payor_id)
    uri = URI("#{@base_url}/v1/rest/merchants/#{merchant_id}/payors/#{payor_id}/savedPaymentMethods")

    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true if uri.scheme == 'https'

    request = Net::HTTP::Get.new(uri.path)
    request['Authorization'] = "Bearer #{@bearer_token}"
    request['Accept'] = 'application/json'

    response = http.request(request)

    case response.code.to_i
    when 200
      JSON.parse(response.body)
    when 404
      raise "Payor not found: #{payor_id}"
    else
      raise "Request failed with status: #{response.code} - #{response.message}"
    end
  rescue StandardError => e
    puts "Request error: #{e.message}"
    raise
  end

  # Helper: Get only active payment methods
  def get_active_payment_methods(merchant_id, payor_id)
    all_methods = get_saved_payment_methods(merchant_id, payor_id)
    all_methods.reject { |m| m['isDeleted'] }
  end

  # Helper: Get default payment method
  def get_default_payment_method(merchant_id, payor_id)
    all_methods = get_saved_payment_methods(merchant_id, payor_id)
    all_methods.find { |m| m['isDefaultAccount'] && !m['isDeleted'] }
  end
end

# Example usage
client = SavedPaymentMethodsClient.new('your-bearer-token-here')

payment_methods = client.get_saved_payment_methods('12345678901', 'payor123')

payment_methods.each do |method|
  unless method['isDeleted']
    puts "#{method['accountType']} ending in #{method['lastFour']}"
    puts '  [Default]' if method['isDefaultAccount']
  end
end

# Get default method
default_method = client.get_default_payment_method('12345678901', 'payor123')

if default_method
  puts "\nDefault: #{default_method['accountType']} ****#{default_method['lastFour']}"
end
  rescue StandardError => e
    puts "Request error: #{e.message}"
    raise
  end

  # Helper: Get only active payment methods
  def get_active_payment_methods(merchant_id, payor_id)
    all_methods = get_saved_payment_methods(merchant_id, payor_id)
    all_methods.reject { |m| m['isDeleted'] }
  end

  # Helper: Get default payment method
  def get_default_payment_method(merchant_id, payor_id)
    all_methods = get_saved_payment_methods(merchant_id, payor_id)
    all_methods.find { |m| m['isDefaultAccount'] && !m['isDeleted'] }
  end
end

# Example usage
client = SavedPaymentMethodsClient.new('your-bearer-token-here')

payment_methods = client.get_saved_payment_methods('12345678901', 'payor123')

payment_methods.each do |method|
  unless method['isDeleted']
    puts "#{method['accountType']} ending in #{method['lastFour']}"
    puts '  [Default]' if method['isDefaultAccount']
  end
end

# Get default method
default_method = client.get_default_payment_method('12345678901', 'payor123')

if default_method
  puts "\nDefault: #{default_method['accountType']} ****#{default_method['lastFour']}"
end