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

Public Class IssuerInformation
    <JsonProperty("name")>
    Public Property Name As String

    <JsonProperty("country")>
    Public Property Country As String

    <JsonProperty("phoneNumber")>
    Public Property PhoneNumber As String
End Class

Public Class BinResponse
    <JsonProperty("binId")>
    Public Property BinId As String

    <JsonProperty("cardType")>
    Public Property CardType As String

    <JsonProperty("brandName")>
    Public Property BrandName As String

    <JsonProperty("fundingSource")>
    Public Property FundingSource As String

    <JsonProperty("bin")>
    Public Property Bin As String

    <JsonProperty("issuerInformation")>
    Public Property IssuerInformation As IssuerInformation

    <JsonProperty("surcharge")>
    Public Property Surcharge As String
End Class

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

    Public Sub New()
        _httpClient = New HttpClient()
        _httpClient.BaseAddress = New Uri(_baseUrl)
    End Sub

    Public Async Function GetMultipleBinInfoAsync(binIds As List(Of String)) As Task(Of List(Of BinResponse))
        Try
            ' Validate input
            If binIds Is Nothing OrElse Not binIds.Any() Then
                Throw New ArgumentException("BIN IDs list cannot be empty", NameOf(binIds))
            End If

            ' Validate each BIN
            For Each bin In binIds
                If String.IsNullOrEmpty(bin) OrElse bin.Length < 6 Then
                    Throw New ArgumentException($"Invalid BIN: {bin}. Must be at least 6 digits.")
                End If
            Next

            ' Create comma-separated list
            Dim binIdsParam As String = String.Join(",", binIds)

            ' Construct the endpoint URL with query parameter
            Dim endpoint As String = $"/v1/rest/bins?binIds={Uri.EscapeDataString(binIdsParam)}"

            ' Make the GET request
            Dim response As HttpResponseMessage = Await _httpClient.GetAsync(endpoint)

            ' Ensure the request was successful
            response.EnsureSuccessStatusCode()

            ' Read and deserialize the response
            Dim responseBody As String = Await response.Content.ReadAsStringAsync()
            Dim binInfoList As List(Of BinResponse) = _
                JsonConvert.DeserializeObject(Of List(Of BinResponse))(responseBody)

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

    ' Helper: Extract BINs from multiple card numbers
    Public Function ExtractBins(cardNumbers As List(Of String), Optional binLength As Integer = 8) As List(Of String)
        Return cardNumbers.Select(Function(card)
                                      Dim cleaned As String = New String(card.Where(AddressOf Char.IsDigit).ToArray())
                                      Return cleaned.Substring(0, Math.Min(binLength, cleaned.Length))
                                  End Function).Distinct().ToList()
    End Function
End Class

' Example usage:
Dim client As New BinBulkClient()

' Look up multiple BINs
Dim binIds As New List(Of String) From {"411111", "540123", "378282", "601111"}

Dim binInfoList As List(Of BinResponse) = Await client.GetMultipleBinInfoAsync(binIds)

' Process results
For Each binInfo In binInfoList
    Console.WriteLine($"BIN: {binInfo.Bin}")
    Console.WriteLine($"  Brand: {binInfo.BrandName}")
    Console.WriteLine($"  Type: {binInfo.CardType}")
    Console.WriteLine($"  Surcharge: {binInfo.Surcharge}")
    Console.WriteLine()
Next

import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
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 IssuerInformation {
    @SerializedName("name")
    private String name;

    @SerializedName("country")
    private String country;

    @SerializedName("phoneNumber")
    private String phoneNumber;

    // Getters
    public String getName() { return name; }
    public String getCountry() { return country; }
    public String getPhoneNumber() { return phoneNumber; }
}

class BinResponse {
    @SerializedName("binId")
    private String binId;

    @SerializedName("cardType")
    private String cardType;

    @SerializedName("brandName")
    private String brandName;

    @SerializedName("fundingSource")
    private String fundingSource;

    @SerializedName("bin")
    private String bin;

    @SerializedName("issuerInformation")
    private IssuerInformation issuerInformation;

    @SerializedName("surcharge")
    private String surcharge;

