const result = await agent.utils.job.submitTask({
  automationStatus: "success",
  data: { orderId: "12345", totalAmount: 99.99 },
  resultType: { "Account Type": "Old Account" },
  // finish defaults to true; files defaults to []
});

if (result.success) {
  console.log("Task submitted successfully");
}

const result = await agent.utils.job.submitTask(
  "success",
  {
    orderId: "12345",
    totalAmount: 99.99,
    itemsProcessed: 3
  },
  true, // Final submission
  []    // No files
);

if (result.success) {
  console.log("Task submitted successfully");
}

const screenshot = await agent.actions.screenshot(1080, 1920, 80);

const result = await agent.utils.job.submitTask(
  "success",
  { status: "completed" },
  true, // Final submission
  [{
    name: "confirmation",
    extension: "jpg",
    base64Data: screenshot.screenshot || ""
  }]
);

// Note: files parameter is ignored when finish=false
await agent.utils.job.submitTask(
  "running",
  { currentStep: 3, totalSteps: 10 },
  false, // More submissions coming
  []     // Files ignored for progress updates
);

await agent.utils.job.submitTask(
  "declined",
  { reason: "Item out of stock" },
  true, // Final submission
  []
);

const result = await agent.utils.job.setResultType({
  "Account Type": "Old Account",
});

if (result.success) {
  console.log("Task price is now", result.job_price);
}

await agent.utils.job.submitTask(
  "success",
  { email: account.email },
  true, // Final submission
  [],   // No files
  { "Account Type": "New Account" }
);

const result = await agent.utils.job.submitTaskToAnotherJob({
  job_id: "68868530c189957861cd698a",
  data: { email: account.email, password: account.password },
  status: "pending",
  resultType: { "Account Type": "Old Account" },
});

if (result.success) {
  console.log("Sink task", result.job_task_id);
}

const result = await agent.utils.job.submitTaskToAnotherJob(
  "68868530c189957861cd698a", // target data-dump job_id
  {
    email: "lead@example.com",
    name: "Jane Doe",
    capturedAt: Date.now(),
  },
);
if (result.success) {
  console.log("Wrote dump task", result.job_task_id, "to job", result.job_id);
}

const screenshot = await agent.actions.screenshot(1080, 1920, 80);

await agent.utils.job.submitTaskToAnotherJob(
  "68868530c189957861cd698a",
  { note: "Profile page state at capture" },
  "pending",
  [{
    name: "snapshot",   // proof.snapshot will hold the public URL
    extension: ".jpg",
    base64Data: screenshot.screenshot || "",
  }],
);

await agent.utils.job.submitTaskToAnotherJob(
  "68868530c189957861cd698a",
  { reason: "captcha blocked" },
  "failed",
);

// First, the other task must mark itself as waiting:
// await agent.utils.setAutomationVariables({ waiting: true });

// Then this task can access it:
const otherTask = await agent.utils.job.useAnotherTask();

if (otherTask) {
  console.log("Found waiting task:", otherTask.job_task_id);
  const proof = JSON.parse(otherTask.job_proof);

  // Use data from the other task
  const sharedData = proof.someSharedField;

  // Process with the shared data...
} else {
  console.log("No waiting task available");
}

// Task A: Set up data and wait
await agent.utils.job.submitTask(
  "running",
  { preparedData: "value", step: "waiting" },
  false,
  []
);
await agent.utils.setAutomationVariables({ waiting: true });

// Task B: Access Task A's data
const taskA = await agent.utils.job.useAnotherTask();
if (taskA) {
  const taskAData = JSON.parse(taskA.job_proof);
  console.log("Got data from Task A:", taskAData.preparedData);
}

const task = await agent.utils.job.getCurrentTask();

if (task.success) {
  console.log("Current task ID:", task.parent_task_id);
  console.log("Job proof:", task.job_proof);

  // Access job proof data
  const targetUrl = task.job_proof.url;
  const credentials = task.job_proof.credentials;
} else {
  console.log("Error getting task:", task.error);
}

const result = await agent.utils.job.addSubTasks([
  { email: "user1@example.com", action: "verify" },
  { email: "user2@example.com", action: "verify" },
]);

if (result.success) {
  console.log("Created sub-tasks:", result.inserted_ids);
  // Save planned_task_ids to check status later
  const ids = result.inserted_ids.map(t => t.planned_task_id);
}

const result = await agent.utils.job.addSubTasks(
  [{ url: "https://example.com/page1" }, { url: "https://example.com/page2" }],
  false // Don't assign immediately
);

const result = await agent.utils.job.addSubTasks(
  [{ targetId: "abc123" }],
  true,
  "674a1b2c3d4e5f6a7b8c9d0e" // Different job ID
);

const result = await agent.utils.job.addSubTasks({
  job_variables: [
    { query: "search term 1" },
    { query: "search term 2" },
  ],
  run_immediately: true,
  remote_device_id: "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
});

const result = await agent.utils.job.addSubTasks({
  job_variables: [{ action: "scrape", url: "https://example.com" }],
  run_immediately: false,
  job_id: "674a1b2c3d4e5f6a7b8c9d0e",
  remote_device_id: "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
});

// After creating sub-tasks with addSubTasks
const result = await agent.utils.job.getSubTasks([
  "674a1b2c3d4e5f6a7b8c9d01",
  "674a1b2c3d4e5f6a7b8c9d02",
]);

if (result.success) {
  for (const [plannedTaskId, task] of Object.entries(result.tasks)) {
    console.log(`Task ${plannedTaskId}: status=${task.status}`);
    if (task.status === "confirmed") {
      console.log("Result:", task.job_proof);
    }
  }
}

const subTaskResult = await agent.utils.job.addSubTasks([
  { query: "search term 1" },
  { query: "search term 2" },
]);

if (!subTaskResult.success) throw new Error(subTaskResult.error);

const ids = subTaskResult.inserted_ids.map(t => t.planned_task_id);

// Poll until all sub-tasks finish
while (true) {
  const status = await agent.utils.job.getSubTasks(ids);
  if (!status.success) break;

  const allDone = Object.values(status.tasks).every(
    t => ["confirmed", "failed", "declined", "deleted"].includes(t.status)
  );

  if (allDone) {
    console.log("All sub-tasks completed");
    break;
  }

  await sleepRandom(5000, 10000);
}

// Make this task's data available for another task to use
await agent.utils.setAutomationVariables({ waiting: true });

// Now another task in the same job can call useAnotherTask()
// to access this task's job_proof data

// Store state that can be retrieved later
const result = await agent.utils.setAutomationVariables({
  waiting: true,
  stage: "data_prepared",
  timestamp: Date.now()
});

if (result.success) {
  console.log("Variables set:", result.automation_variables);
} else {
  console.error("Failed to set variables:", result.error);
}

const result = await agent.utils.getAutomationVariables();

if (result.success) {
  console.log("Current variables:", result.automation_variables);

  if (result.automation_variables?.waiting) {
    console.log("This task is marked as waiting");
  }
} else {
  console.error("Failed to get variables:", result.error);
}

const result = await agent.utils.getAutomationVariables();

if (result.success && result.automation_variables) {
  const { stage, timestamp } = result.automation_variables;
  console.log(`Task is at stage: ${stage}, set at: ${timestamp}`);
}