import { NextRequest, NextResponse } from 'next/server';
import { getAuth } from 'firebase-admin/auth';
import { getFirebaseAdmin } from '@/lib/firebase-admin';
import { GoogleGenerativeAI } from '@google/generative-ai';
import { ADMIN_EMAILS } from '@/lib/constants';

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/insurance/terms/[productId]/search
// 특정 상품 내 벡터 검색
export async function POST(
    req: NextRequest,
    { params }: { params: Promise<{ productId: string }> }
) {
    try {
        const authResult = await verifyAdmin(req);
        if (authResult instanceof NextResponse) return authResult;

        const { productId } = await params;
        if (!productId) {
            return NextResponse.json({ error: 'productId is required' }, { status: 400 });
        }

        const body = await req.json();
        const { query } = body as { query: string };

        if (!query || typeof query !== 'string' || query.trim().length === 0) {
            return NextResponse.json({ error: 'query is required' }, { status: 400 });
        }

        const apiKey = process.env.GEMINI_API_KEY;
        if (!apiKey) {
            return NextResponse.json({ error: 'GEMINI_API_KEY not configured' }, { status: 500 });
        }

        const genAI = new GoogleGenerativeAI(apiKey);
        const embedModel = genAI.getGenerativeModel({ model: 'text-embedding-004' });
        const embeddingResult = await embedModel.embedContent(query.trim());
        const queryEmbedding = embeddingResult.embedding.values;

        const db = getFirebaseAdmin().firestore();
        const chunksRef = db.collection('insurance_chunks');

        // 벡터 검색 (전체 → productId 필터링)
        const vectorQuery = chunksRef.findNearest({
            vectorField: 'embedding',
            queryVector: queryEmbedding,
            limit: 20,
            distanceMeasure: 'COSINE',
            distanceResultField: '_distance',
        });

        const snapshot = await vectorQuery.get();

        // productId 필터링 + 유사도 계산
        const results = snapshot.docs
            .map((doc: any) => {
                const data = doc.data();
                const score = 1 - (data._distance ?? 1);
                return {
                    chunk: {
                        id: doc.id,
                        productId: data.productId,
                        companyId: data.companyId,
                        companyName: data.companyName,
                        productName: data.productName,
                        pageNumber: data.pageNumber,
                        chunkText: data.chunkText,
                        coverageNames: data.coverageNames ?? [],
                        sourceType: data.sourceType,
                        effectiveDate: data.effectiveDate,
                    },
                    score,
                };
            })
            .filter((r: any) => r.chunk.productId === productId && r.score >= 0.5)
            .slice(0, 10);

        return NextResponse.json({ results });
    } catch (error: any) {
        console.error('POST search error:', error);
        return NextResponse.json({ error: 'Internal Server Error', message: error.message }, { status: 500 });
    }
}