import {
  PrismaClient,
  ProcessingStage,
  ProcessingStatus,
} from "@prisma/client";
import { ProcessingStatusManager } from "./lib/processingStatusManager";

const prisma = new PrismaClient();

async function fixProcessingStatus() {
  try {
    console.log("=== FIXING PROCESSING STATUS (REFACTORED SYSTEM) ===\n");

    // Check for any failed processing stages that might need retry
    const failedSessions = await ProcessingStatusManager.getFailedSessions();

    console.log(`Found ${failedSessions.length} failed processing stages`);

    if (failedSessions.length > 0) {
      console.log("\nFailed sessions by stage:");
      const failuresByStage: Record<string, number> = {};

      failedSessions.forEach((failure) => {
        failuresByStage[failure.stage] =
          (failuresByStage[failure.stage] || 0) + 1;
      });

      Object.entries(failuresByStage).forEach(([stage, count]) => {
        console.log(`  ${stage}: ${count} failures`);
      });

      // Show sample failed sessions
      console.log("\nSample failed sessions:");
      failedSessions.slice(0, 5).forEach((failure) => {
        console.log(
          `  ${failure.session.import?.externalSessionId || failure.sessionId}: ${failure.stage} - ${failure.errorMessage}`
        );
      });

      // Ask if user wants to reset failed stages for retry
      console.log("\nTo reset failed stages for retry, you can use:");
      console.log(
        "ProcessingStatusManager.resetStageForRetry(sessionId, stage)"
      );
    }

    // Check for sessions that might be stuck in IN_PROGRESS
    const stuckSessions = await prisma.sessionProcessingStatus.findMany({
      where: {
        status: ProcessingStatus.IN_PROGRESS,
        startedAt: {
          lt: new Date(Date.now() - 30 * 60 * 1000), // Started more than 30 minutes ago
        },
      },
      include: {
        session: {
          include: {
            import: true,
          },
        },
      },
    });

    if (stuckSessions.length > 0) {
      console.log(
        `\nFound ${stuckSessions.length} sessions stuck in IN_PROGRESS state:`
      );
      stuckSessions.forEach((stuck) => {
        console.log(
          `  ${stuck.session.import?.externalSessionId || stuck.sessionId}: ${stuck.stage} (started: ${stuck.startedAt})`
        );
      });

      console.log(
        "\nThese sessions may need to be reset to PENDING status for retry."
      );
    }

    // Show current pipeline status
    console.log("\n=== CURRENT PIPELINE STATUS ===");
    const pipelineStatus = await ProcessingStatusManager.getPipelineStatus();

    const stages = [
      "CSV_IMPORT",
      "TRANSCRIPT_FETCH",
      "SESSION_CREATION",
      "AI_ANALYSIS",
      "QUESTION_EXTRACTION",
    ];

    for (const stage of stages) {
      const stageData = pipelineStatus.pipeline[stage] || {};
      const pending = stageData.PENDING || 0;
      const inProgress = stageData.IN_PROGRESS || 0;
      const completed = stageData.COMPLETED || 0;
      const failed = stageData.FAILED || 0;
      const skipped = stageData.SKIPPED || 0;

      console.log(
        `${stage}: ${completed} completed, ${pending} pending, ${inProgress} in progress, ${failed} failed, ${skipped} skipped`
      );
    }
  } catch (error) {
    console.error("Error fixing processing status:", error);
  } finally {
    await prisma.$disconnect();
  }
}

fixProcessingStatus();