"use server";

import prisma from "@/lib/prisma";
import { revalidatePath } from "next/cache";
import { getCurrentUser } from "@/lib/auth";
import { JobPostingSchema, JobPostingFormValues } from "@/lib/validations/job";
import type { Prisma } from "@prisma/client";

// UUID v4 format validator
function isValidUUID(str: string): boolean {
    return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(str);
}

export async function createJobAction(formData: JobPostingFormValues) {
    try {
        const currentUser = await getCurrentUser();

        if (!currentUser) {
            console.error("[createJobAction] No current user found. Session might be invalid or missing.");
            return { success: false, error: "You must be logged in to post a job." };
        }

        const employerId = currentUser.id;

        if (!isValidUUID(employerId)) {
            console.error("[createJobAction] Invalid employer UUID:", employerId);
            return { success: false, error: "Your session appears to be invalid. Please log out and log back in." };
        }

        // Validate server-side to ensure integrity before touching DB
        const parsed = JobPostingSchema.safeParse(formData);

        if (!parsed.success) {
            console.error(parsed.error);
            return { success: false, error: "Validation failed. Please check form inputs." };
        }

        const data = parsed.data;

        // Generate Slug (e.g., "senior-frontend-engineer-acme-corp-123")
        const slugBase = `${data.title}-${data.company}`.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/(^-|-$)+/g, '');
        const slug = `${slugBase}-${Math.floor(Math.random() * 10000)}`;

        // Process Global Skills & Taxonomy
        const skillConnections = [];
        if (data.skills && data.skills.length > 0) {
            for (const skillItem of data.skills) {
                const skill = await prisma.skill.upsert({
                    where: { name: skillItem.name },
                    update: {},
                    create: { name: skillItem.name },
                });
                skillConnections.push({
                    skill_id: skill.id,
                    is_required: skillItem.is_required || false
                });
            }
        }

        // Insert new Job Record with all complex relations
        const newJob = await prisma.job.create({
            data: {
                employer_id: employerId,
                title: data.title,
                company: data.company,
                slug: slug,

                // Location & Work Rules
                work_location_type: data.work_location_type,
                address: data.address || null,
                city: data.city || null,
                state: data.state || null,
                country: data.country || null,
                zip_code: data.zip_code || null,
                remote_geo_restriction: data.remote_geo_restriction || null,
                time_zone_requirements: data.time_zone_requirements || null,
                days_in_office: data.days_in_office ? Number(data.days_in_office) : null,

                // Job Details
                type: data.type,
                experience_level: data.experience_level,
                number_of_openings: data.number_of_openings,

                // Taxonomy — only set if valid UUID (dropdown might use placeholder values)
                category_id: data.category_id && isValidUUID(data.category_id) ? data.category_id : null,
                industry_id: data.industry_id && isValidUUID(data.industry_id) ? data.industry_id : null,

                // Compensation — strip commas from formatted number strings, store as Int
                salary_type: data.salary_type,
                salary_min: data.salary_min
                    ? parseInt(String(data.salary_min).replace(/,/g, ""), 10)
                    : null,
                salary_max: data.salary_max
                    ? parseInt(String(data.salary_max).replace(/,/g, ""), 10)
                    : null,
                currency: data.currency || "NGN",
                hide_salary: data.hide_salary || false,
                benefits: (data.benefits && data.benefits.length > 0 ? data.benefits : []) as Prisma.InputJsonValue,

                // Description & Requirements
                summary: data.summary || null,
                description: data.description,
                responsibilities: data.responsibilities.filter(r => r.trim() !== ""),
                required_qualifications: data.required_qualifications.filter(q => q.trim() !== ""),
                preferred_qualifications: (data.preferred_qualifications || []).filter(q => q.trim() !== ""),

                // Settings
                application_method: data.application_method,
                external_url: data.external_url || null,
                contact_email: data.contact_email || null,
                internal_notes: data.internal_notes || null,

                status: 'pending',

                // Relations
                skills: skillConnections.length > 0 ? {
                    create: skillConnections,
                } : undefined,
                screening_questions: data.screening_questions && data.screening_questions.length > 0 ? {
                    create: data.screening_questions.map((q, i) => ({
                        question_text: q.question_text,
                        question_type: q.question_type,
                        is_required: q.is_required,
                        order: q.order ?? i,
                        options: q.options && q.options.length > 0 ? q.options : [],
                        ideal_answer: q.ideal_answer || null,
                    }))
                } : undefined,
            },
            select: {
                id: true,
                slug: true,
            },
        });

        revalidatePath("/");
        revalidatePath("/dashboard/jobs");

        return { success: true, jobId: newJob.id, slug: newJob.slug };
    } catch (error: any) {
        console.error("[createJobAction] Failed to create job:", error?.message || error);
        const userMessage = error?.code === 'P2023'
            ? "There was a data format issue. Please log out and log back in, then try again."
            : error?.code === 'P2003'
                ? "A referenced record (like category or industry) was not found. Please check your selections."
                : `Failed to create job: ${error?.message || 'Unknown server error'}`;
        return { success: false, error: userMessage };
    }
}

export async function toggleSaveJobAction(jobId: string, userId?: string) {
    try {
        let currentUserId = userId;
        if (!currentUserId) {
            const user = await getCurrentUser();
            currentUserId = user?.id;
        }

        if (!currentUserId) {
            return { success: false, error: "Must be logged in" };
        }

        const existing = await prisma.savedJob.findUnique({
            where: {
                user_id_job_id: {
                    user_id: currentUserId,
                    job_id: jobId,
                }
            }
        });

        if (existing) {
            await prisma.savedJob.delete({
                where: {
                    user_id_job_id: {
                        user_id: currentUserId,
                        job_id: jobId,
                    }
                }
            });
        } else {
            await prisma.savedJob.create({
                data: {
                    user_id: currentUserId,
                    job_id: jobId,
                }
            });
        }

        revalidatePath("/");
        revalidatePath("/dashboard");
        return { success: true };
    } catch (error) {
        console.error("Failed to toggle save:", error);
        return { success: false, error: "Failed to save job" };
    }
}