    // Getters
    public String getBinId() { return binId; }
    public String getCardType() { return cardType; }
    public String getBrandName() { return brandName; }
    public String getFundingSource() { return fundingSource; }
    public String getBin() { return bin; }
    public IssuerInformation getIssuerInformation() { return issuerInformation; }
    public String getSurcharge() { return surcharge; }
}

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

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

    public List<BinResponse> getMultipleBinInfo(List<String> binIds) throws Exception {
        // Validate input
        if (binIds == null || binIds.isEmpty()) {
            throw new IllegalArgumentException("BIN IDs list cannot be empty");
        }

        // Validate each BIN
        for (String bin : binIds) {
            if (bin == null || bin.length() < 6) {
                throw new IllegalArgumentException("Invalid BIN: " + bin + ". Must be at least 6 digits.");
            }
        }

        // Create comma-separated list
        String binIdsParam = String.join(",", binIds);

        // URL encode the parameter
        String encodedBinIds = URLEncoder.encode(binIdsParam, StandardCharsets.UTF_8);

        // Construct the endpoint URL
        String endpoint = baseUrl + "/v1/rest/bins?binIds=" + encodedBinIds;

        // Build the HTTP request
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(endpoint))
            .header("Accept", "application/json")
            .GET()
            .build();

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

        // Check response status
        if (response.statusCode() == 200) {
            return gson.fromJson(response.body(), new TypeToken<List<BinResponse>>(){}.getType());
        } else if (response.statusCode() == 404) {
            throw new Exception("One or more BINs not found");
        } else {
            throw new Exception("Request failed with status: " + response.statusCode());
        }
    }

    // Helper: Extract BINs from multiple card numbers
    public List<String> extractBins(List<String> cardNumbers, int binLength) {
        return cardNumbers.stream()
            .map(card -> card.replaceAll("[^0-9]", ""))
            .map(cleaned -> cleaned.substring(0, Math.min(binLength, cleaned.length())))
            .distinct()
            .collect(Collectors.toList());
    }

    // Example usage
    public static void main(String[] args) {
        try {
            BinBulkClient client = new BinBulkClient();

            // Look up multiple BINs
            List<String> binIds = new ArrayList<>();
            binIds.add("411111");
            binIds.add("540123");
            binIds.add("378282");
            binIds.add("601111");

            List<BinResponse> binInfoList = client.getMultipleBinInfo(binIds);

            // Process results
            for (BinResponse binInfo : binInfoList) {
                System.out.println("BIN: " + binInfo.getBin());
                System.out.println("  Brand: " + binInfo.getBrandName());
                System.out.println("  Type: " + binInfo.getCardType());
                System.out.println("  Surcharge: " + binInfo.getSurcharge());
                System.out.println();
            }

            System.out.println("Total BINs processed: " + binInfoList.size());
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

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

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

  def get_multiple_bin_info(bin_ids)
    # Validate input
    raise ArgumentError, 'BIN IDs list cannot be empty' if bin_ids.nil? || bin_ids.empty?

    # Validate each BIN
    bin_ids.each do |bin|
      raise ArgumentError, "Invalid BIN: #{bin}. Must be at least 6 digits." if bin.nil? || bin.length < 6
    end

    # Create comma-separated list
    bin_ids_param = bin_ids.join(',')

    # URL encode the parameter
    encoded_bin_ids = CGI.escape(bin_ids_param)

    # Construct the endpoint URL
    uri = URI("#{@base_url}/v1/rest/bins?binIds=#{encoded_bin_ids}")

    # Create HTTP request
    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true if uri.scheme == 'https'
    http.read_timeout = 30

    request = Net::HTTP::Get.new(uri.request_uri)
    request['Accept'] = 'application/json'

    # Send request and handle response
    response = http.request(request)

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

  # Helper: Extract BINs from multiple card numbers
  def extract_bins(card_numbers, bin_length = 8)
    card_numbers.map do |card|
      cleaned = card.gsub(/[^0-9]/, '')
      cleaned[0, [bin_length, cleaned.length].min]
    end.uniq
  end
end

# Example usage:
client = BinBulkClient.new

# Look up multiple BINs
bin_ids = ['411111', '540123', '378282', '601111']

bin_info_list = client.get_multiple_bin_info(bin_ids)

# Process results
bin_info_list.each do |bin_info|
  puts "BIN: #{bin_info['bin']}"
  puts "  Brand: #{bin_info['brandName']}"
  puts "  Type: #{bin_info['cardType']}"
  puts "  Surcharge: #{bin_info['surcharge']}"
  puts
end

puts "Total BINs processed: #{bin_info_list.length}"

# Example: Get BINs from saved payment methods
saved_cards = [
  '4111111111111111',
  '5401234567890123',
  '378282246310005',
  '6011111111111117'
]

bins = client.extract_bins(saved_cards, 8)
puts "\nLooking up #{bins.length} unique BINs..."
results = client.get_multiple_bin_info(bins)