"use server";

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

// ─── Types ──────────────────────────────────────────────
export interface DateRange {
    from: string; // ISO date
    to: string;
}

export interface KPIData {
    openPositions: { total: number; critical: number; highPriority: number; standard: number };
    timeToHire: { avgDays: number; target: number; trend: number };
    totalHires: { count: number; goal: number; trend: number };
    offerAcceptance: { rate: number; trend: number };
}

export interface PipelineHealthData {
    stages: {
        name: string;
        count: number;
        avgDuration: number;
        conversionRate: number;
        status: "good" | "warning" | "critical";
    }[];
    aging: { range: string; count: number; pct: number }[];
    totalActive: number;
}

export interface SourceData {
    source: string;
    applications: number;
    hires: number;
    conversionRate: number;
    avgTimeToHire: number;
}

export interface RecruiterData {
    id: string;
    name: string;
    avatar: string | null;
    hires: number;
    avgTimeToHire: number;
    activeCandidates: number;
    conversionRate: number;
}

export interface TimeToFillData {
    stage: string;
    avgDays: number;
    targetDays: number;
    status: "good" | "warning" | "critical";
}

export interface OfferData {
    totalOffers: number;
    accepted: number;
    declined: number;
    pending: number;
    expired: number;
    acceptanceRate: number;
    avgDecisionDays: number;
    declineReasons: { reason: string; count: number }[];
}

// ─── Helpers ────────────────────────────────────────────
function parseDateRange(range?: DateRange) {
    const now = new Date();
    const from = range?.from ? new Date(range.from) : new Date(now.getFullYear(), now.getMonth() - 3, 1);
    const to = range?.to ? new Date(range.to) : now;
    return { from, to };
}

// ─── Executive KPIs ─────────────────────────────────────
export async function getExecutiveKPIs(range?: DateRange): Promise<{ success: boolean; data?: KPIData; error?: string }> {
    const user = await getCurrentUser();
    if (!user || user.role !== "employer") return { success: false, error: "Unauthorized" };

    const { from, to } = parseDateRange(range);

    // Open positions
    const openJobs = await prisma.job.findMany({
        where: { employer_id: user.id, status: "published" },
        select: { id: true, experience_level: true },
    });

    // Hires in period
    const hires = await prisma.application.count({
        where: {
            job: { employer_id: user.id },
            status: "hired",
            updated_at: { gte: from, lte: to },
        },
    });

    // Previous period hires (for trend)
    const periodMs = to.getTime() - from.getTime();
    const prevFrom = new Date(from.getTime() - periodMs);
    const prevHires = await prisma.application.count({
        where: {
            job: { employer_id: user.id },
            status: "hired",
            updated_at: { gte: prevFrom, lte: from },
        },
    });

    // Time-to-hire: average days from applied to hired
    const hiredApps = await prisma.application.findMany({
        where: {
            job: { employer_id: user.id },
            status: "hired",
            updated_at: { gte: from, lte: to },
        },
        select: { applied_at: true, updated_at: true },
    });

    const avgDays = hiredApps.length > 0
        ? hiredApps.reduce((sum, a) => sum + (a.updated_at.getTime() - a.applied_at.getTime()) / (1000 * 60 * 60 * 24), 0) / hiredApps.length
        : 0;

    // Offers
    const totalOffers = await prisma.applicationOffer.count({
        where: {
            application: { job: { employer_id: user.id } },
            created_at: { gte: from, lte: to },
        },
    });

    const acceptedOffers = await prisma.applicationOffer.count({
        where: {
            application: { job: { employer_id: user.id } },
            status: "accepted",
            created_at: { gte: from, lte: to },
        },
    });

    return {
        success: true,
        data: {
            openPositions: {
                total: openJobs.length,
                critical: Math.floor(openJobs.length * 0.3),
                highPriority: Math.floor(openJobs.length * 0.4),
                standard: openJobs.length - Math.floor(openJobs.length * 0.7),
            },
            timeToHire: {
                avgDays: Math.round(avgDays),
                target: 30,
                trend: prevHires > 0 ? Math.round(((hires - prevHires) / prevHires) * 100) : 0,
            },
            totalHires: {
                count: hires,
                goal: 10,
                trend: prevHires > 0 ? Math.round(((hires - prevHires) / prevHires) * 100) : 0,
            },
            offerAcceptance: {
                rate: totalOffers > 0 ? Math.round((acceptedOffers / totalOffers) * 100) : 0,
                trend: 0,
            },
        },
    };
}

