import { NextResponse } from 'next/server';
import { prisma } from '@/lib/prisma';
import { getCurrentUser } from '@/lib/auth';

export async function POST(req: Request) {
    try {
        const user = await getCurrentUser();
        if (!user || !['admin', 'super_admin'].includes(user.role)) {
            return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
        }

        const body = await req.json();
        const { jobIds, action, allInQueue, filters, severity, ...extraData } = body;

        // 1. Identify Target IDs
        let targetIds = jobIds || [];

        if (allInQueue && filters) {
            // Build where clause from filters
            const where: any = { status: 'pending' };
            if (filters.search) {
                where.OR = [
                    { title: { contains: filters.search, mode: 'insensitive' } },
                    { company_name: { contains: filters.search, mode: 'insensitive' } }
                ];
            }
            if (filters.workType && filters.workType !== 'all') where.work_type = filters.workType;
            if (filters.urgentOnly) where.is_urgent = true;

            const jobsInQueue = await prisma.job.findMany({
                where,
                select: { id: true },
                take: 1000
            });
            targetIds = jobsInQueue.map(j => j.id);
        }

        if (targetIds.length === 0) {
            return NextResponse.json({ error: 'No jobs targetable for this action' }, { status: 400 });
        }

        // 2. Prepare Data Update
        let targetStatus: string;
        switch (action) {
            case 'approve': targetStatus = 'published'; break;
            case 'reject': targetStatus = 'rejected'; break;
            case 'changes': targetStatus = 'changes_requested'; break;
            default: return NextResponse.json({ error: 'Invalid action' }, { status: 400 });
        }

        // 3. Execution Transaction
        const batchId = crypto.randomUUID();
        const result = await prisma.$transaction(async (tx) => {
            // Bulk Update Jobs
            const updateData: any = {
                status: targetStatus,
                updated_at: new Date()
            };

            if (action === 'approve' && extraData.featureAll) {
                updateData.is_featured = true;
            }

            const updated = await tx.job.updateMany({
                where: { id: { in: targetIds }, status: 'pending' },
                data: updateData
            });

            // Handle Employer Sanctions for Hard Rejects/Bans
            if (action === 'reject' && (severity === 'hard' || severity === 'ban')) {
                const jobs = await tx.job.findMany({
                    where: { id: { in: targetIds } },
                    select: { employer_id: true }
                });
                const employerIds = Array.from(new Set(jobs.map(j => j.employer_id)));

                for (const empId of employerIds) {
                    if (severity === 'ban') {
                        // Suspend employer account
                        await tx.user.update({
                            where: { id: empId },
                            data: {
                                is_active: false
                            }
                        });
                    } else {
                        // We would ideally log a flag here, but User has no internal_notes field
                        // Skipping for now, we have AuditLog capturing this instead.
                    }
                }
            }

            // Create Audit Logs
            const processedJobs = await tx.job.findMany({
                where: { id: { in: targetIds } },
                select: { id: true, title: true }
            });

            for (const job of processedJobs) {
                await tx.auditLog.create({
                    data: {
                        action: `job.bulk_${action}`,
                        resource_type: 'job',
                        resource_id: job.id,
                        user_id: user.id,
                        details: {
                            bulk: true,
                            batchId,
                            severity,
                            ...extraData,
                            job_title: job.title,
                            timestamp: new Date().toISOString()
                        }
                    }
                });
            }

            return updated.count;
        });

        return NextResponse.json({
            success: true,
            count: result,
            batchId,
            message: `Successfully processed ${result} jobs via bulk ${action}`
        });

    } catch (error: any) {
        console.error('Bulk moderation API error:', error);
        return NextResponse.json({
            error: error.message || 'Internal server error',
            details: error.code // Useful for prisma errors
        }, { status: 500 });
    }
}
