import { NextRequest, NextResponse } from "next/server"
import { prisma } from "@/lib/db"
import { getStagesForProfile } from "@/lib/curriculum/engine"

export async function POST(request: NextRequest) {
  if (process.env.NODE_ENV === "production") {
    return NextResponse.json({ error: "Not available in production" }, { status: 403 })
  }
  try {
    const { childId, profile = "ISABELLA", topic = "lectura", stages: stageIds, markAllCorrect = false } = await request.json()
    if (!childId) {
      return NextResponse.json({ error: "childId required" }, { status: 400 })
    }

    const child = await prisma.child.findUnique({
      where: { id: childId },
      select: { id: true, name: true, profile: true },
    })

    if (!child) {
      return NextResponse.json({ error: "Child not found" }, { status: 404 })
    }

    const resolvedProfile = (profile || child.profile).toUpperCase()

    // Get stages for this topic
    const stages = await getStagesForProfile(resolvedProfile, topic)

    // Filter to specific stages if requested
    const stageEntries = stageIds
      ? Object.entries(stages).filter(([id]) => stageIds.includes(Number(id)))
      : Object.entries(stages)

    let seeded = 0

    for (const [stageId, stage] of stageEntries) {
      // Ensure curriculum progress exists
      const exists = await prisma.curriculumProgress.findUnique({
        where: { childId_topic_stage: { childId, topic, stage: Number(stageId) } },
      })

      if (!exists) {
        await prisma.curriculumProgress.create({
          data: { childId, topic, stage: Number(stageId) },
        })
      }

      // Create a session log
      const sessionLog = await prisma.sessionLog.create({
        data: { childId, startedAt: new Date() },
      })

      // Create skill attempts for each exercise in the stage
      for (const ex of stage.exercises) {
        await prisma.skillAttempt.create({
          data: {
            sessionLogId: sessionLog.id,
            skillCode: ex.skillCode,
            promptLevel: 0,
            correct: markAllCorrect,
            responseMs: 2000,
            errorType: markAllCorrect ? null : (ex.errorType || "discriminacion-auditiva"),
            exerciseId: ex.id,
            stage: ex.stage,
          },
        })

        // Create FSRS card
        await prisma.fsrsCard.create({
          data: {
            childId,
            skillCode: ex.skillCode,
            dueAt: new Date(Date.now() + 86400000),
            stability: markAllCorrect ? 3.0 : 0.5,
            difficulty: markAllCorrect ? 4.0 : 7.0,
            reps: 1,
            lapses: markAllCorrect ? 0 : 1,
          },
        })

        seeded++
      }

      // Mark stage as completed if markAllCorrect
      if (markAllCorrect) {
        await prisma.curriculumProgress.updateMany({
          where: { childId, topic, stage: Number(stageId) },
          data: { completedAt: new Date() },
        })

        // Advance to next stage
        const nextStage = Number(stageId) + 1
        const nextExists = await prisma.curriculumProgress.findUnique({
          where: { childId_topic_stage: { childId, topic, stage: nextStage } },
        })
        if (!nextExists) {
          await prisma.curriculumProgress.create({
            data: { childId, topic, stage: nextStage },
          })
        }
      }
    }

    return NextResponse.json({
      success: true,
      child: { id: child.id, name: child.name, profile: resolvedProfile },
      topic,
      stagesSeeded: stageEntries.length,
      exercisesSeeded: seeded,
    })
  } catch (error) {
    console.error("Debug seed error:", error)
    return NextResponse.json({ error: "Internal error" }, { status: 500 })
  }
}