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 BinClient
    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 GetBinInfoAsync(binId As String) As Task(Of BinResponse)
        Try
            ' Validate input
            If String.IsNullOrEmpty(binId) OrElse binId.Length < 6 Then
                Throw New ArgumentException("BIN ID must be at least 6 digits", NameOf(binId))
            End If

            ' Construct the endpoint URL
            Dim endpoint As String = $"/v1/rest/bins/{binId}"

            ' 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 binInfo As BinResponse = JsonConvert.DeserializeObject(Of BinResponse)(responseBody)

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

    ' Helper method: Extract BIN from full card number
    Public Function ExtractBin(cardNumber As String, Optional binLength As Integer = 8) As String
        ' Remove spaces and non-numeric characters
        Dim cleaned As String = New String(cardNumber.Where(AddressOf Char.IsDigit).ToArray())

        ' Return first 6-8 digits
        Return cleaned.Substring(0, Math.Min(binLength, cleaned.Length))
    End Function
End Class

' Example usage:
Dim client As New BinClient()

' Look up BIN using first 8 digits of card
Dim cardNumber As String = "4111111111111111"
Dim bin As String = client.ExtractBin(cardNumber, 8)

Dim binInfo As BinResponse = Await client.GetBinInfoAsync(bin)

Console.WriteLine($"Card Brand: {binInfo.BrandName}")
Console.WriteLine($"Card Type: {binInfo.CardType}")
Console.WriteLine($"Issuing Bank: {binInfo.IssuerInformation?.Name}")
Console.WriteLine($"Surcharge Allowed: {binInfo.Surcharge}")

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

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 BinClient {
    private final HttpClient httpClient;
    private final String baseUrl;
    private final Gson gson;

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

    public BinResponse getBinInfo(String binId) throws Exception {
        // Validate input
        if (binId == null || binId.length() < 6) {
            throw new IllegalArgumentException("BIN ID must be at least 6 digits");
        }

        // Construct the endpoint URL
        String endpoint = baseUrl + "/v1/rest/bins/" + binId;

        // 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(), BinResponse.class);
        } else if (response.statusCode() == 404) {
            throw new Exception("BIN not found: " + binId);
        } else {
            throw new Exception("Request failed with status: " + response.statusCode());
        }
    }

    // Helper method: Extract BIN from full card number
    public String extractBin(String cardNumber, int binLength) {
        // Remove spaces and non-numeric characters
        String cleaned = cardNumber.replaceAll("[^0-9]", "");

        // Return first 6-8 digits
        return cleaned.substring(0, Math.min(binLength, cleaned.length()));
    }

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

            // Look up BIN using first 8 digits of card
            String cardNumber = "4111111111111111";
            String bin = client.extractBin(cardNumber, 8);

            BinResponse binInfo = client.getBinInfo(bin);

            System.out.println("Card Brand: " + binInfo.getBrandName());
            System.out.println("Card Type: " + binInfo.getCardType());
            System.out.println("Issuing Bank: " +
                (binInfo.getIssuerInformation() != null ?
                 binInfo.getIssuerInformation().getName() : "N/A"));
            System.out.println("Surcharge Allowed: " + binInfo.getSurcharge());
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

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

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

  def get_bin_info(bin_id)
    # Validate input
    raise ArgumentError, 'BIN ID must be at least 6 digits' if bin_id.nil? || bin_id.length < 6

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

    # 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.path)
    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 "BIN not found: #{bin_id}"
    else
      raise "Request failed with status: #{response.code} - #{response.message}"
    end
  rescue StandardError => e
    puts "Request error: #{e.message}"
    raise
  end

  # Helper method: Extract BIN from full card number
  def extract_bin(card_number, bin_length = 8)
    # Remove spaces and non-numeric characters
    cleaned = card_number.gsub(/[^0-9]/, '')

    # Return first 6-8 digits
    cleaned[0, [bin_length, cleaned.length].min]
  end
end

# Example usage:
client = BinClient.new

# Look up BIN using first 8 digits of card
card_number = '4111111111111111'
bin = client.extract_bin(card_number, 8)

bin_info = client.get_bin_info(bin)

puts "Card Brand: #{bin_info['brandName']}"
puts "Card Type: #{bin_info['cardType']}"
puts "Issuing Bank: #{bin_info.dig('issuerInformation', 'name') || 'N/A'}"
puts "Surcharge Allowed: #{bin_info['surcharge']}"

puts "\nFull Response:"
puts JSON.pretty_generate(bin_info)