import { NextResponse } from 'next/server';
import prisma from '@/lib/prisma';
import { EmailService } from '@/services/EmailService';
import { addHours } from 'date-fns';

/**
 * Consolidated Cron Job for Proten Job Board
 * Handles:
 * 1. Interview Reminders (Hourly)
 * 2. Job Alerts (Daily/Weekly)
 * 
 * Vercel Hobby tier is limited to 1 cron job, so we run everything here.
 */
export async function GET(request: Request) {
    // 1. Verify Authorization
    const authHeader = request.headers.get('authorization');
    const cronSecret = process.env.CRON_SECRET;

    if (cronSecret && authHeader !== `Bearer ${cronSecret}`) {
        return new NextResponse("Unauthorized", { status: 401 });
    }

    const results: any = {
        timestamp: new Date().toISOString(),
        reminders: null,
        jobAlerts: null
    };

    try {
        const now = new Date();

        // --- SECTION 1: INTERVIEW REMINDERS ---
        try {
            const next24Hours = addHours(now, 24);
            const upcomingInterviews = await prisma.interview.findMany({
                where: {
                    status: "scheduled",
                    scheduled_start_datetime: { gt: now, lte: next24Hours },
                    audit_logs: { none: { action: 'reminder_24h_sent' } }
                },
                include: {
                    application: {
                        include: {
                            candidate: { select: { name: true, email: true, first_name: true } },
                            job: { select: { title: true, employer_id: true, employer: { select: { name: true } } } },
                        },
                    },
                },
            });

            let sentReminders = 0;
            for (const interview of upcomingInterviews) {
                const candidateEmail = interview.application.candidate.email;
                if (!candidateEmail) continue;

                const dateStr = new Date(interview.scheduled_start_datetime).toLocaleString('en-US', {
                    dateStyle: 'full', timeStyle: 'short', timeZone: interview.timezone || 'Africa/Lagos'
                });

                const emailResult = await EmailService.sendNotificationEmail(
                    candidateEmail,
                    `Reminder: Upcoming Interview for ${interview.application.job.title}`,
                    `<p>Hi ${interview.application.candidate.name || interview.application.candidate.first_name || "Candidate"},</p><p>Reminder for your <strong>${interview.type.replace('_', ' ')}</strong> interview.</p><p><strong>Time:</strong> ${dateStr}</p>`
                );

                if (emailResult.success) {
                    await prisma.interviewAuditLog.create({
                        data: {
                            interview_id: interview.id,
                            user_id: interview.application.job.employer_id, // Or interview.created_by_user_id
                            action: 'reminder_24h_sent',
                        }
                    });
                    sentReminders++;
                }
            }
            results.reminders = { processed: upcomingInterviews.length, sent: sentReminders };
        } catch (e: any) {
            results.reminders = { error: e.message };
        }

        // --- SECTION 2: JOB ALERTS ---
        try {
            const oneDayAgo = new Date(now.getTime() - 24 * 60 * 60 * 1000);
            const oneWeekAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);

            const searchesToProcess = await prisma.savedSearch.findMany({
                where: {
                    OR: [
                        { alert_frequency: 'daily', last_checked_at: { lt: oneDayAgo } },
                        { alert_frequency: 'weekly', last_checked_at: { lt: oneWeekAgo } }
                    ]
                },
                include: { user: { select: { email: true, name: true, is_active: true } } }
            });

            let alertsSent = 0;
            for (const search of searchesToProcess) {
                if (!search.user.is_active) continue;
                const filters = search.filters as Record<string, any>;
                const matchingJobs = await prisma.job.findMany({
                    where: { status: 'published', posted_at: { gt: search.last_checked_at } },
                    select: { id: true, title: true, company: true },
                    take: 10
                });

                if (matchingJobs.length > 0) {
                    const baseUrl = process.env.NEXT_PUBLIC_APP_URL || 'http://localhost:3000';
                    await EmailService.sendJobAlert(search.user.email, search.name, matchingJobs.map(j => ({
                        title: j.title, company: j.company, url: `${baseUrl}/jobs/${j.id}`
                    })));
                    alertsSent++;
                }
                await prisma.savedSearch.update({
                    where: { id: search.id },
                    data: { last_checked_at: now, new_job_count: matchingJobs.length }
                });
            }
            results.jobAlerts = { processed: searchesToProcess.length, sent: alertsSent };
        } catch (e: any) {
            results.jobAlerts = { error: e.message };
        }

        return NextResponse.json({ success: true, results });

    } catch (error: any) {
        console.error("Master Cron Error:", error);
        return NextResponse.json({ success: false, error: error.message }, { status: 500 });
    }
}
