/api/transactions/task

# Query task status (full endpoint)
curl -X GET "http://localhost:8080/api/transactions/task?task_id=Jan-31-25_03-45-12-PM"

# Query task status (short endpoint)
curl -X GET "http://localhost:8080/api/task?task_id=Oct-26-25_09-15-16-AM"

# Poll in a loop (Bash)
TASK_ID="Nov-01-25_05-49-16-PM"
while true; do
    RESPONSE=$(curl -s "http://localhost:8080/api/task?task_id=$TASK_ID")
    echo "$RESPONSE" | jq .

    STATUS=$(echo "$RESPONSE" | jq -r .status)
    PROGRESS=$(echo "$RESPONSE" | jq -r .progress)

    if [ "$STATUS" = "success" ] && [ "$PROGRESS" = "100" ]; then
        echo "Task completed!"
        break
    elif [ "$STATUS" = "error" ]; then
        echo "Task failed!"
        break
    fi

    sleep 1
done

package main

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

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

type TaskStatus struct {
    Status   string                 `json:"status"`
    TaskID   string                 `json:"task_id"`
    Progress int                    `json:"progress"`
    Message  string                 `json:"message"`
    Data     map[string]interface{} `json:"data"`
}

type POWNResults struct {
    Bank         int `json:"bank"`
    Fracked      int `json:"fracked"`
    Counterfeit  int `json:"counterfeit"`
    Limbo        int `json:"limbo"`
    Errors       int `json:"errors"`
    Suspect      int `json:"suspect"`
}

func getTaskStatus(taskID string) (*TaskStatus, error) {
    url := fmt.Sprintf("%s/api/task?task_id=%s", ApiHost, taskID)

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

    if resp.StatusCode != 200 {
        body, _ := ioutil.ReadAll(resp.Body)
        return nil, fmt.Errorf("HTTP %d: %s", resp.StatusCode, string(body))
    }

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }

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

    return &task, nil
}

func waitForCompletion(taskID string, pollInterval time.Duration) (*TaskStatus, error) {
    fmt.Printf("Waiting for task %s to complete...\n", taskID)

    for {
        task, err := getTaskStatus(taskID)
        if err != nil {
            return nil, err
        }

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

        if task.Status == "success" && task.Progress == 100 {
            fmt.Println("Task completed successfully!")
            return task, nil
        } else if task.Status == "error" {
            return nil, fmt.Errorf("task failed: %s", task.Message)
        }

        time.Sleep(pollInterval)
    }
}

func main() {
    // Example: Check specific task
    taskID := "Oct-26-25_09-15-16-AM"

    task, err := getTaskStatus(taskID)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }

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

    // Pretty print data
    dataJSON, _ := json.MarshalIndent(task.Data, "", "  ")
    fmt.Printf("Data:\n%s\n", string(dataJSON))

    // Example: Wait for completion
    // finalTask, err := waitForCompletion(taskID, 1*time.Second)
    // if err != nil {
    //     fmt.Printf("Error: %v\n", err)
    // }
}