import { task, wait, logger } from "@trigger.dev/sdk/v3";

// Agent task - simulates CFN Loop agent execution
export const agentTask = task({
  id: "cfn-agent",
  run: async (payload: { agentType: string; taskId: string; iteration: number }) => {
    await logger.info(`Agent ${payload.agentType} starting`, { payload });

    // Simulate agent work
    await wait.for({ seconds: 2 });

    const confidence = 0.85 + Math.random() * 0.1; // 0.85-0.95

    await logger.info(`Agent ${payload.agentType} completed`, { confidence });

    return {
      agentType: payload.agentType,
      taskId: payload.taskId,
      iteration: payload.iteration,
      confidence,
      output: `Agent ${payload.agentType} result for iteration ${payload.iteration}`,
    };
  },
});

// Gate check task - evaluates pass rate
export const gateCheckTask = task({
  id: "cfn-gate-check",
  run: async (payload: { results: Array<{ confidence: number }>; threshold: number }) => {
    const avgConfidence = payload.results.reduce((sum, r) => sum + r.confidence, 0) / payload.results.length;
    const passed = avgConfidence >= payload.threshold;

    await logger.info(`Gate check: ${passed ? "PASSED" : "FAILED"}`, { avgConfidence, threshold: payload.threshold });

    return { passed, avgConfidence };
  },
});

// Main CFN Loop workflow
export const cfnLoopWorkflow = task({
  id: "cfn-loop-workflow",
  run: async (payload: {
    taskDescription: string;
    maxIterations: number;
    threshold: number;
    agentTypes: string[];
  }) => {
    await logger.info("Starting CFN Loop workflow", { payload });

    let iteration = 1;
    let decision = "ITERATE";

    while (iteration <= payload.maxIterations && decision === "ITERATE") {
      await logger.info(`=== Iteration ${iteration} ===`);

      // Batch trigger agents in parallel
      const agentRuns = await agentTask.batchTrigger(
        payload.agentTypes.map(agentType => ({
          payload: {
            agentType,
            taskId: `task-${Date.now()}`,
            iteration,
          },
        }))
      );

      // Wait for all agents to complete and collect results
      const results = await Promise.all(
        agentRuns.map((run: any) => run.result())
      );

      await logger.info(`Collected ${results.length} agent results`);

      // Gate check
      const gateResult = await gateCheckTask.triggerAndWait({
        results: results.map((r: any) => ({ confidence: r.confidence })),
        threshold: payload.threshold,
      });

      if (gateResult.ok && gateResult.output.passed) {
        decision = "PROCEED";
        await logger.info("Gate passed - proceeding to completion");
      } else {
        iteration++;
        await logger.info(`Gate failed - iteration ${iteration}`);
      }
    }

    const finalStatus = decision === "PROCEED" ? "COMPLETED" : "MAX_ITERATIONS_REACHED";

    await logger.info(`CFN Loop workflow finished: ${finalStatus}`);

    return {
      status: finalStatus,
      iterations: iteration,
      decision,
    };
  },
});