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

Public Class SavedPaymentMethodResponse
    <JsonProperty("responseStatus")>
    Public Property ResponseStatus As String

    <JsonProperty("responseMessage")>
    Public Property ResponseMessage As String

    <JsonProperty("responseResult")>
    Public Property ResponseResult As String

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

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

    <JsonProperty("deletedDate")>
    Public Property DeletedDate As DateTime?
End Class

Public Class PayorClient
    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)

        _httpClient.DefaultRequestHeaders.Accept.Add( _
            New MediaTypeWithQualityHeaderValue("application/json"))
    End Sub

    Public Async Function DeleteAllSavedPaymentMethodsAsync( _
        merchantId As String, _
        payorId As String) As Task(Of String)

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

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

            If response.StatusCode = Net.HttpStatusCode.MultiStatus Then
                Dim partialResponseBody As String = Await response.Content.ReadAsStringAsync()
                Console.WriteLine("WARNING: Some payment methods failed to delete.")
                Console.WriteLine(partialResponseBody)
                Return partialResponseBody
            End If

            response.EnsureSuccessStatusCode()

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

    Public Async Function DeleteAllWithDetailsAsync( _
        merchantId As String, _
        payorId As String) As Task(Of (Success As Boolean, DeletedCount As Integer, Errors As List(Of String)))

        Try
            Dim getEndpoint As String = $"/v1/rest/merchants/{merchantId}/payors/{payorId}" & _
                                      "/savedPaymentMethods"
            Dim getResponse As HttpResponseMessage = Await _httpClient.GetAsync(getEndpoint)
            Dim paymentMethodsJson As String = Await getResponse.Content.ReadAsStringAsync()
            Dim paymentMethods As List(Of SavedPaymentMethodResponse) = _
                JsonConvert.DeserializeObject(Of List(Of SavedPaymentMethodResponse))(paymentMethodsJson)

            Dim originalCount As Integer = If(paymentMethods IsNot Nothing, paymentMethods.Count, 0)
            Console.WriteLine($"Found {originalCount} payment method(s) to delete.")

            Console.Write("Are you sure you want to delete ALL payment methods? (yes/no): ")
            Dim confirmation As String = Console.ReadLine()
            If confirmation?.ToLower() <> "yes" Then
                Console.WriteLine("Delete operation cancelled.")
                Return (False, 0, New List(Of String) From {"Operation cancelled by user"})
            End If

            Dim deleteEndpoint As String = $"/v1/rest/merchants/{merchantId}/payors/{payorId}" & _
                                         "/savedPaymentMethods"
            Dim deleteResponse As HttpResponseMessage = Await _httpClient.DeleteAsync(deleteEndpoint)

            Dim errors As New List(Of String)

            If deleteResponse.StatusCode = Net.HttpStatusCode.OK Then
                Console.WriteLine($"Successfully deleted all {originalCount} payment method(s).")
                Return (True, originalCount, errors)
            ElseIf deleteResponse.StatusCode = Net.HttpStatusCode.MultiStatus Then
                Console.WriteLine("Partial success - some payment methods failed to delete.")
                Dim responseBody As String = Await deleteResponse.Content.ReadAsStringAsync()
                errors.Add(responseBody)
                Return (False, 0, errors)
            Else
                Dim errorBody As String = Await deleteResponse.Content.ReadAsStringAsync()
                errors.Add($"HTTP {deleteResponse.StatusCode}: {errorBody}")
                Return (False, 0, errors)
            End If
        Catch ex As Exception
            Console.WriteLine($"Error: {ex.Message}")
            Return (False, 0, New List(Of String) From {ex.Message})
        End Try
    End Function
End Class

' Example usage: Simple delete
Dim client As New PayorClient("your-bearer-token-here")
Dim result As String = Await client.DeleteAllSavedPaymentMethodsAsync( _
    "12345678901", _
    "5513027774438108364")
Console.WriteLine(result)

' Example usage: Delete with detailed feedback
Dim deleteResult = Await client.DeleteAllWithDetailsAsync( _
    "12345678901", _
    "5513027774438108364")

If deleteResult.Success Then
    Console.WriteLine($"Successfully deleted {deleteResult.DeletedCount} payment method(s).")
Else
    Console.WriteLine("Deletion failed or partially completed:")
    For Each errorMsg In deleteResult.Errors
        Console.WriteLine($"  - {errorMsg}")
    Next
