import { PrismaClient } from "@prisma/client";

const prisma = new PrismaClient();

async function main() {
  console.log("Starting to fetch missing transcripts...");

  const sessionsToUpdate = await prisma.session.findMany({
    where: {
      AND: [
        { fullTranscriptUrl: { not: null } },
        { fullTranscriptUrl: { not: "" } }, // Ensure URL is not an empty string
        { transcriptContent: null },
      ],
    },
    select: {
      id: true,
      fullTranscriptUrl: true,
    },
  });

  if (sessionsToUpdate.length === 0) {
    console.log("No sessions found requiring transcript fetching.");
    return;
  }

  console.log(`Found ${sessionsToUpdate.length} sessions to update.`);
  let successCount = 0;
  let errorCount = 0;

  for (const session of sessionsToUpdate) {
    if (!session.fullTranscriptUrl) {
      // Should not happen due to query, but good for type safety
      console.warn(`Session ${session.id} has no fullTranscriptUrl, skipping.`);
      continue;
    }

    console.log(
      `Fetching transcript for session ${session.id} from ${session.fullTranscriptUrl}...`
    );
    try {
      const response = await fetch(session.fullTranscriptUrl);
      if (!response.ok) {
        console.error(
          `Failed to fetch transcript for session ${session.id}: ${response.status} ${response.statusText}`
        );
        const errorBody = await response.text();
        console.error(`Error details: ${errorBody.substring(0, 500)}`); // Log first 500 chars of error
        errorCount++;
        continue;
      }

      const transcriptText = await response.text();

      if (transcriptText.trim() === "") {
        console.warn(
          `Fetched empty transcript for session ${session.id}. Storing as empty string.`
        );
      }

      await prisma.session.update({
        where: { id: session.id },
        data: { transcriptContent: transcriptText },
      });
      console.log(
        `Successfully fetched and stored transcript for session ${session.id}.`
      );
      successCount++;
    } catch (error) {
      console.error(`Error processing session ${session.id}:`, error);
      errorCount++;
    }
  }

  console.log("Transcript fetching complete.");
  console.log(`Successfully updated: ${successCount} sessions.`);
  console.log(`Failed to update: ${errorCount} sessions.`);
}

main()
  .catch((e) => {
    console.error("An error occurred during the script execution:", e);
    process.exitCode = 1;
  })
  .finally(async () => {
    await prisma.$disconnect();
  });