/api/program/echo

# Test RAIDA network health
curl -X GET "http://localhost:8080/api/program/echo"

# Pretty-print JSON output with jq
curl -X GET "http://localhost:8080/api/program/echo" | jq

# Check if array is usable
curl -s "http://localhost:8080/api/program/echo" | jq '.array_usable'

# Count ready RAIDAs
curl -s "http://localhost:8080/api/program/echo" | jq '.total_available'

# List all RAIDAs that are not ready
curl -s "http://localhost:8080/api/program/echo" | \
  jq '.raidas[] | select(.status != "Ready") | {index, status, latency_ms: .network_latency_ms}'

# Calculate average latency for ready RAIDAs
curl -s "http://localhost:8080/api/program/echo" | \
  jq '[.raidas[] | select(.status == "Ready") | .network_latency_ms] | add / length'

package main

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
    "time"
)

const ApiHost = "http://localhost:8080"

type RAIDAStatus struct {
    Index             int    `json:"index"`
    Status            string `json:"status"`
    NetworkLatencyMs  int    `json:"network_latency_ms"`
    ExecutionTimeNs   int64  `json:"execution_time_ns"`
}

type EchoResponse struct {
    Status         string        `json:"status"`
    Operation      string        `json:"operation"`
    RAIDAs         []RAIDAStatus `json:"raidas"`
    TotalAvailable int           `json:"total_available"`
    ArrayUsable    bool          `json:"array_usable"`
}

func main() {
    fmt.Println("Testing RAIDA Network Health...")
    startTime := time.Now()

    resp, err := http.Get(fmt.Sprintf("%s/api/program/echo", ApiHost))
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    defer resp.Body.Close()

    body, _ := ioutil.ReadAll(resp.Body)

    var result EchoResponse
    if err := json.Unmarshal(body, &result); err != nil {
        fmt.Printf("Error parsing JSON: %v\n", err)
        return
    }

    elapsed := time.Since(startTime)
    fmt.Printf("Request completed in %v\n\n", elapsed)

    // Display summary
    fmt.Printf("RAIDA Network Status:\n")
    fmt.Printf("  Total Available: %d/25\n", result.TotalAvailable)
    fmt.Printf("  Array Usable: %v\n", result.ArrayUsable)

    if !result.ArrayUsable {
        fmt.Println("  ⚠️  WARNING: Array does not meet minimum quorum!")
    }
    fmt.Println()

    // Count by status
    statusCounts := make(map[string]int)
    var totalLatency int
    var readyCount int

    for _, raida := range result.RAIDAs {
        statusCounts[raida.Status]++
        if raida.Status == "Ready" {
            totalLatency += raida.NetworkLatencyMs
            readyCount++
        }
    }

    // Display status breakdown
    fmt.Println("Status Breakdown:")
    for status, count := range statusCounts {
        fmt.Printf("  %s: %d\n", status, count)
    }

    // Calculate and display average latency
    if readyCount > 0 {
        avgLatency := float64(totalLatency) / float64(readyCount)
        fmt.Printf("\nAverage Network Latency: %.2f ms\n", avgLatency)
    }

    // List slow or problematic RAIDAs
    fmt.Println("\nProblematic RAIDAs:")
    hasProblems := false
    for _, raida := range result.RAIDAs {
        if raida.Status != "Ready" {
            fmt.Printf("  RAIDA %d: %s\n", raida.Index, raida.Status)
            hasProblems = true
        } else if raida.NetworkLatencyMs > 1000 {
            fmt.Printf("  RAIDA %d: Slow (%d ms)\n", raida.Index, raida.NetworkLatencyMs)
            hasProblems = true
        }
    }
    if !hasProblems {
        fmt.Println("  None - All RAIDAs healthy!")
    }
}