import Link from 'next/link'
import { notFound } from 'next/navigation'
import { db } from '@/lib/db'
import { Card, Caveat, Label } from '@/components/ui'
import { ReviewControls, ItemEditor } from './editor'

export default async function ReviewSet({
  params,
}: {
  params: Promise<{ setId: string }>
}) {
  const { setId } = await params

  const set = await db.itemSet.findUnique({
    where: { id: setId },
    include: {
      student: true,
      generationRun: true,
      items: {
        orderBy: { position: 'asc' },
        include: { item: { include: { construct: true } } },
      },
    },
  })
  if (!set) notFound()

  // Items written to re-test something he asked about. Shown so the intent is
  // visible: a follow-up item is deliberately unsignposted to the boy, which
  // means it is invisible to you too unless the review screen says so.
  const addressed = await db.studentQuestion.findMany({
    where: { addressedBySetId: set.id },
    select: { id: true, question: true, addressedByItemId: true, askedAt: true },
  })
  const followUpFor = new Map(addressed.map((q) => [q.addressedByItemId, q]))

  const plan = (set.generationRun?.targetPlan as { plan?: string } | null)?.plan
  const dropped = set.items.filter((si) => si.droppedByReviewer).length
  const flagged = set.items.filter((si) => si.reviewVerdict === 'FLAG').length
  const live = set.items.length - dropped

  return (
    <div className="space-y-6">
      <div>
        <Link href="/parent" className="text-xs text-[var(--color-muted)] hover:underline">
          &larr; Back
        </Link>
        <h1 className="mt-2 text-xl font-semibold">{set.title}</h1>
        <p className="text-sm text-[var(--color-muted)]">
          {set.student.name} &middot; round {set.round} &middot; {set.items.length} items
          &middot; {set.status.toLowerCase().replace('_', ' ')}
        </p>
      </div>

      <Caveat>
        Nothing here has been seen by {set.student.name}. Read every item before
        releasing: a bad item does not just waste a sitting, it writes a false
        measurement into his state and the next set is then aimed at a gap that
        was never there.
      </Caveat>

      {set.reviewedAt ? (
        <Card className="space-y-2">
          <Label>
            Second agent&rsquo;s review &middot; {live} of {set.items.length} items stand
            {dropped > 0 && ` · ${dropped} dropped`}
            {flagged > 0 && ` · ${flagged} with notes`}
          </Label>
          {set.reviewSummary && (
            <p className="text-sm leading-relaxed whitespace-pre-wrap">{set.reviewSummary}</p>
          )}
          <p className="text-xs text-[var(--color-muted)]">
            A dropped item is withheld from {set.student.name}, not deleted &mdash; its
            reason is shown below and you can put it back. The reviewer is a safety
            net on the writer, not a substitute for your read.
          </p>
        </Card>
      ) : (
        <Card>
          <p className="text-sm text-[var(--color-muted)]">
            This draft has not been through the reviewer &mdash; either it predates the
            review pass or the reviewer failed. Read it with that in mind.
          </p>
        </Card>
      )}

      {plan && (
        <Card>
          <Label>Why this set</Label>
          <p className="mt-2 text-sm leading-relaxed whitespace-pre-wrap">{plan}</p>
        </Card>
      )}

      <div className="space-y-4">
        {set.items.map((si, index) => (
          <ItemEditor
            key={si.id}
            setItemId={si.id}
            index={index + 1}
            followUp={
              followUpFor.has(si.item.id)
                ? {
                    question: followUpFor.get(si.item.id)!.question,
                    askedAt: followUpFor.get(si.item.id)!.askedAt.toLocaleDateString(),
                  }
                : null
            }
            reviewVerdict={si.reviewVerdict}
            reviewNote={si.reviewNote}
            droppedByReviewer={si.droppedByReviewer}
            item={{
              id: si.item.id,
              constructLabel: si.item.construct.label,
              format: si.item.format,
              responseMode: si.item.responseMode,
              stimulus: si.item.stimulus,
              prompt: si.item.prompt,
              choices: si.item.choices as { key: string; text: string }[] | null,
              answerKey: si.item.answerKey,
              rubricCriteria: si.item.rubricCriteria,
              rationale: si.item.rationale,
              pairKind: si.item.pairKind,
              editedByParent: si.item.editedByParent,
            }}
          />
        ))}
      </div>

      {set.status === 'PENDING_REVIEW' && (
        <ReviewControls setId={set.id} itemCount={live} name={set.student.name} />
      )}
    </div>
  )
}