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

Public Class SavedPaymentMethodRequest
    <JsonProperty("customerAccountId")>
    Public Property CustomerAccountId As String

    <JsonProperty("encryptedAccountNumber")>
    Public Property EncryptedAccountNumber As String

    <JsonProperty("paymentMethodType")>
    Public Property PaymentMethodType As String

    <JsonProperty("accountHolderFirstName")>
    Public Property AccountHolderFirstName As String

    <JsonProperty("accountHolderLastName")>
    Public Property AccountHolderLastName As String

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

    <JsonProperty("abaRoutingNumber")>
    Public Property AbaRoutingNumber As String

    <JsonProperty("accountHolderStreetLine1")>
    Public Property AccountHolderStreetLine1 As String

    <JsonProperty("accountHolderCity")>
    Public Property AccountHolderCity As String

    <JsonProperty("accountHolderRegion")>
    Public Property AccountHolderRegion As String

    <JsonProperty("accountHolderPostalCode")>
    Public Property AccountHolderPostalCode As String

    <JsonProperty("accountHolderEmail")>
    Public Property AccountHolderEmail As String

    <JsonProperty("setAsDefaultPaymentMethod")>
    Public Property SetAsDefaultPaymentMethod As Boolean
End Class

Public Class PayorResponse
    <JsonProperty("payorId")>
    Public Property PayorId As String

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

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

Public Class CreatePayorClient
    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 CreatePayorWithCreditCardAsync(
        merchantId As String,
        customerAccountId As String,
        encryptedCardNumber As String,
        cardExpiry As String,
        firstName As String,
        lastName As String,
        address As String,
        city As String,
        state As String,
        zip As String,
        Optional email As String = Nothing) As Task(Of PayorResponse)

        Dim request As New SavedPaymentMethodRequest With {
            .CustomerAccountId = customerAccountId,
            .EncryptedAccountNumber = encryptedCardNumber,
            .PaymentMethodType = "CreditCard",
            .CardExpiry = cardExpiry,
            .AccountHolderFirstName = firstName,
            .AccountHolderLastName = lastName,
            .AccountHolderStreetLine1 = address,
            .AccountHolderCity = city,
            .AccountHolderRegion = state,
            .AccountHolderPostalCode = zip,
            .AccountHolderEmail = email,
            .SetAsDefaultPaymentMethod = True
        }

        Return Await CreatePayorAsync(merchantId, request)
    End Function

    Private Async Function CreatePayorAsync(
        merchantId As String,
        request As SavedPaymentMethodRequest) As Task(Of PayorResponse)

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

            Dim jsonContent As String = JsonConvert.SerializeObject(request)
            Dim content As New StringContent(jsonContent, Encoding.UTF8, "application/json")

            Dim response As HttpResponseMessage = Await _httpClient.PostAsync(endpoint, content)
            response.EnsureSuccessStatusCode()

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

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

' Encrypt card number first
Dim cardNumber As String = "4111111111111111"
Dim encryptedCard As String = Await EncryptWithPanKey(cardNumber)

Dim result As PayorResponse = Await client.CreatePayorWithCreditCardAsync(
    "12345678901",
    "CUST-12345",
    encryptedCard,
    "1225",
    "John",
    "Doe",
    "123 Main St",
    "Springfield",
    "IL",
    "62701",
    "john.doe@example.com"
)

Console.WriteLine($"Payor created: {result.PayorId}")

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.HashMap;
import java.util.Map;
import com.google.gson.Gson;
import com.google.gson.annotations.SerializedName;

class SavedPaymentMethodRequest {
    @SerializedName("customerAccountId")
    private String customerAccountId;

    @SerializedName("encryptedAccountNumber")
    private String encryptedAccountNumber;

    @SerializedName("paymentMethodType")
    private String paymentMethodType;

    @SerializedName("accountHolderFirstName")
    private String accountHolderFirstName;

    @SerializedName("accountHolderLastName")
    private String accountHolderLastName;

    @SerializedName("cardExpiry")
    private String cardExpiry;

    @SerializedName("abaRoutingNumber")
    private String abaRoutingNumber;

    @SerializedName("accountHolderStreetLine1")
    private String accountHolderStreetLine1;

    @SerializedName("accountHolderCity")
    private String accountHolderCity;

    @SerializedName("accountHolderRegion")
    private String accountHolderRegion;

    @SerializedName("accountHolderPostalCode")
    private String accountHolderPostalCode;

    @SerializedName("accountHolderEmail")
    private String accountHolderEmail;

    @SerializedName("setAsDefaultPaymentMethod")
    private boolean setAsDefaultPaymentMethod;

    // Setters for builder pattern
    public void setCustomerAccountId(String id) { this.customerAccountId = id; }
    public void setEncryptedAccountNumber(String num) { this.encryptedAccountNumber = num; }
    public void setPaymentMethodType(String type) { this.paymentMethodType = type; }
    public void setAccountHolderFirstName(String name) { this.accountHolderFirstName = name; }
    public void setAccountHolderLastName(String name) { this.accountHolderLastName = name; }
    public void setCardExpiry(String expiry) { this.cardExpiry = expiry; }
    public void setAbaRoutingNumber(String routing) { this.abaRoutingNumber = routing; }
    public void setAccountHolderStreetLine1(String address) { this.accountHolderStreetLine1 = address; }
    public void setAccountHolderCity(String city) { this.accountHolderCity = city; }
    public void setAccountHolderRegion(String region) { this.accountHolderRegion = region; }
    public void setAccountHolderPostalCode(String postal) { this.accountHolderPostalCode = postal; }
    public void setAccountHolderEmail(String email) { this.accountHolderEmail = email; }
    public void setSetAsDefaultPaymentMethod(boolean isDefault) { this.setAsDefaultPaymentMethod = isDefault; }
}