End If

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.ArrayList;
import java.util.List;
import java.util.Scanner;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.ObjectMapper;

public class SavedPaymentMethodResponse {
    @JsonProperty("responseStatus")
    private String responseStatus;

    @JsonProperty("responseMessage")
    private String responseMessage;

    @JsonProperty("responseResult")
    private String responseResult;

    @JsonProperty("savedPaymentMethodId")
    private String savedPaymentMethodId;

    @JsonProperty("isDeleted")
    private boolean isDeleted;

    @JsonProperty("deletedDate")
    private String deletedDate;

    // Getters and setters omitted for brevity
}

public class PayorClient {
    private final HttpClient httpClient;
    private final String baseUrl = "https://your-api-domain.com";
    private final String bearerToken;
    private final ObjectMapper objectMapper;

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

    public String deleteAllSavedPaymentMethods(String merchantId, String payorId)
            throws IOException, InterruptedException {
        try {
            String endpoint = String.format("/v1/rest/merchants/%s/payors/%s/savedPaymentMethods",
                                          merchantId, payorId);

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

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

            if (response.statusCode() == 207) {
                System.out.println("WARNING: Some payment methods failed to delete.");
                System.out.println(response.body());
                return response.body();
            }

            if (response.statusCode() < 200 || response.statusCode() >= 300) {
                throw new IOException("HTTP " + response.statusCode() + ": " + response.body());
            }

            return response.body();
        } catch (IOException | InterruptedException e) {
            System.err.println("Request error: " + e.getMessage());
            throw e;
        }
    }

    public DeleteResult deleteAllWithDetails(String merchantId, String payorId)
            throws IOException, InterruptedException {
        try {
            // First, get the list of payment methods
            String getEndpoint = String.format("/v1/rest/merchants/%s/payors/%s/savedPaymentMethods",
                                             merchantId, payorId);

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

            HttpResponse<String> getResponse = httpClient.send(getRequest,
                HttpResponse.BodyHandlers.ofString());

            SavedPaymentMethodResponse[] paymentMethods = objectMapper.readValue(
                getResponse.body(), SavedPaymentMethodResponse[].class);

            int originalCount = paymentMethods != null ? paymentMethods.length : 0;
            System.out.println("Found " + originalCount + " payment method(s) to delete.");

            // Confirm with user
            Scanner scanner = new Scanner(System.in);
            System.out.print("Are you sure you want to delete ALL payment methods? (yes/no): ");
            String confirmation = scanner.nextLine();
            if (!"yes".equalsIgnoreCase(confirmation)) {
                System.out.println("Delete operation cancelled.");
                List<String> errors = new ArrayList<>();
                errors.add("Operation cancelled by user");
                return new DeleteResult(false, 0, errors);
            }

            // Proceed with deletion
            String deleteEndpoint = String.format("/v1/rest/merchants/%s/payors/%s/savedPaymentMethods",
                                                merchantId, payorId);

            HttpRequest deleteRequest = HttpRequest.newBuilder()
                .uri(URI.create(baseUrl + deleteEndpoint))
                .header("Authorization", "Bearer " + bearerToken)
                .header("Accept", "application/json")
                .DELETE()
                .build();

            HttpResponse<String> deleteResponse = httpClient.send(deleteRequest,
                HttpResponse.BodyHandlers.ofString());

            List<String> errors = new ArrayList<>();

            if (deleteResponse.statusCode() == 200) {
                System.out.println("Successfully deleted all " + originalCount + " payment method(s).");
                return new DeleteResult(true, originalCount, errors);
            } else if (deleteResponse.statusCode() == 207) {
                System.out.println("Partial success - some payment methods failed to delete.");
                errors.add(deleteResponse.body());
                return new DeleteResult(false, 0, errors);
            } else {
                errors.add("HTTP " + deleteResponse.statusCode() + ": " + deleteResponse.body());
                return new DeleteResult(false, 0, errors);
            }
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
            List<String> errors = new ArrayList<>();
            errors.add(e.getMessage());
            return new DeleteResult(false, 0, errors);
        }
    }

    public static class DeleteResult {
        public final boolean success;
        public final int deletedCount;
        public final List<String> errors;

        public DeleteResult(boolean success, int deletedCount, List<String> errors) {
            this.success = success;
            this.deletedCount = deletedCount;
            this.errors = errors;
        }
    }
}

