# 👀 Specify an execution timeout on a task
@timeout_wf.task(
    execution_timeout=timedelta(seconds=5), schedule_timeout=timedelta(minutes=10)
)
def timeout_task(input: EmptyModel, ctx: Context) -> dict[str, str]:
    time.sleep(30)
    return {"status": "success"}

export const withTimeouts = hatchet.task({
  name: 'with-timeouts',
  // time the task can wait in the queue before it is cancelled
  scheduleTimeout: '10s',
  // time the task can run before it is cancelled
  executionTimeout: '10s',
  fn: async (input: SimpleInput, ctx) => {
    // wait 15 seconds
    await sleep(15000);

    // get the abort controller
    const { abortController } = ctx;

    // if the abort controller is aborted, throw an error
    if (abortController.signal.aborted) {
      throw new Error('cancelled');
    }

    return {
      TransformedMessage: input.Message.toLowerCase(),
    };
  },
});

// Task that will timeout - sleeps for 10 seconds but has 3 second timeout
_ = timeoutWorkflow.NewTask("timeout-task",
	func(ctx hatchet.Context, input TimeoutInput) (TimeoutOutput, error) {
		log.Printf("Starting task that will timeout. Message: %s", input.Message)

		// Sleep for 10 seconds (will be interrupted by timeout)
		time.Sleep(10 * time.Second)

		// This should not be reached due to timeout
		log.Println("Task completed successfully (this shouldn't be reached)")
		return TimeoutOutput{
			Status:    "completed",
			Completed: true,
		}, nil
	},
	hatchet.WithExecutionTimeout(3*time.Second), // 3 second timeout
)

# Specify an execution timeout on a task
TIMEOUT_WF.task(:timeout_task, execution_timeout: 5, schedule_timeout: 600) do |input, ctx|
  sleep 30
  { "status" => "success" }
end

REFRESH_TIMEOUT_WF = HATCHET.workflow(name: "RefreshTimeoutWorkflow")

@refresh_timeout_wf.task(execution_timeout=timedelta(seconds=4))
def refresh_task(input: EmptyModel, ctx: Context) -> dict[str, str]:
    ctx.refresh_timeout(timedelta(seconds=10))
    time.sleep(5)

    return {"status": "success"}

export const refreshTimeout = hatchet.task({
  name: 'refresh-timeout',
  executionTimeout: '10s',
  scheduleTimeout: '10s',
  fn: async (input: SimpleInput, ctx) => {
    // adds 15 seconds to the execution timeout
    ctx.refreshTimeout('15s');
    await sleep(15000);

    // get the abort controller
    const { abortController } = ctx;

    // now this condition will not be met
    // if the abort controller is aborted, throw an error
    if (abortController.signal.aborted) {
      throw new Error('cancelled');
    }

    return {
      TransformedMessage: input.Message.toLowerCase(),
    };
  },
});

// Create workflow with timeout refresh example
refreshTimeoutWorkflow := client.NewWorkflow("refresh-timeout-demo",
	hatchet.WithWorkflowDescription("Demonstrates timeout refresh functionality"),
	hatchet.WithWorkflowVersion("1.0.0"),
)

// Task that refreshes its timeout to avoid timing out
_ = refreshTimeoutWorkflow.NewTask("refresh-timeout-task",
	func(ctx hatchet.Context, input TimeoutInput) (TimeoutOutput, error) {
		log.Printf("Starting task with timeout refresh. Message: %s", input.Message)

		// Refresh timeout by 10 seconds
		log.Println("Refreshing timeout by 10 seconds...")
		err := ctx.RefreshTimeout("10s")
		if err != nil {
			log.Printf("Failed to refresh timeout: %v", err)
			return TimeoutOutput{
				Status:    "failed",
				Completed: false,
			}, err
		}

		// Now sleep for 5 seconds (should complete successfully)
		log.Println("Sleeping for 5 seconds...")
		time.Sleep(5 * time.Second)

		log.Println("Task completed successfully after timeout refresh")
		return TimeoutOutput{
			Status:    "completed",
			Completed: true,
		}, nil
	},
	hatchet.WithExecutionTimeout(3*time.Second), // Initial 3 second timeout
)

REFRESH_TIMEOUT_WF.task(:refresh_task, execution_timeout: 4) do |input, ctx|
  ctx.refresh_timeout(10)
  sleep 5

  { "status" => "success" }
end