tasks.go

package csclient

import (
	"context"
	"fmt"
	"time"
)

// GetTask retrieves detailed information about a specific task
func (c *Client) GetTask(ctx context.Context, taskID string) (*TaskDetailDto, error) {
	var task TaskDetailDto
	path := fmt.Sprintf("/api/v1/tasks/%s", taskID)
	if err := c.doRequest(ctx, "GET", path, nil, &task, true); err != nil {
		return nil, fmt.Errorf("failed to get task: %w", err)
	}
	return &task, nil
}

// ListTasks retrieves all tasks
func (c *Client) ListTasks(ctx context.Context) ([]TaskSummaryDto, error) {
	var tasks []TaskSummaryDto
	if err := c.doRequest(ctx, "GET", "/api/v1/tasks", nil, &tasks, true); err != nil {
		return nil, fmt.Errorf("failed to list tasks: %w", err)
	}
	return tasks, nil
}

// GetBeaconTasksSummary retrieves task summaries for a specific beacon
func (c *Client) GetBeaconTasksSummary(ctx context.Context, bid string) ([]TaskSummaryDto, error) {
	var tasks []TaskSummaryDto
	path := fmt.Sprintf("/api/v1/beacons/%s/tasks/summary", bid)
	if err := c.doRequest(ctx, "GET", path, nil, &tasks, true); err != nil {
		return nil, fmt.Errorf("failed to get beacon tasks: %w", err)
	}
	return tasks, nil
}

// GetBeaconTasksDetail retrieves detailed tasks for a specific beacon
func (c *Client) GetBeaconTasksDetail(ctx context.Context, bid string) ([]TaskDetailDto, error) {
	var tasks []TaskDetailDto
	path := fmt.Sprintf("/api/v1/beacons/%s/tasks/detail", bid)
	if err := c.doRequest(ctx, "GET", path, nil, &tasks, true); err != nil {
		return nil, fmt.Errorf("failed to get beacon task details: %w", err)
	}
	return tasks, nil
}

// WaitForTaskAck polls a task briefly to see if it completes quickly.
// If the task transitions to a terminal state (COMPLETED/OUTPUT_RECEIVED/FAILED) within
// the timeout, it returns that result. If the task stays IN_PROGRESS after the timeout,
// it returns the last known task state with a nil error (fire-and-forget acknowledgment).
// This is designed for commands that may never produce output (e.g., mkdir, cd, sleep, etc.).
func (c *Client) WaitForTaskAck(ctx context.Context, taskID string, timeout time.Duration) (*TaskDetailDto, error) {
	deadline := time.Now().Add(timeout)
	ticker := time.NewTicker(2 * time.Second)
	defer ticker.Stop()

	for {
		select {
		case <-ctx.Done():
			return nil, ctx.Err()
		case <-ticker.C:
			task, err := c.GetTask(ctx, taskID)
			if err != nil {
				return nil, err
			}

			// If terminal state, return immediately
			if task.TaskStatus == TaskStatusCompleted ||
				task.TaskStatus == TaskStatusOutputReceived ||
				task.TaskStatus == TaskStatusFailed {
				return task, nil
			}

			// If past deadline and still IN_PROGRESS, treat as acknowledged
			if time.Now().After(deadline) {
				return task, nil
			}
		}
	}
}

// WaitForTaskCompletion polls a task until it completes or times out
func (c *Client) WaitForTaskCompletion(ctx context.Context, taskID string, timeout time.Duration) (*TaskDetailDto, error) {
	deadline := time.Now().Add(timeout)
	ticker := time.NewTicker(2 * time.Second)
	defer ticker.Stop()

	for {
		select {
		case <-ctx.Done():
			return nil, ctx.Err()
		case <-ticker.C:
			if time.Now().After(deadline) {
				return nil, fmt.Errorf("timeout waiting for task completion")
			}

			task, err := c.GetTask(ctx, taskID)
			if err != nil {
				return nil, err
			}

			if task.TaskStatus == TaskStatusCompleted ||
			   task.TaskStatus == TaskStatusOutputReceived ||
			   task.TaskStatus == TaskStatusFailed {
				return task, nil
			}
		}
	}
}