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

Public Class CognitoTokenResponse
    <JsonProperty("access_token")>
    Public Property AccessToken As String

    <JsonProperty("token_type")>
    Public Property TokenType As String

    <JsonProperty("expires_in")>
    Public Property ExpiresIn As Integer
End Class

Public Class CognitoAuthClient
    Private ReadOnly _cognitoDomain As String
    Private ReadOnly _clientId As String
    Private ReadOnly _clientSecret As String
    Private ReadOnly _httpClient As HttpClient

    Public Sub New(cognitoDomain As String, clientId As String, clientSecret As String)
        _cognitoDomain = cognitoDomain
        _clientId = clientId
        _clientSecret = clientSecret
        _httpClient = New HttpClient()
    End Sub

    Public Async Function GetAccessTokenAsync(Optional scope As String = Nothing) _
        As Task(Of CognitoTokenResponse)
        Try
            ' Construct the token endpoint URL
            Dim tokenEndpoint As String = $"{_cognitoDomain}/oauth2/token"

            ' Create Basic Authentication header
            Dim credentials As String = $"{_clientId}:{_clientSecret}"
            Dim base64Credentials As String = Convert.ToBase64String(
                Encoding.UTF8.GetBytes(credentials))

            ' Prepare the request
            Dim request As New HttpRequestMessage(HttpMethod.Post, tokenEndpoint)
            request.Headers.Authorization =
                New AuthenticationHeaderValue("Basic", base64Credentials)

            ' Prepare form-encoded body
            Dim formData As New Dictionary(Of String, String) From {
                {"grant_type", "client_credentials"}
            }

            If Not String.IsNullOrEmpty(scope) Then
                formData.Add("scope", scope)
            End If

            request.Content = New FormUrlEncodedContent(formData)

            ' Send the request
            Dim response As HttpResponseMessage = Await _httpClient.SendAsync(request)
            response.EnsureSuccessStatusCode()

            ' Parse the response
            Dim responseBody As String = Await response.Content.ReadAsStringAsync()
            Dim tokenResponse As CognitoTokenResponse =
                JsonConvert.DeserializeObject(Of CognitoTokenResponse)(responseBody)

            Return tokenResponse

        Catch ex As HttpRequestException
            Console.WriteLine($"Error obtaining token: {ex.Message}")
            Throw
        End Try
    End Function
End Class

' Example usage:
Dim authClient As New CognitoAuthClient(
    "https://your-app.auth.us-east-1.amazoncognito.com",
    "your-client-id",
    "your-client-secret"
)

Dim token As CognitoTokenResponse =
    Await authClient.GetAccessTokenAsync("api/read api/write")

Console.WriteLine($"Access Token: {token.AccessToken}")
Console.WriteLine($"Token Type: {token.TokenType}")
Console.WriteLine($"Expires In: {token.ExpiresIn} seconds")

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.nio.charset.StandardCharsets;
import java.util.Base64;
import com.google.gson.Gson;
import com.google.gson.annotations.SerializedName;

public class CognitoTokenResponse {
    @SerializedName("access_token")
    private String accessToken;

    @SerializedName("token_type")
    private String tokenType;

    @SerializedName("expires_in")
    private int expiresIn;

    // Getters
    public String getAccessToken() { return accessToken; }
    public String getTokenType() { return tokenType; }
    public int getExpiresIn() { return expiresIn; }
}

public class CognitoAuthClient {
    private final String cognitoDomain;
    private final String clientId;
    private final String clientSecret;
    private final HttpClient httpClient;
    private final Gson gson;

    public CognitoAuthClient(String cognitoDomain, String clientId, String clientSecret) {
        this.cognitoDomain = cognitoDomain;
        this.clientId = clientId;
        this.clientSecret = clientSecret;
        this.httpClient = HttpClient.newHttpClient();
        this.gson = new Gson();
    }

    public CognitoTokenResponse getAccessToken(String scope)
            throws IOException, InterruptedException {

        // Construct the token endpoint URL
        String tokenEndpoint = cognitoDomain + "/oauth2/token";

        // Create Basic Authentication header
        String credentials = clientId + ":" + clientSecret;
        String base64Credentials = Base64.getEncoder()
            .encodeToString(credentials.getBytes(StandardCharsets.UTF_8));

        // Prepare form body
        StringBuilder formBody = new StringBuilder("grant_type=client_credentials");
        if (scope != null && !scope.isEmpty()) {
            formBody.append("&scope=").append(scope);
        }

        // Build the request
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(tokenEndpoint))
            .header("Content-Type", "application/x-www-form-urlencoded")
            .header("Authorization", "Basic " + base64Credentials)
            .POST(HttpRequest.BodyPublishers.ofString(formBody.toString()))
            .build();

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

        // Check for successful response
        if (response.statusCode() != 200) {
            throw new IOException("Failed to get token: HTTP " + response.statusCode()
                + " - " + response.body());
        }

        // Parse and return the response
        return gson.fromJson(response.body(), CognitoTokenResponse.class);
    }

    public CognitoTokenResponse getAccessToken()
            throws IOException, InterruptedException {
        return getAccessToken(null);
    }
}

// Example usage:
public class Main {
    public static void main(String[] args) {
        try {
            CognitoAuthClient authClient = new CognitoAuthClient(
                "https://your-app.auth.us-east-1.amazoncognito.com",
                "your-client-id",
                "your-client-secret"
            );

            CognitoTokenResponse token = authClient.getAccessToken("api/read api/write");

            System.out.println("Access Token: " + token.getAccessToken());
            System.out.println("Token Type: " + token.getTokenType());
            System.out.println("Expires In: " + token.getExpiresIn() + " seconds");

        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

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

class CognitoAuthClient
  def initialize(cognito_domain, client_id, client_secret)
    @cognito_domain = cognito_domain
    @client_id = client_id
    @client_secret = client_secret
  end

  def get_access_token(scope = nil)
    # Construct the token endpoint URL
    token_endpoint = "#{@cognito_domain}/oauth2/token"
    uri = URI.parse(token_endpoint)

    # Create Basic Authentication header
    credentials = "#{@client_id}:#{@client_secret}"
    base64_credentials = Base64.strict_encode64(credentials)

    # Prepare form body
    form_data = { 'grant_type' => 'client_credentials' }
    form_data['scope'] = scope unless scope.nil? || scope.empty?

    # Create the HTTP request
    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true

    request = Net::HTTP::Post.new(uri.path)
    request['Content-Type'] = 'application/x-www-form-urlencoded'
    request['Authorization'] = "Basic #{base64_credentials}"
    request.set_form_data(form_data)

    # Send the request
    response = http.request(request)

    # Handle the response
    if response.code.to_i == 200
      token_response = JSON.parse(response.body)
      {
        access_token: token_response['access_token'],
        token_type: token_response['token_type'],
        expires_in: token_response['expires_in']
      }
    else
      raise "Failed to get token: HTTP #{response.code} - #{response.body}"
    end
  rescue StandardError => e
    puts "Error obtaining token: #{e.message}"
    raise
  end
end

# Example usage:
begin
  auth_client = CognitoAuthClient.new(
    'https://your-app.auth.us-east-1.amazoncognito.com',
    'your-client-id',
    'your-client-secret'
  )

  token = auth_client.get_access_token('api/read api/write')

  puts "Access Token: #{token[:access_token]}"
  puts "Token Type: #{token[:token_type]}"
  puts "Expires In: #{token[:expires_in]} seconds"

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