/api/coins/join

# Join coins into 1000 denomination (code 5)
curl -X GET "http://localhost:8080/api/coins/join?denomination=5"

# Join coins into 100 denomination (code 3)
curl -X GET "http://localhost:8080/api/coins/join?denomination=3"

# Join coins into 25000 denomination (code 7)
curl -X GET "http://localhost:8080/api/coins/join?denomination=7"

# Pretty-print JSON response with jq
curl -X GET "http://localhost:8080/api/coins/join?denomination=5" | jq .

# Check for errors
curl -X GET "http://localhost:8080/api/coins/join?denomination=99" | jq .

package main

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

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

type SourceCoin struct {
    SerialNumber int `json:"serial_number"`
    Denomination int `json:"denomination"`
    Value        int `json:"value"`
}

type JoinedCoin struct {
    SerialNumber int    `json:"serial_number"`
    Denomination int    `json:"denomination"`
    Value        int    `json:"value"`
    FilePath     string `json:"file_path"`
}

type RaidaResults struct {
    TotalRaidas  int `json:"total_raidas"`
    SuccessCount int `json:"success_count"`
    FailCount    int `json:"fail_count"`
    ErrorCount   int `json:"error_count"`
}

type JoinResponse struct {
    Status               string       `json:"status"`
    Operation            string       `json:"operation"`
    Message              string       `json:"message"`
    Wallet               string       `json:"wallet"`
    TargetDenomination   int          `json:"target_denomination"`
    TargetValue          int          `json:"target_value"`
    Note                 string       `json:"note"`
    // Future implementation fields:
    SourceCoins          []SourceCoin `json:"source_coins,omitempty"`
    SourceCount          int          `json:"source_count,omitempty"`
    JoinedCoin           *JoinedCoin  `json:"joined_coin,omitempty"`
    RaidaResults         *RaidaResults `json:"raida_results,omitempty"`
    PownString           string       `json:"pown_string,omitempty"`
    AuthenticityStatus   string       `json:"authenticity_status,omitempty"`
}

// Denomination value reference
var DenominationValues = map[int]int{
    0: 1,
    1: 5,
    2: 25,
    3: 100,
    4: 250,
    5: 1000,
    6: 5000,
    7: 25000,
    8: 100000,
    9: 250000,
    10: 1000000,
}

func joinCoins(targetDenomination int) (*JoinResponse, error) {
    url := fmt.Sprintf("%s/api/coins/join?denomination=%d",
        ApiHost, targetDenomination)

    resp, err := http.Get(url)
    if err != nil {
        return nil, fmt.Errorf("request failed: %v", err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return nil, fmt.Errorf("failed to read response: %v", err)
    }

    var result JoinResponse
    if err := json.Unmarshal(body, &result); err != nil {
        return nil, fmt.Errorf("failed to parse JSON: %v", err)
    }

    return &result, nil
}

func main() {
    // Join into 1000 denomination (code 5)
    result, err := joinCoins(5)
    if err != nil {
        panic(err)
    }

    if result.Status == "success" {
        fmt.Println("Join Operation (Parameter Validation):")
        fmt.Printf("Target Denomination: %d\n", result.TargetDenomination)
        fmt.Printf("Target Value: %d\n", result.TargetValue)
        fmt.Printf("Wallet: %s\n", result.Wallet)
        fmt.Printf("Note: %s\n", result.Note)

        // Future implementation will include:
        // fmt.Printf("Source Coins: %d\n", result.SourceCount)
        // fmt.Printf("Joined Coin SN: %d\n", result.JoinedCoin.SerialNumber)
        // fmt.Printf("POWN String: %s\n", result.PownString)
        // fmt.Printf("Status: %s\n", result.AuthenticityStatus)
    } else {
        fmt.Printf("Join failed: %s\n", result.Message)
    }

    // Example: Join different denominations
    denominations := []int{3, 5, 7} // 100, 1000, 25000
    for _, denom := range denominations {
        result, err := joinCoins(denom)
        if err != nil {
            fmt.Printf("Error for denomination %d: %v\n", denom, err)
            continue
        }
        value := DenominationValues[denom]
        fmt.Printf("Validated join into %d (value: %d)\n", denom, value)
    }
}