/api/transactions/import

# Step 1: Start import with POST JSON body
curl -X POST "http://localhost:8080/api/transactions/import" \
  -H "Content-Type: application/json" \
  -d '{
    "files": [
      "C:\\Downloads\\coins1.bin",
      "C:\\Downloads\\stack25.stack"
    ],
    "memo": "Import from exchange"
  }'

# Response:
# {
#   "status": "success",
#   "operation": "import",
#   "task_id": "Jan-31-25_03-45-12-PM",
#   "message": "Import task started successfully",
#   "file_count": 2
# }

# Step 2: Poll task status
curl -X GET "http://localhost:8080/api/transactions/task?id=Jan-31-25_03-45-12-PM"

# Step 3: Check receipt (after completion)
# Receipt saved to: [wallet]/Receipts/Jan-31-25_03-45-12-PM.import.txt

# Step 4: Check wallet balance
curl -X GET "http://localhost:8080/api/wallet/balance"

# Example: Single file import with no memo
curl -X POST "http://localhost:8080/api/transactions/import" \
  -H "Content-Type: application/json" \
  -d '{
    "files": ["/tmp/payment.stack"]
  }'

package main

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

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

type ImportRequest struct {
    Files []string `json:"files"`
    Memo  string   `json:"memo,omitempty"`
}

type ImportResponse struct {
    Status    string `json:"status"`
    Operation string `json:"operation"`
    TaskID    string `json:"task_id"`
    Message   string `json:"message"`
    FileCount int    `json:"file_count"`
}

type TaskStatus struct {
    Status   string `json:"status"`
    Progress int    `json:"progress"`
    Message  string `json:"message"`
}

type WalletBalance struct {
    TotalValue int `json:"total_value"`
    CoinCount  int `json:"coin_count"`
}

func importFiles(filePaths []string, memo string) error {
    // Step 1: Start import with POST JSON body
    requestBody := ImportRequest{
        Files: filePaths,
        Memo:  memo,
    }

    jsonData, err := json.Marshal(requestBody)
    if err != nil {
        return err
    }

    requestURL := fmt.Sprintf("%s/api/transactions/import", ApiHost)
    resp, err := http.Post(requestURL, "application/json", bytes.NewBuffer(jsonData))
    if err != nil {
        return err
    }
    defer resp.Body.Close()

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

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

    if result.Status != "success" {
        return fmt.Errorf("import failed: %s", result.Message)
    }

    fmt.Printf("Import started with task ID: %s\n", result.TaskID)
    fmt.Printf("Processing %d files\n", result.FileCount)

    // Step 2: Poll for completion
    if err := pollTaskStatus(result.TaskID); err != nil {
        return err
    }

    // Step 3: Check receipt
    fmt.Printf("Receipt saved to: [wallet]/Receipts/%s.import.txt\n", result.TaskID)

    // Step 4: Check updated balance
    return checkBalance()
}

func pollTaskStatus(taskID string) error {
    for {
        requestURL := fmt.Sprintf("%s/api/transactions/task?id=%s", ApiHost, taskID)
        resp, err := http.Get(requestURL)
        if err != nil {
            return err
        }

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

        var task TaskStatus
        if err := json.Unmarshal(body, &task); err != nil {
            return err
        }

        fmt.Printf("Status: %s, Progress: %d%%\n", task.Status, task.Progress)

        if task.Status == "completed" {
            fmt.Println("Import complete!")
            return nil
        } else if task.Status == "error" || task.Status == "failed" {
            return fmt.Errorf("import failed: %s", task.Message)
        }

        time.Sleep(1 * time.Second)
    }
}

func checkBalance() error {
    requestURL := fmt.Sprintf("%s/api/wallet/balance", ApiHost)
    resp, err := http.Get(requestURL)
    if err != nil {
        return err
    }
    defer resp.Body.Close()

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

    var balance WalletBalance
    if err := json.Unmarshal(body, &balance); err != nil {
        return err
    }

    fmt.Printf("New wallet balance: %d CloudCoins, Total value: %d\n",
        balance.CoinCount, balance.TotalValue)
    return nil
}

func main() {
    filePaths := []string{
        "C:\\Downloads\\coins1.bin",
        "C:\\Downloads\\stack25.stack",
    }

    if err := importFiles(filePaths, "Import from exchange"); err != nil {
        fmt.Printf("Error: %v\n", err)
    }
}