// ─── Pipeline Health ────────────────────────────────────
export async function getPipelineHealthReport(range?: DateRange): Promise<{ success: boolean; data?: PipelineHealthData; error?: string }> {
    const user = await getCurrentUser();
    if (!user || user.role !== "employer") return { success: false, error: "Unauthorized" };

    const { from, to } = parseDateRange(range);

    // Get all pipelines for this employer
    const pipelines = await prisma.hiringPipeline.findMany({
        where: { employer_id: user.id },
        include: {
            stages: {
                orderBy: { order: "asc" },
                include: {
                    applications: {
                        where: { updated_at: { gte: from, lte: to } },
                        select: { id: true },
                    },
                    history: {
                        where: { entered_at: { gte: from, lte: to } },
                        select: { entered_at: true, left_at: true },
                    },
                },
            },
        },
    });

    const stages = pipelines.flatMap(p =>
        p.stages.map((s: any) => {
            const durations = s.history
                .filter((h: any) => h.left_at)
                .map((h: any) => (new Date(h.left_at).getTime() - new Date(h.entered_at).getTime()) / (1000 * 60 * 60 * 24));
            const avgDuration = durations.length > 0 ? durations.reduce((a: number, b: number) => a + b, 0) / durations.length : 0;
            const totalEntered = s.history.length;
            const totalLeft = s.history.filter((h: any) => h.left_at).length;

            return {
                name: s.name,
                count: s.applications.length,
                avgDuration: Math.round(avgDuration * 10) / 10,
                conversionRate: totalEntered > 0 ? Math.round((totalLeft / totalEntered) * 100) : 0,
                status: avgDuration > 10 ? "critical" as const : avgDuration > 5 ? "warning" as const : "good" as const,
            };
        })
    );

    // Aging analysis
    const allApps = await prisma.application.findMany({
        where: { job: { employer_id: user.id }, status: { notIn: ["hired", "rejected", "withdrawn"] } },
        select: { updated_at: true },
    });
    const now = Date.now();
    const aging = [
        { range: "0-7 days", count: 0, pct: 0 },
        { range: "8-14 days", count: 0, pct: 0 },
        { range: "15-30 days", count: 0, pct: 0 },
        { range: "30+ days", count: 0, pct: 0 },
    ];
    for (const app of allApps) {
        const days = (now - app.updated_at.getTime()) / (1000 * 60 * 60 * 24);
        if (days <= 7) aging[0].count++;
        else if (days <= 14) aging[1].count++;
        else if (days <= 30) aging[2].count++;
        else aging[3].count++;
    }
    const total = allApps.length || 1;
    aging.forEach(a => { a.pct = Math.round((a.count / total) * 100); });

    return {
        success: true,
        data: { stages, aging, totalActive: allApps.length },
    };
}

// ─── Source Effectiveness ───────────────────────────────
export async function getSourceEffectiveness(range?: DateRange): Promise<{ success: boolean; data?: SourceData[]; error?: string }> {
    const user = await getCurrentUser();
    if (!user || user.role !== "employer") return { success: false, error: "Unauthorized" };

    const { from, to } = parseDateRange(range);

    const apps = await prisma.application.findMany({
        where: { job: { employer_id: user.id }, applied_at: { gte: from, lte: to } },
        select: { source: true, status: true, applied_at: true, updated_at: true },
    });

    const sourceMap: Record<string, { applications: number; hires: number; totalDays: number }> = {};
    for (const app of apps) {
        const src = app.source || "Direct";
        if (!sourceMap[src]) sourceMap[src] = { applications: 0, hires: 0, totalDays: 0 };
        sourceMap[src].applications++;
        if (app.status === "hired") {
            sourceMap[src].hires++;
            sourceMap[src].totalDays += (app.updated_at.getTime() - app.applied_at.getTime()) / (1000 * 60 * 60 * 24);
        }
    }

    const data = Object.entries(sourceMap).map(([source, d]) => ({
        source,
        applications: d.applications,
        hires: d.hires,
        conversionRate: d.applications > 0 ? Math.round((d.hires / d.applications) * 1000) / 10 : 0,
        avgTimeToHire: d.hires > 0 ? Math.round(d.totalDays / d.hires) : 0,
    })).sort((a, b) => b.applications - a.applications);

    return { success: true, data };
}

