import { NextRequest, NextResponse } from 'next/server';
import { verifyReviewer } from '@/lib/auth-middleware';
import { getFirebaseAdmin } from '@/lib/firebase-admin';
import { getFirestore, FieldValue } from 'firebase-admin/firestore';

const DASHBOARD_API_URL = process.env.DASHBOARD_API_URL || 'http://localhost:8000';

export async function POST(
  req: NextRequest,
  { params }: { params: Promise<{ id: string }> }
) {
  const authResult = await verifyReviewer(req);
  if (authResult instanceof NextResponse) return authResult;

  const { id: docId } = await params;

  let body: { decision: string; comment?: string };
  try {
    body = await req.json();
  } catch {
    return NextResponse.json({ error: 'Invalid JSON body' }, { status: 400 });
  }

  const { decision, comment } = body;

  if (!decision || !['approve', 'reject'].includes(decision)) {
    return NextResponse.json(
      { error: 'Invalid decision. Must be approve or reject' },
      { status: 400 }
    );
  }

  if (decision === 'reject' && (!comment || comment.trim() === '')) {
    return NextResponse.json(
      { error: 'Comment is required for reject decisions' },
      { status: 400 }
    );
  }

  getFirebaseAdmin();
  const db = getFirestore();

  const docRef = db.collection('documents').doc(docId);
  const docSnap = await docRef.get();
  if (!docSnap.exists) {
    return NextResponse.json({ error: 'Document not found' }, { status: 404 });
  }

  const docData = docSnap.data()!;

  if (docData.sourceType !== 'dashboard_insight' || docData.status !== 'pending') {
    return NextResponse.json(
      { error: 'This document is not a pending dashboard insight' },
      { status: 400 }
    );
  }

  const entryId = docData.insightEntryId || docId.split('__').pop() || '';
  if (!entryId) {
    return NextResponse.json(
      { error: 'Unable to determine entry ID from document' },
      { status: 400 }
    );
  }
  const reviewerDoc = await db.collection('users').doc(authResult.uid).get();
  const reviewerName = reviewerDoc.data()?.name ?? reviewerDoc.data()?.displayName ?? 'Unknown';

  if (decision === 'approve') {
    await docRef.update({
      status: 'approved',
      visibility: 'public',
      verificationStatus: 'expert_verified',
      authorId: 'system_kakao_qa',
      sourceType: docData.originalSourceType || 'kakao_community',
      updatedAt: FieldValue.serverTimestamp(),
    });

    const wikiData: Record<string, unknown> = {
      title: docData.title || '',
      category: docData.category || '',
      subcategory: docData.subcategory || '',
      question: docData.question || '',
      answer: docData.answer || '',
      expert: docData.sourceMeta?.expertName || '',
      keywords: docData.searchKeywords || [],
      source: docData.sourceRef?.channelId || '',
      sourceDate: docData.sourceMeta?.collectedAt || '',
      createdAt: FieldValue.serverTimestamp(),
      updatedAt: FieldValue.serverTimestamp(),
    };
    await db.collection('wiki').doc(entryId).set(wikiData, { merge: true });

    await docRef.collection('reviews').add({
      docId,
      reviewerId: authResult.uid,
      reviewerName,
      decision: 'approve',
      comment: comment ?? '',
      riskLevel: 'low',
      createdAt: FieldValue.serverTimestamp(),
    });
  } else {
    await docRef.update({
      status: 'rejected',
      updatedAt: FieldValue.serverTimestamp(),
    });

    await docRef.collection('reviews').add({
      docId,
      reviewerId: authResult.uid,
      reviewerName,
      decision: 'reject',
      comment: comment ?? '',
      riskLevel: 'low',
      createdAt: FieldValue.serverTimestamp(),
    });
  }

  try {
    const dashboardStatus = decision === 'approve' ? 'approved' : 'rejected';
    await fetch(`${DASHBOARD_API_URL}/api/wiki/entries/${encodeURIComponent(entryId)}/approve`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ status: dashboardStatus }),
    });
  } catch (dashErr) {
    console.error('Dashboard status sync failed:', dashErr);
  }

  return NextResponse.json({
    success: true,
    decision,
    docId,
    entryId,
  });
}