"use server";

import { db } from "@/lib/db";
import prisma from "@/lib/prisma";
import { getCurrentUser } from "@/lib/auth";

export async function recordJobView(jobId: string, userAgent?: string, ipAddress?: string, source?: string) {
    try {
        const user = await getCurrentUser();
        const userId = user?.id || null;

        // Optionally, check if this user/IP has viewed this job recently to deduplicate
        // But for simplicity, we insert a new view record and increment the counter
        const [view, updatedJob] = await prisma.$transaction([
            prisma.jobView.create({
                data: {
                    job_id: jobId,
                    user_id: userId,
                    user_agent: userAgent,
                    ip_address: ipAddress,
                    source: source || 'direct'
                }
            }),
            prisma.job.update({
                where: { id: jobId },
                data: { view_count: { increment: 1 } }
            })
        ]);

        return { success: true, viewId: view.id };
    } catch (error) {
        console.error("Failed to record job view:", error);
        return { success: false, error: "Failed to record job view" };
    }
}

export async function getSingleJobAnalytics(jobId: string) {
    try {
        const user = await getCurrentUser();
        if (!user || user.role !== "employer") return null;

        const job = await prisma.job.findUnique({
            where: { id: jobId, employer_id: user.id },
            select: {
                view_count: true,
                applicant_count: true,
                job_views: {
                    where: {
                        created_at: {
                            gte: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000) // Last 30 days
                        }
                    },
                    select: { created_at: true }
                }
            }
        });

        if (!job) return null;

        // Group views by day
        const viewsByDay: Record<string, number> = {};
        for (let i = 29; i >= 0; i--) {
            const d = new Date();
            d.setDate(d.getDate() - i);
            viewsByDay[d.toISOString().split('T')[0]] = 0;
        }

        job.job_views.forEach(view => {
            const dateStr = view.created_at.toISOString().split('T')[0];
            if (viewsByDay[dateStr] !== undefined) {
                viewsByDay[dateStr]++;
            }
        });

        const timeline = Object.keys(viewsByDay).map(date => ({
            date,
            views: viewsByDay[date]
        }));

        const conversionRate = job.view_count > 0
            ? ((job.applicant_count / job.view_count) * 100).toFixed(1)
            : 0;

        return {
            totalViews: job.view_count,
            totalApplications: job.applicant_count,
            conversionRate: Number(conversionRate),
            timeline
        };
    } catch (error) {
        console.error("Failed to get job analytics:", error);
        return null;
    }
}

export async function getEmployerJobAnalytics() {
    try {
        const user = await getCurrentUser();
        if (!user || user.role !== "employer") return null;

        const jobs = await prisma.job.findMany({
            where: { employer_id: user.id },
            select: {
                id: true,
                title: true,
                view_count: true,
                applicant_count: true,
            }
        });

        const totalViews = jobs.reduce((sum, j) => sum + j.view_count, 0);
        const totalApplications = jobs.reduce((sum, j) => sum + j.applicant_count, 0);
        const conversionRate = totalViews > 0
            ? ((totalApplications / totalViews) * 100).toFixed(1)
            : 0;

        return {
            totalViews,
            totalApplications,
            conversionRate: Number(conversionRate),
            topJobs: jobs.sort((a, b) => b.view_count - a.view_count).slice(0, 5)
        };
    } catch (error) {
        console.error("Failed to get employer job analytics:", error);
        return null;
    }
}

