/api/raida/countcoins

# Count all coins in RAIDA network
curl -X GET "http://localhost:8080/api/raida/countcoins"

# Pretty-print JSON output with jq
curl -X GET "http://localhost:8080/api/raida/countcoins" | jq .

# Extract only successful response count
curl -X GET "http://localhost:8080/api/raida/countcoins" | jq '.successful_responses'

# Show total value for each RAIDA
curl -X GET "http://localhost:8080/api/raida/countcoins" | \
  jq '.raida_responses[] | "RAIDA \(.raida_id): \(.total_value) CloudCoins"'

package main

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

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

type Denomination struct {
    Denomination string `json:"denomination"`
    Count        int    `json:"count"`
}

type RaidaResponse struct {
    RaidaID        int            `json:"raida_id"`
    Denominations  []Denomination `json:"denominations"`
    TotalValue     int            `json:"total_value"`
}

type AuditResponse struct {
    Status              string          `json:"status"`
    Operation           string          `json:"operation"`
    SuccessfulResponses int             `json:"successful_responses"`
    TotalRaidas         int             `json:"total_raidas"`
    RaidaResponses      []RaidaResponse `json:"raida_responses"`
}

func main() {
    resp, err := http.Get(fmt.Sprintf("%s/api/raida/countcoins", ApiHost))
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

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

    var result AuditResponse
    if err := json.Unmarshal(body, &result); err != nil {
        panic(err)
    }

    if result.Status == "success" {
        fmt.Printf("Network Audit Results:\n")
        fmt.Printf("Successful RAIDAs: %d/%d\n\n", result.SuccessfulResponses, result.TotalRaidas)

        networkTotal := 0
        for _, raida := range result.RaidaResponses {
            fmt.Printf("RAIDA %d: %d CloudCoins\n", raida.RaidaID, raida.TotalValue)
            networkTotal += raida.TotalValue
        }

        avgPerRaida := networkTotal / result.SuccessfulResponses
        fmt.Printf("\nAverage per RAIDA: %d CloudCoins\n", avgPerRaida)
    } else {
        fmt.Printf("Error occurred\n")
    }
}

import requests
from collections import defaultdict

API_HOST = "http://localhost:8080"

def count_network_coins():
    try:
        response = requests.get(f"{API_HOST}/api/raida/countcoins")
        result = response.json()

        if result['status'] == 'success':
            print("Network Audit Results:")
            print(f"Successful RAIDAs: {result['successful_responses']}/{result['total_raidas']}\n")

            # Calculate network totals
            network_total = 0
            denomination_totals = defaultdict(int)

            for raida in result['raida_responses']:
                print(f"RAIDA {raida['raida_id']}: {raida['total_value']} CloudCoins")
                network_total += raida['total_value']

                for denom in raida['denominations']:
                    denomination_totals[denom['denomination']] += denom['count']

            avg_per_raida = network_total // result['successful_responses']
            print(f"\nAverage per RAIDA: {avg_per_raida} CloudCoins\n")

            print("Denomination Distribution:")
            for denom in sorted(denomination_totals.keys(), key=lambda x: float(x)):
                print(f"  {denom}: {denomination_totals[denom]} coins")
        else:
            print(f"Error: {result.get('message', 'Unknown error')}")

    except requests.exceptions.RequestException as e:
        print(f"Network error: {e}")

if __name__ == "__main__":
    count_network_coins()