/api/transactions/locker/download

# Download coins from locker (automatically grades to Bank/Fracked/Counterfeit)
curl -X GET "http://localhost:8080/api/transactions/locker/download?locker_key=0123456789abcdef0123456789abcdef"

# Example output:
# {
#   "status": "success",
#   "operation": "locker_download",
#   "coins_found": 5,
#   "coins_saved": 5,
#   "graded_to_bank": 4,
#   "graded_to_fracked": 1,
#   "graded_to_counterfeit": 0,
#   "locker_key": "0123456789abcdef0123456789abcdef"
# }

# Optional: Fix fracked coins if any were downloaded
curl -X GET "http://localhost:8080/api/coins/fix"

package main

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

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

type LockerDownloadResponse struct {
    Status             string `json:"status"`
    Operation          string `json:"operation"`
    CoinsFound         int    `json:"coins_found"`
    CoinsSaved         int    `json:"coins_saved"`
    GradedToBank       int    `json:"graded_to_bank"`
    GradedToFracked    int    `json:"graded_to_fracked"`
    GradedToCounterfeit int   `json:"graded_to_counterfeit"`
    LockerKey          string `json:"locker_key"`
}

type ErrorResponse struct {
    Status   string `json:"status"`
    Error    string `json:"error"`
    HTTPCode int    `json:"http_code"`
}

func downloadFromLocker(lockerKey string) error {
    url := fmt.Sprintf("%s/api/transactions/locker/download?locker_key=%s",
        ApiHost, lockerKey)

    resp, err := http.Get(url)
    if err != nil {
        return err
    }
    defer resp.Body.Close()

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

    if resp.StatusCode == 200 {
        var result LockerDownloadResponse
        if err := json.Unmarshal(body, &result); err != nil {
            return err
        }

        fmt.Printf("Success! Downloaded and graded %d coins\n", result.CoinsSaved)
        fmt.Printf("Total coins found: %d\n", result.CoinsFound)
        fmt.Printf("Graded to Bank: %d\n", result.GradedToBank)
        fmt.Printf("Graded to Fracked: %d\n", result.GradedToFracked)
        fmt.Printf("Graded to Counterfeit: %d\n", result.GradedToCounterfeit)

        // Optional: Fix fracked coins if any
        if result.GradedToFracked > 0 {
            fmt.Println("Running fix for fracked coins...")
            fixFrackedCoins()
        }

        return nil
    } else {
        var errResp ErrorResponse
        if err := json.Unmarshal(body, &errResp); err != nil {
            return err
        }
        return fmt.Errorf("Error %d: %s", errResp.HTTPCode, errResp.Error)
    }
}

func fixFrackedCoins() error {
    resp, err := http.Get(fmt.Sprintf("%s/api/coins/fix", ApiHost))
    if err != nil {
        return err
    }
    defer resp.Body.Close()
    fmt.Println("Fix complete")
    return nil
}

func main() {
    lockerKey := "0123456789abcdef0123456789abcdef"

    if err := downloadFromLocker(lockerKey); err != nil {
        fmt.Printf("Error: %v\n", err)
    }
}