Imports System
Imports System.Net.Http
Imports System.Net.Http.Headers
Imports System.Threading.Tasks

Public Class PayorClient
    Private ReadOnly _httpClient As HttpClient
    Private ReadOnly _baseUrl As String = "https://your-api-domain.com" ' Replace with actual base URL
    Private ReadOnly _bearerToken As String

    Public Sub New(bearerToken As String)
        _bearerToken = bearerToken
        _httpClient = New HttpClient()
        _httpClient.BaseAddress = New Uri(_baseUrl)

        ' Set the Authorization header with bearer token
        _httpClient.DefaultRequestHeaders.Authorization = _
            New AuthenticationHeaderValue("Bearer", _bearerToken)

        ' Set Accept header to request JSON
        _httpClient.DefaultRequestHeaders.Accept.Add( _
            New MediaTypeWithQualityHeaderValue("application/json"))
    End Sub

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

        Try
            ' Construct the endpoint URL
            Dim endpoint As String = $"/v1/rest/merchants/{merchantId}/payors/{payorId}"

            ' Make the DELETE request
            Dim response As HttpResponseMessage = Await _httpClient.DeleteAsync(endpoint)

            ' Ensure the request was successful
            response.EnsureSuccessStatusCode()

            ' Read and return the response content as a string
            Dim responseBody As String = Await response.Content.ReadAsStringAsync()
            Return responseBody

        Catch e As HttpRequestException
            Console.WriteLine($"Request error: {e.Message}")
            Throw
        End Try
    End Function

    Public Async Function DeletePayorWithConfirmationAsync(
        merchantId As String,
        payorId As String) As Task(Of Boolean)

        Try
            Console.WriteLine("WARNING: This will delete the payor and all saved payment methods.")
            Console.Write("Are you sure you want to proceed? (yes/no): ")

            Dim confirmation As String = Console.ReadLine()
            If confirmation?.ToLower() <> "yes" Then
                Console.WriteLine("Delete operation cancelled.")
                Return False
            End If

            ' Proceed with deletion
            Dim endpoint As String = $"/v1/rest/merchants/{merchantId}/payors/{payorId}"
            Dim response As HttpResponseMessage = Await _httpClient.DeleteAsync(endpoint)

            If response.IsSuccessStatusCode Then
                Console.WriteLine("Payor deleted successfully.")
                Return True
            ElseIf response.StatusCode = Net.HttpStatusCode.Conflict Then
                Console.WriteLine("Payor was already deleted.")
                Return False
            Else
                Console.WriteLine($"Delete failed with status code: {response.StatusCode}")
                Return False
            End If

        Catch e As HttpRequestException
            Console.WriteLine($"Request error: {e.Message}")
            Throw
        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.DeletePayorAsync(
    "12345678901",              ' merchantId
    "5513027774438108364"       ' payorId
)
Console.WriteLine(result)

' Example usage: Delete with confirmation
Dim wasDeleted As Boolean = Await client.DeletePayorWithConfirmationAsync(
    "12345678901",              ' merchantId
    "5513027774438108364"       ' payorId
)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class PayorClient {
    private final HttpClient httpClient;
    private final String baseUrl;
    private final String bearerToken;

    public PayorClient(String baseUrl, String bearerToken) {
        this.baseUrl = baseUrl;
        this.bearerToken = bearerToken;
        this.httpClient = HttpClient.newHttpClient();
    }

    public String deletePayor(String merchantId, String payorId)
            throws IOException, InterruptedException {
        try {
            // Construct the endpoint URL
            String endpoint = String.format("%s/v1/rest/merchants/%s/payors/%s",
                baseUrl, merchantId, payorId);

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

            // Send the request and get response
            HttpResponse<String> response = httpClient.send(request,
                HttpResponse.BodyHandlers.ofString());

            // Check if request was successful (status code 200-299)
            if (response.statusCode() < 200 || response.statusCode() >= 300) {
                throw new RuntimeException("HTTP Error: " + response.statusCode() +
                    " - " + response.body());
            }

            // Return the response body
            return response.body();

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

    public boolean deletePayorWithConfirmation(String merchantId, String payorId)
            throws IOException, InterruptedException {
        try {
            System.out.println("WARNING: This will delete the payor and all saved payment methods.");
            System.out.print("Are you sure you want to proceed? (yes/no): ");

            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            String confirmation = reader.readLine();

            if (!"yes".equalsIgnoreCase(confirmation)) {
                System.out.println("Delete operation cancelled.");
                return false;
            }

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

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

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

            if (response.statusCode() >= 200 && response.statusCode() < 300) {
                System.out.println("Payor deleted successfully.");
                return true;
            } else if (response.statusCode() == 409) {
                System.out.println("Payor was already deleted.");
                return false;
            } else {
                System.out.println("Delete failed with status code: " + response.statusCode());
                return false;
            }

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

    // Example usage
    public static void main(String[] args) {
        try {
            PayorClient client = new PayorClient(
                "https://your-api-domain.com",
                "your-bearer-token-here"
            );

            // Simple delete
            String result = client.deletePayor("12345678901", "5513027774438108364");
            System.out.println(result);

            // Delete with confirmation
            boolean wasDeleted = client.deletePayorWithConfirmation(
                "12345678901",
                "5513027774438108364"
            );
            System.out.println("Was deleted: " + wasDeleted);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

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

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

  def delete_payor(merchant_id, payor_id)
    # Construct the endpoint URL
    endpoint = "#{@base_url}/v1/rest/merchants/#{merchant_id}/payors/#{payor_id}"
    uri = URI(endpoint)

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

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

    # Check response status
    unless response.is_a?(Net::HTTPSuccess)
      raise "HTTP Error: #{response.code} - #{response.message}\n#{response.body}"
    end

    # Return the response body
    response.body

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

  def delete_payor_with_confirmation(merchant_id, payor_id)
    puts 'WARNING: This will delete the payor and all saved payment methods.'
    print 'Are you sure you want to proceed? (yes/no): '

    confirmation = gets.chomp

    unless confirmation.downcase == 'yes'
      puts 'Delete operation cancelled.'
      return false
    end

    # Proceed with deletion
    endpoint = "#{@base_url}/v1/rest/merchants/#{merchant_id}/payors/#{payor_id}"
    uri = URI(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: uri.scheme == 'https') do |http|
      http.request(request)
    end

    case response
    when Net::HTTPSuccess
      puts 'Payor deleted successfully.'
      true
    when Net::HTTPConflict
      puts 'Payor was already deleted.'
      false
    else
      puts "Delete failed with status code: #{response.code}"
      false
    end

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

# Example usage
begin
  client = PayorClient.new(
    'https://your-api-domain.com',
    'your-bearer-token-here'
  )

  # Simple delete
  result = client.delete_payor('12345678901', '5513027774438108364')
  puts result

  # Delete with confirmation
  was_deleted = client.delete_payor_with_confirmation(
    '12345678901',
    '5513027774438108364'
  )
  puts "Was deleted: #{was_deleted}"

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