// ─── Recruiter Performance ──────────────────────────────
export async function getRecruiterPerformance(range?: DateRange): Promise<{ success: boolean; data?: RecruiterData[]; error?: string }> {
    const user = await getCurrentUser();
    if (!user || user.role !== "employer") return { success: false, error: "Unauthorized" };

    const { from, to } = parseDateRange(range);

    // Get all employer's jobs and their applications
    const jobs = await prisma.job.findMany({
        where: { employer_id: user.id },
        select: { id: true },
    });
    const jobIds = jobs.map(j => j.id);

    // Get hiring team members (recruiters)
    const teamMembers = await prisma.hiringTeamMember.findMany({
        where: { job_id: { in: jobIds }, role: { in: ["recruiter", "hiring_manager"] } },
        include: { user: { select: { id: true, name: true, avatar_url: true } } },
    });

    // Aggregate per recruiter
    const recruiterMap: Record<string, RecruiterData> = {};
    for (const tm of teamMembers) {
        if (!recruiterMap[tm.user.id]) {
            recruiterMap[tm.user.id] = {
                id: tm.user.id,
                name: tm.user.name,
                avatar: tm.user.avatar_url,
                hires: 0,
                avgTimeToHire: 0,
                activeCandidates: 0,
                conversionRate: 0,
            };
        }
    }

    // If no team members, return the employer themselves
    if (Object.keys(recruiterMap).length === 0) {
        const allApps = await prisma.application.count({
            where: { job_id: { in: jobIds }, applied_at: { gte: from, lte: to } },
        });
        const allHires = await prisma.application.count({
            where: { job_id: { in: jobIds }, status: "hired", updated_at: { gte: from, lte: to } },
        });
        return {
            success: true,
            data: [{
                id: user.id,
                name: user.name || "You",
                avatar: null,
                hires: allHires,
                avgTimeToHire: 0,
                activeCandidates: allApps - allHires,
                conversionRate: allApps > 0 ? Math.round((allHires / allApps) * 100) : 0,
            }],
        };
    }

    return { success: true, data: Object.values(recruiterMap) };
}

// ─── Time to Fill Breakdown ─────────────────────────────
export async function getTimeToFillBreakdown(range?: DateRange): Promise<{ success: boolean; data?: TimeToFillData[]; error?: string }> {
    const user = await getCurrentUser();
    if (!user || user.role !== "employer") return { success: false, error: "Unauthorized" };

    const { from, to } = parseDateRange(range);

    const history = await prisma.candidateStageHistory.findMany({
        where: {
            application: { job: { employer_id: user.id } },
            entered_at: { gte: from, lte: to },
            left_at: { not: null },
        },
        include: { stage: { select: { name: true, order: true } } },
    });

    const stageMap: Record<string, { totalDays: number; count: number; order: number }> = {};
    for (const h of history) {
        const name = h.stage.name;
        if (!stageMap[name]) stageMap[name] = { totalDays: 0, count: 0, order: h.stage.order };
        const days = h.left_at ? (h.left_at.getTime() - h.entered_at.getTime()) / (1000 * 60 * 60 * 24) : 0;
        stageMap[name].totalDays += days;
        stageMap[name].count++;
    }

    const data = Object.entries(stageMap)
        .map(([stage, d]) => {
            const avgDays = Math.round((d.totalDays / d.count) * 10) / 10;
            return {
                stage,
                avgDays,
                targetDays: 7,
                status: avgDays > 10 ? "critical" as const : avgDays > 5 ? "warning" as const : "good" as const,
                order: d.order,
            };
        })
        .sort((a, b) => a.order - b.order)
        .map(({ order, ...rest }) => rest);

    return { success: true, data };
}

// ─── Offer Acceptance ───────────────────────────────────
export async function getOfferAcceptanceReport(range?: DateRange): Promise<{ success: boolean; data?: OfferData; error?: string }> {
    const user = await getCurrentUser();
    if (!user || user.role !== "employer") return { success: false, error: "Unauthorized" };

    const { from, to } = parseDateRange(range);

    const offers = await prisma.applicationOffer.findMany({
        where: {
            application: {
                job: { employer_id: user.id },
                applied_at: { gte: from, lte: to },
            },
        },
        select: { id: true, status: true, created_at: true, updated_at: true },
    });

    const accepted = offers.filter(o => o.status === "accepted").length;
    const declined = offers.filter(o => o.status === "declined" || o.status === "rejected").length;
    const pending = offers.filter(o => o.status === "pending" || o.status === "sent").length;
    const expired = offers.filter(o => o.status === "expired").length;

    // Decision time for accepted offers
    const decisionDays = offers
        .filter(o => o.status === "accepted" || o.status === "declined")
        .map(o => (o.updated_at.getTime() - o.created_at.getTime()) / (1000 * 60 * 60 * 24));
    const avgDecisionDays = decisionDays.length > 0 ? Math.round(decisionDays.reduce((a, b) => a + b, 0) / decisionDays.length) : 0;

    // Decline reasons (use status as reason since no rejection_reason field)
    const reasonMap: Record<string, number> = {};
    for (const o of offers.filter(o => (o.status === "declined" || o.status === "rejected"))) {
        const reason = "Declined";
        reasonMap[reason] = (reasonMap[reason] || 0) + 1;
    }

    return {
        success: true,
        data: {
            totalOffers: offers.length,
            accepted,
            declined,
            pending,
            expired,
            acceptanceRate: offers.length > 0 ? Math.round((accepted / offers.length) * 100) : 0,
            avgDecisionDays,
            declineReasons: Object.entries(reasonMap).map(([reason, count]) => ({ reason, count })),
        },
    };
}