class PayorResponse {
    @SerializedName("payorId")
    private String payorId;

    @SerializedName("savedPaymentMethodId")
    private String savedPaymentMethodId;

    @SerializedName("responseStatus")
    private String responseStatus;

    public String getPayorId() { return payorId; }
    public String getSavedPaymentMethodId() { return savedPaymentMethodId; }
    public String getResponseStatus() { return responseStatus; }
}

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

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

    public PayorResponse createPayorWithCreditCard(
            String merchantId,
            String customerAccountId,
            String encryptedCardNumber,
            String cardExpiry,
            String firstName,
            String lastName,
            String address,
            String city,
            String state,
            String zip,
            String email) throws Exception {

        SavedPaymentMethodRequest request = new SavedPaymentMethodRequest();
        request.setCustomerAccountId(customerAccountId);
        request.setEncryptedAccountNumber(encryptedCardNumber);
        request.setPaymentMethodType("CreditCard");
        request.setCardExpiry(cardExpiry);
        request.setAccountHolderFirstName(firstName);
        request.setAccountHolderLastName(lastName);
        request.setAccountHolderStreetLine1(address);
        request.setAccountHolderCity(city);
        request.setAccountHolderRegion(state);
        request.setAccountHolderPostalCode(zip);
        request.setAccountHolderEmail(email);
        request.setSetAsDefaultPaymentMethod(true);

        return createPayor(merchantId, request);
    }

    private PayorResponse createPayor(
            String merchantId,
            SavedPaymentMethodRequest request) throws Exception {

        String endpoint = baseUrl + "/v1/rest/merchants/" + merchantId + "/payors";
        String jsonBody = gson.toJson(request);

        HttpRequest httpRequest = HttpRequest.newBuilder()
            .uri(URI.create(endpoint))
            .header("Authorization", "Bearer " + bearerToken)
            .header("Content-Type", "application/json")
            .header("Accept", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
            .build();

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

        if (response.statusCode() == 201 || response.statusCode() == 200) {
            return gson.fromJson(response.body(), PayorResponse.class);
        } else {
            throw new Exception("Request failed with status: " + response.statusCode());
        }
    }

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

            // Encrypt card number first
            String cardNumber = "4111111111111111";
            String encryptedCard = encryptWithPanKey(cardNumber);

            PayorResponse result = client.createPayorWithCreditCard(
                "12345678901",
                "CUST-12345",
                encryptedCard,
                "1225",
                "John",
                "Doe",
                "123 Main St",
                "Springfield",
                "IL",
                "62701",
                "john.doe@example.com"
            );

            System.out.println("Payor created: " + result.getPayorId());
            System.out.println("Payment method ID: " + result.getSavedPaymentMethodId());
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

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

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

  def create_payor_with_credit_card(merchant_id, customer_account_id,
                                     encrypted_card_number, card_expiry,
                                     first_name, last_name,
                                     address, city, state, zip, email = nil)
    request_body = {
      customerAccountId: customer_account_id,
      encryptedAccountNumber: encrypted_card_number,
      paymentMethodType: 'CreditCard',
      cardExpiry: card_expiry,
      accountHolderFirstName: first_name,
      accountHolderLastName: last_name,
      accountHolderStreetLine1: address,
      accountHolderCity: city,
      accountHolderRegion: state,
      accountHolderPostalCode: zip,
      accountHolderEmail: email,
      setAsDefaultPaymentMethod: true
    }

    create_payor(merchant_id, request_body)
  end

  def create_payor_with_bank_account(merchant_id, customer_account_id,
                                      encrypted_account_number, routing_number,
                                      account_type, first_name, last_name, email = nil)
    request_body = {
      customerAccountId: customer_account_id,
      encryptedAccountNumber: encrypted_account_number,
      abaRoutingNumber: routing_number,
      paymentMethodType: account_type, # 'Checking' or 'Saving'
      accountHolderFirstName: first_name,
      accountHolderLastName: last_name,
      accountHolderEmail: email,
      setAsDefaultPaymentMethod: true
    }

    create_payor(merchant_id, request_body)
  end

  private

  def create_payor(merchant_id, request_body)
    uri = URI("#{@base_url}/v1/rest/merchants/#{merchant_id}/payors")

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

    request = Net::HTTP::Post.new(uri.path)
    request['Authorization'] = "Bearer #{@bearer_token}"
    request['Content-Type'] = 'application/json'
    request['Accept'] = 'application/json'
    request.body = JSON.generate(request_body)

    response = http.request(request)

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

# Example usage: Create payor with credit card
client = CreatePayorClient.new('your-bearer-token-here')

# Encrypt card number first
card_number = '4111111111111111'
encrypted_card = encrypt_with_pan_key(card_number)

result = client.create_payor_with_credit_card(
  '12345678901',
  'CUST-12345',
  encrypted_card,
  '1225',
  'John',
  'Doe',
  '123 Main St',
  'Springfield',
  'IL',
  '62701',
  'john.doe@example.com'
)

puts "Payor created: #{result['payorId']}"
puts "Payment method ID: #{result['savedPaymentMethodId']}"
puts "Status: #{result['responseStatus']}"