Imports System.Net.Http
Imports System.Text.Json
Imports System.Text.Json.Serialization
Imports System.Collections.Generic

Public Class ShallowStatusClient
    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)
        _httpClient.Timeout = TimeSpan.FromSeconds(10)
    End Sub

    Public Async Function CheckShallowStatusAsync() As Task(Of DependencyCheckResponse)
        Try
            ' Make the GET request (no authentication required)
            Dim response As HttpResponseMessage = Await _httpClient.GetAsync("/v1/rest/status/shallow")
            Dim responseBody As String = Await response.Content.ReadAsStringAsync()

            Dim options As New JsonSerializerOptions()
            options.PropertyNameCaseInsensitive = True
            Dim result As DependencyCheckResponse = JsonSerializer.Deserialize(Of DependencyCheckResponse)(responseBody, options)

            ' HTTP 200 = all healthy, HTTP 503 = one or more unhealthy
            If response.IsSuccessStatusCode Then
                Console.WriteLine("All dependencies are healthy.")
            ElseIf CInt(response.StatusCode) = 503 Then
                Console.WriteLine("One or more dependencies are unhealthy:")
                For Each dep In result.Dependencies
                    If dep.Status <> "Healthy" Then
                        Console.WriteLine($"  - {dep.Name}: {dep.Status} ({dep.Message})")
                    End If
                Next
            End If

            Return result
        Catch ex As Exception
            Console.WriteLine($"Shallow status check failed: {ex.Message}")
            Throw
        End Try
    End Function
End Class

Public Class DependencyCheckResponse
    Public Property Status As String
    Public Property Dependencies As List(Of DependencyStatus)
End Class

Public Class DependencyStatus
    Public Property Name As String
    Public Property Status As String
    Public Property Message As String
End Class

' Example usage:
Dim client As New ShallowStatusClient()
Dim statusResponse As DependencyCheckResponse = Await client.CheckShallowStatusAsync()

Console.WriteLine($"Overall Status: {statusResponse.Status}")
For Each dep In statusResponse.Dependencies
    Console.WriteLine($"  {dep.Name}: {dep.Status} - {dep.Message}")
Next

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.List;

public class ShallowStatusClient {
    private final HttpClient httpClient;
    private final String baseUrl;
    private final ObjectMapper objectMapper;

    public ShallowStatusClient() {
        this.baseUrl = "https://your-api-domain.com";
        this.httpClient = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(10))
            .build();
        this.objectMapper = new ObjectMapper();
    }

    public DependencyCheckResponse checkShallowStatus() throws Exception {
        // Construct the endpoint URL
        String endpoint = baseUrl + "/v1/rest/status/shallow";

        // Build the HTTP request (no authentication required)
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(endpoint))
            .timeout(Duration.ofSeconds(10))
            .GET()
            .build();

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

        DependencyCheckResponse result = objectMapper.readValue(
            response.body(),
            DependencyCheckResponse.class
        );

        // HTTP 200 = all healthy, HTTP 503 = one or more unhealthy
        if (response.statusCode() == 200) {
            System.out.println("All dependencies are healthy.");
        } else if (response.statusCode() == 503) {
            System.out.println("One or more dependencies are unhealthy:");
            for (DependencyStatus dep : result.dependencies) {
                if (!"Healthy".equals(dep.status)) {
                    System.out.println("  - " + dep.name + ": " + dep.status + " (" + dep.message + ")");
                }
            }
        } else {
            throw new Exception("Unexpected status code: " + response.statusCode());
        }

        return result;
    }

    public static class DependencyCheckResponse {
        public String status;
        public List<DependencyStatus> dependencies;
    }

    public static class DependencyStatus {
        public String name;
        public String status;
        public String message;
    }

    // Example usage
    public static void main(String[] args) {
        try {
            ShallowStatusClient client = new ShallowStatusClient();
            DependencyCheckResponse result = client.checkShallowStatus();

            System.out.println("Overall Status: " + result.status);
            for (DependencyStatus dep : result.dependencies) {
                System.out.println("  " + dep.name + ": " + dep.status + " - " + dep.message);
            }
        } catch (Exception e) {
            System.out.println("Shallow status check failed: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

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

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

  def check_shallow_status
    # Construct the endpoint URL
    uri = URI("#{@base_url}/v1/rest/status/shallow")

    # Create the HTTP request (no authentication required)
    request = Net::HTTP::Get.new(uri)

    # Send the request with timeout
    response = Timeout.timeout(10) do
      Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
        http.request(request)
      end
    end

    result = JSON.parse(response.body)

    # HTTP 200 = all healthy, HTTP 503 = one or more unhealthy
    case response.code.to_i
    when 200
      puts 'All dependencies are healthy.'
    when 503
      puts 'One or more dependencies are unhealthy:'
      result['dependencies']&.each do |dep|
        unless dep['status'] == 'Healthy'
          puts "  - #{dep['name']}: #{dep['status']} (#{dep['message']})"
        end
      end
    else
      raise "Unexpected status code: #{response.code}"
    end

    result
  rescue StandardError => e
    puts "Shallow status check failed: #{e.message}"
    raise
  end
end

# Example usage:
client = ShallowStatusClient.new
result = client.check_shallow_status

puts "Overall Status: #{result['status']}"
result['dependencies']&.each do |dep|
  puts "  #{dep['name']}: #{dep['status']} - #{dep['message']}"
end