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

Public Class DeepStatusClient
    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)
        ' Longer timeout for deep checks (2-5 seconds expected)
        _httpClient.Timeout = TimeSpan.FromSeconds(30)
    End Sub

    Public Async Function CheckDeepStatusAsync() As Task(Of DependencyCheckResponse)
        Try
            ' Make the GET request (no authentication required)
            Dim response As HttpResponseMessage = Await _httpClient.GetAsync("/v1/rest/status/deep")
            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 passed deep health checks.")
            ElseIf CInt(response.StatusCode) = 503 Then
                Console.WriteLine("One or more dependencies failed deep health checks:")
                For Each dep In result.Dependencies
                    If dep.Status <> "Healthy" Then
                        Console.WriteLine($"  - {dep.Name}: {dep.Status}")
                        Console.WriteLine($"    Message: {dep.Message}")
                    End If
                Next
            End If

            Return result
        Catch ex As TaskCanceledException
            Console.WriteLine("Deep status check timed out. The service may be under heavy load.")
            Throw
        Catch ex As Exception
            Console.WriteLine($"Deep 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 DeepStatusClient()
Dim statusResponse As DependencyCheckResponse = Await client.CheckDeepStatusAsync()

Console.WriteLine($"Overall Status: {statusResponse.Status}")
Console.WriteLine("Dependency Details:")
For Each dep In statusResponse.Dependencies
    Dim indicator As String = If(dep.Status = "Healthy", "[OK]", "[FAIL]")
    Console.WriteLine($"  {indicator} {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 DeepStatusClient {
    private final HttpClient httpClient;
    private final String baseUrl;
    private final ObjectMapper objectMapper;

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

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

        // Build the HTTP request (no authentication required)
        // Use a longer timeout for deep checks (2-5 seconds expected)
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(endpoint))
            .timeout(Duration.ofSeconds(30))
            .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 passed deep health checks.");
        } else if (response.statusCode() == 503) {
            System.out.println("One or more dependencies failed deep health checks:");
            for (DependencyStatus dep : result.dependencies) {
                if (!"Healthy".equals(dep.status)) {
                    System.out.println("  - " + dep.name + ": " + dep.status);
                    System.out.println("    Message: " + 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 {
            DeepStatusClient client = new DeepStatusClient();
            DependencyCheckResponse result = client.checkDeepStatus();

            System.out.println("Overall Status: " + result.status);
            System.out.println("Dependency Details:");
            for (DependencyStatus dep : result.dependencies) {
                String indicator = "Healthy".equals(dep.status) ? "[OK]" : "[FAIL]";
                System.out.println("  " + indicator + " " + dep.name + ": " + dep.status + " - " + dep.message);
            }
        } catch (Exception e) {
            System.out.println("Deep status check failed: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

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

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

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

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

    # Send the request with a longer timeout for deep checks (2-5 seconds expected)
    response = Timeout.timeout(30) do
      Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
        http.read_timeout = 30
        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 passed deep health checks.'
    when 503
      puts 'One or more dependencies failed deep health checks:'
      result['dependencies']&.each do |dep|
        unless dep['status'] == 'Healthy'
          puts "  - #{dep['name']}: #{dep['status']}"
          puts "    Message: #{dep['message']}"
        end
      end
    else
      raise "Unexpected status code: #{response.code}"
    end

    result
  rescue Timeout::Error
    puts 'Deep status check timed out. The service may be under heavy load.'
    raise
  rescue StandardError => e
    puts "Deep status check failed: #{e.message}"
    raise
  end
end

# Example usage:
client = DeepStatusClient.new
result = client.check_deep_status

puts "Overall Status: #{result['status']}"
puts 'Dependency Details:'
result['dependencies']&.each do |dep|
  indicator = dep['status'] == 'Healthy' ? '[OK]' : '[FAIL]'
  puts "  #{indicator} #{dep['name']}: #{dep['status']} - #{dep['message']}"
end