import { NextRequest, NextResponse } from 'next/server';
import { getAuth } from 'firebase-admin/auth';
import { getFirebaseAdmin } from '@/lib/firebase-admin';
import { FieldValue } from 'firebase-admin/firestore';
import { ADMIN_EMAILS } from '@/lib/constants';

interface Level2Section {
    sectionTitle: string;
    content: string;
    pageRange: { start: number; end: number };
}

interface InsuranceSummary {
    id: string;
    productId: string;
    companyId: string;
    level: 1 | 2;
    content: string;
    sectionTitle?: string;
    pageRange?: { start: number; end: number };
    createdAt: string;
    updatedAt: string;
}

async function verifyAdmin(req: NextRequest): Promise<{ email: string } | NextResponse> {
    const authHeader = req.headers.get('Authorization');
    if (!authHeader?.startsWith('Bearer ')) {
        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
    }
    const idToken = authHeader.split('Bearer ')[1];

    getFirebaseAdmin();
    let userEmail: string | undefined;
    try {
        const decoded = await getAuth().verifyIdToken(idToken);
        userEmail = decoded.email;
    } catch {
        return NextResponse.json({ error: 'Unauthorized: Invalid token' }, { status: 401 });
    }

    if (!userEmail || !ADMIN_EMAILS.includes(userEmail)) {
        return NextResponse.json({ error: 'Forbidden: Admin only' }, { status: 403 });
    }

    return { email: userEmail };
}

// POST /api/admin/summary-generate
export async function POST(req: NextRequest) {
    const db = getFirebaseAdmin().firestore();
    let resolvedJobId: string | undefined;

    try {
        const authResult = await verifyAdmin(req);
        if (authResult instanceof NextResponse) return authResult;

        const body = await req.json();
        const { jobId, level1, level2 } = body as {
            jobId: string;
            level1: string;
            level2: Level2Section[];
        };

        if (!jobId || typeof jobId !== 'string') {
            return NextResponse.json({ error: 'jobId is required' }, { status: 400 });
        }
        if (!level1 || typeof level1 !== 'string') {
            return NextResponse.json({ error: 'level1 content is required' }, { status: 400 });
        }
        if (!Array.isArray(level2)) {
            return NextResponse.json({ error: 'level2 must be an array' }, { status: 400 });
        }

        resolvedJobId = jobId;

        // 1. jobId로 summary_jobs 조회하여 productId, companyId 확인
        const jobRef = db.collection('summary_jobs').doc(jobId);
        const jobSnap = await jobRef.get();

        if (!jobSnap.exists) {
            return NextResponse.json({ error: `summary_jobs document not found: ${jobId}` }, { status: 404 });
        }

        const jobData = jobSnap.data()!;
        const { productId, companyId } = jobData as { productId: string; companyId: string };

        if (!productId || !companyId) {
            return NextResponse.json(
                { error: 'summary_jobs document is missing productId or companyId' },
                { status: 422 }
            );
        }

        const now = new Date().toISOString();

        // 2. 기존 해당 productId의 insurance_summaries 문서 전부 삭제 (idempotent)
        const existingSnapshot = await db
            .collection('insurance_summaries')
            .where('productId', '==', productId)
            .get();

        if (!existingSnapshot.empty) {
            const deleteChunkSize = 500;
            const existingDocs = existingSnapshot.docs;
            for (let i = 0; i < existingDocs.length; i += deleteChunkSize) {
                const batch = db.batch();
                existingDocs.slice(i, i + deleteChunkSize).forEach((doc: any) => batch.delete(doc.ref));
                await batch.commit();
            }
        }

        // 3. Level 1 요약 저장 + 4. Level 2 요약 각각 저장 (배치)
        const writeBatch = db.batch();

        const level1Ref = db.collection('insurance_summaries').doc();
        writeBatch.set(level1Ref, {
            productId,
            companyId,
            level: 1,
            content: level1,
            createdAt: FieldValue.serverTimestamp(),
            updatedAt: FieldValue.serverTimestamp(),
        });

        const level2Refs = level2.map((section) => {
            const ref = db.collection('insurance_summaries').doc();
            writeBatch.set(ref, {
                productId,
                companyId,
                level: 2,
                sectionTitle: section.sectionTitle,
                content: section.content,
                pageRange: section.pageRange,
                createdAt: FieldValue.serverTimestamp(),
                updatedAt: FieldValue.serverTimestamp(),
            });
            return ref;
        });

        await writeBatch.commit();

        // 5. summary_jobs status를 'complete'로 업데이트
        await jobRef.update({
            status: 'complete',
            updatedAt: FieldValue.serverTimestamp(),
        });

        return NextResponse.json({
            success: true,
            level1Count: 1,
            level2Count: level2Refs.length,
        });
    } catch (error: any) {
        console.error('Admin summary-generate POST error:', error);

        // 에러 시: summary_jobs status를 'failed'로 업데이트, error 메시지 기록
        if (resolvedJobId) {
            try {
                await db.collection('summary_jobs').doc(resolvedJobId).update({
                    status: 'failed',
                    error: error.message ?? 'Unknown error',
                    updatedAt: FieldValue.serverTimestamp(),
                });
            } catch (updateErr: any) {
                console.error('Failed to update summary_jobs status to failed:', updateErr);
            }
        }

        return NextResponse.json({ error: 'Internal Server Error', message: error.message }, { status: 500 });
    }
}

// GET /api/admin/summary-generate?productId=xxx
export async function GET(req: NextRequest) {
    try {
        const authResult = await verifyAdmin(req);
        if (authResult instanceof NextResponse) return authResult;

        const { searchParams } = new URL(req.url);
        const productId = searchParams.get('productId');

        if (!productId) {
            return NextResponse.json({ error: 'productId query parameter is required' }, { status: 400 });
        }

        const db = getFirebaseAdmin().firestore();
        const snapshot = await db
            .collection('insurance_summaries')
            .where('productId', '==', productId)
            .orderBy('level', 'asc')
            .get();

        const summaries: InsuranceSummary[] = snapshot.docs.map((doc: any) => {
            const data = doc.data();
            const summary: InsuranceSummary = {
                id: doc.id,
                productId: data.productId ?? '',
                companyId: data.companyId ?? '',
                level: data.level as 1 | 2,
                content: data.content ?? '',
                createdAt: data.createdAt?.toDate?.()?.toISOString() ?? data.createdAt ?? '',
                updatedAt: data.updatedAt?.toDate?.()?.toISOString() ?? data.updatedAt ?? '',
            };
            if (data.sectionTitle !== undefined) summary.sectionTitle = data.sectionTitle;
            if (data.pageRange !== undefined) summary.pageRange = data.pageRange;
            return summary;
        });

        return NextResponse.json({ summaries });
    } catch (error: any) {
        console.error('Admin summary-generate GET error:', error);
        return NextResponse.json({ error: 'Internal Server Error', message: error.message }, { status: 500 });
    }
}