import { notFound } from "next/navigation"
import { ExamAssembly } from "@/modules/exams/components/exam-assembly"
import { getExamById } from "@/modules/exams/data-access"
import { getQuestions } from "@/modules/questions/data-access"
import type { Question } from "@/modules/questions/types"
import type { ExamNode } from "@/modules/exams/components/assembly/selected-question-list"
import { createId } from "@paralleldrive/cuid2"

export default async function BuildExamPage({ params }: { params: Promise<{ id: string }> }) {
  const { id } = await params
  
  const exam = await getExamById(id)
  if (!exam) return notFound()

  // Fetch all available questions (for selection pool)
  // In a real app, this might be paginated or filtered by exam subject/grade
  const { data: questionsData } = await getQuestions({ pageSize: 100 })
  
  const initialSelected = (exam.questions || []).map(q => ({
    id: q.id,
    score: q.score || 0
  }))

  const selectedQuestionIds = initialSelected.map((s) => s.id)
  const { data: selectedQuestionsData } = selectedQuestionIds.length
    ? await getQuestions({ ids: selectedQuestionIds, pageSize: Math.max(10, selectedQuestionIds.length) })
    : { data: [] as typeof questionsData }

  type RawQuestion = (typeof questionsData)[number]

  const toQuestionOption = (q: RawQuestion): Question => ({
    id: q.id,
    content: q.content as Question["content"],
    type: q.type as Question["type"],
    difficulty: q.difficulty ?? 1,
    createdAt: new Date(q.createdAt),
    updatedAt: new Date(q.updatedAt),
    author: q.author
      ? {
          id: q.author.id,
          name: q.author.name || "Unknown",
          image: q.author.image || null,
        }
      : null,
    knowledgePoints: q.knowledgePoints ?? [],
  })

  const questionOptionsById = new Map<string, Question>()
  for (const q of questionsData) questionOptionsById.set(q.id, toQuestionOption(q))
  for (const q of selectedQuestionsData) questionOptionsById.set(q.id, toQuestionOption(q))
  const questionOptions = Array.from(questionOptionsById.values())

  const normalizeStructure = (nodes: unknown): ExamNode[] => {
    const seen = new Set<string>()
    const isRecord = (v: unknown): v is Record<string, unknown> =>
      typeof v === "object" && v !== null

    const normalize = (raw: unknown[]): ExamNode[] => {
      return raw
        .map((n) => {
          if (!isRecord(n)) return null
          const type = n.type
          if (type !== "group" && type !== "question") return null

          let id = typeof n.id === "string" && n.id.length > 0 ? n.id : createId()
          while (seen.has(id)) id = createId()
          seen.add(id)

          if (type === "group") {
            return {
              id,
              type: "group",
              title: typeof n.title === "string" ? n.title : undefined,
              children: normalize(Array.isArray(n.children) ? n.children : []),
            } satisfies ExamNode
          }

          if (typeof n.questionId !== "string" || n.questionId.length === 0) return null

          return {
            id,
            type: "question",
            questionId: n.questionId,
            score: typeof n.score === "number" ? n.score : undefined,
          } satisfies ExamNode
        })
        .filter(Boolean) as ExamNode[]
    }

    if (!Array.isArray(nodes)) return []
    return normalize(nodes)
  }

  let initialStructure: ExamNode[] = normalizeStructure(exam.structure)
  
  if (initialStructure.length === 0 && initialSelected.length > 0) {
    initialStructure = initialSelected.map((s) => ({
      id: createId(),
      type: "question",
      questionId: s.id,
      score: s.score,
    }))
  }

  return (
    <div className="flex h-full flex-col space-y-8 p-8">
      <div className="flex items-center justify-between">
        <div>
          <h2 className="text-2xl font-bold tracking-tight">Build Exam</h2>
          <p className="text-muted-foreground">Add questions and adjust scores.</p>
        </div>
      </div>
      <ExamAssembly
        examId={exam.id}
        title={exam.title}
        subject={exam.subject}
        grade={exam.grade}
        difficulty={exam.difficulty}
        totalScore={exam.totalScore}
        durationMin={exam.durationMin}
        initialSelected={initialSelected}
        initialStructure={initialStructure}
        questionOptions={questionOptions}
      />
    </div>
  )
}