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';

type SummaryJobStatus = 'pending' | 'processing' | 'complete' | 'failed';

interface SummaryJob {
    id: string;
    productId: string;
    companyId: string;
    companyName: string;
    productName: string;
    driveFileId: string;
    chunksCount: number;
    status: SummaryJobStatus;
    error?: string;
    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 };
}

// GET /api/admin/summary-jobs?status=pending
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 statusParam = searchParams.get('status') ?? 'all';

        const validStatuses: Array<SummaryJobStatus | 'all'> = ['pending', 'processing', 'complete', 'failed', 'all'];
        if (!validStatuses.includes(statusParam as SummaryJobStatus | 'all')) {
            return NextResponse.json(
                { error: `Invalid status. Must be one of: ${validStatuses.join(', ')}` },
                { status: 400 }
            );
        }

        const db = getFirebaseAdmin().firestore();
        let query: FirebaseFirestore.Query = db.collection('summary_jobs').orderBy('createdAt', 'desc');

        if (statusParam !== 'all') {
            query = query.where('status', '==', statusParam);
        }

        const snapshot = await query.get();

        const jobs: SummaryJob[] = snapshot.docs.map((doc) => {
            const data = doc.data();
            return {
                id: doc.id,
                productId: data.productId ?? '',
                companyId: data.companyId ?? '',
                companyName: data.companyName ?? '',
                productName: data.productName ?? '',
                driveFileId: data.driveFileId ?? '',
                chunksCount: data.chunksCount ?? 0,
                status: data.status as SummaryJobStatus,
                ...(data.error !== undefined ? { error: data.error } : {}),
                createdAt: data.createdAt?.toDate?.()?.toISOString() ?? data.createdAt ?? '',
                updatedAt: data.updatedAt?.toDate?.()?.toISOString() ?? data.updatedAt ?? '',
            };
        });

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

// PATCH /api/admin/summary-jobs
export async function PATCH(req: NextRequest) {
    try {
        const authResult = await verifyAdmin(req);
        if (authResult instanceof NextResponse) return authResult;

        const body = await req.json();
        const { jobId, status, error: errorMessage } = body as {
            jobId: string;
            status: SummaryJobStatus;
            error?: string;
        };

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

        const validStatuses: SummaryJobStatus[] = ['pending', 'processing', 'complete', 'failed'];
        if (!status || !validStatuses.includes(status)) {
            return NextResponse.json(
                { error: `Invalid status. Must be one of: ${validStatuses.join(', ')}` },
                { status: 400 }
            );
        }

        const db = getFirebaseAdmin().firestore();
        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 updateData: Record<string, any> = {
            status,
            updatedAt: FieldValue.serverTimestamp(),
        };

        if (errorMessage !== undefined) {
            updateData.error = errorMessage;
        }

        await jobRef.update(updateData);

        return NextResponse.json({ success: true, jobId, status });
    } catch (error: any) {
        console.error('Admin summary-jobs PATCH error:', error);
        return NextResponse.json({ error: 'Internal Server Error', message: error.message }, { status: 500 });
    }
}