// Example usage: Simple delete
PayorClient client = new PayorClient("your-bearer-token-here");
String result = client.deleteAllSavedPaymentMethods(
    "12345678901",
    "5513027774438108364"
);
System.out.println(result);

// Example usage: Delete with detailed feedback
PayorClient.DeleteResult deleteResult = client.deleteAllWithDetails(
    "12345678901",
    "5513027774438108364"
);

if (deleteResult.success) {
    System.out.println("Successfully deleted " + deleteResult.deletedCount + " payment method(s).");
} else {
    System.out.println("Deletion failed or partially completed:");
    for (String error : deleteResult.errors) {
        System.out.println("  - " + error);
    }
}

require 'net/http'
require 'uri'
require 'json'
require 'io/console'

class SavedPaymentMethodResponse
  attr_accessor :response_status, :response_message, :response_result,
                :saved_payment_method_id, :is_deleted, :deleted_date

  def initialize(data)
    @response_status = data['responseStatus']
    @response_message = data['responseMessage']
    @response_result = data['responseResult']
    @saved_payment_method_id = data['savedPaymentMethodId']
    @is_deleted = data['isDeleted']
    @deleted_date = data['deletedDate']
  end
end

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

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

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

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

    if response.code == '207'
      puts 'WARNING: Some payment methods failed to delete.'
      puts response.body
      return response.body
    end

    unless response.is_a?(Net::HTTPSuccess)
      raise "HTTP #{response.code}: #{response.body}"
    end

    response.body
  rescue StandardError => e
    puts "Request error: #{e.message}"
    raise
  end

  def delete_all_with_details(merchant_id, payor_id)
    # First, get the list of payment methods
    get_endpoint = "/v1/rest/merchants/#{merchant_id}/payors/#{payor_id}" +
                   '/savedPaymentMethods'
    get_uri = URI("#{@base_url}#{get_endpoint}")

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

    get_response = Net::HTTP.start(get_uri.hostname, get_uri.port, use_ssl: true) do |http|
      http.request(get_request)
    end

    payment_methods = JSON.parse(get_response.body).map do |pm|
      SavedPaymentMethodResponse.new(pm)
    end

    original_count = payment_methods.length
    puts "Found #{original_count} payment method(s) to delete."

    # Confirm with user
    print 'Are you sure you want to delete ALL payment methods? (yes/no): '
    confirmation = gets.chomp
    unless confirmation.downcase == 'yes'
      puts 'Delete operation cancelled.'
      return { success: false, deleted_count: 0, errors: ['Operation cancelled by user'] }
    end

    # Proceed with deletion
    delete_endpoint = "/v1/rest/merchants/#{merchant_id}/payors/#{payor_id}" +
                     '/savedPaymentMethods'
    delete_uri = URI("#{@base_url}#{delete_endpoint}")

    delete_request = Net::HTTP::Delete.new(delete_uri)
    delete_request['Authorization'] = "Bearer #{@bearer_token}"
    delete_request['Accept'] = 'application/json'

    delete_response = Net::HTTP.start(delete_uri.hostname, delete_uri.port, use_ssl: true) do |http|
      http.request(delete_request)
    end

    errors = []

    case delete_response.code
    when '200'
      puts "Successfully deleted all #{original_count} payment method(s)."
      { success: true, deleted_count: original_count, errors: errors }
    when '207'
      puts 'Partial success - some payment methods failed to delete.'
      errors << delete_response.body
      { success: false, deleted_count: 0, errors: errors }
    else
      errors << "HTTP #{delete_response.code}: #{delete_response.body}"
      { success: false, deleted_count: 0, errors: errors }
    end
  rescue StandardError => e
    puts "Error: #{e.message}"
    { success: false, deleted_count: 0, errors: [e.message] }
  end
end

# Example usage: Simple delete
client = PayorClient.new('your-bearer-token-here')
result = client.delete_all_saved_payment_methods(
  '12345678901',
  '5513027774438108364'
)
puts result

# Example usage: Delete with detailed feedback
delete_result = client.delete_all_with_details(
  '12345678901',
  '5513027774438108364'
)

if delete_result[:success]
  puts "Successfully deleted #{delete_result[:deleted_count]} payment method(s)."
else
  puts 'Deletion failed or partially completed:'
  delete_result[:errors].each do |error|
    puts "  - #{error}"
  end
end