Interview Reports

const handleGenerateReport = async () => {
    const resumeFile = resumeInputRef.current.files[ 0 ]
    if (!jobDescription.trim()) {
        window.alert("Please paste the job description first.")
        return
    }
    if (!resumeFile && !selfDescription.trim()) {
        window.alert("Please upload a resume (PDF/DOCX) or fill in the self description.")
        return
    }
    const data = await generateReport({ jobDescription, selfDescription, resumeFile })
    if (data?._id) {
        navigate(`/interview/${data._id}`)
    }
}

let resumeText = ""
if (req.file?.buffer) {
    const mime = (req.file.mimetype || "").toLowerCase()
    const name = (req.file.originalname || "").toLowerCase()

    // Prefer "magic bytes" over mimetype/extension
    const b = req.file.buffer
    const isPdfMagic = b.length >= 4 && b[0] === 0x25 && b[1] === 0x50 && b[2] === 0x44 && b[3] === 0x46 // %PDF
    const isZipMagic = b.length >= 4 && b[0] === 0x50 && b[1] === 0x4b && b[2] === 0x03 && b[3] === 0x04 // PK..

    const isPdf = isPdfMagic || mime === "application/pdf" || name.endsWith(".pdf")
    const isDocx = isZipMagic || mime === "application/vnd.openxmlformats-officedocument.wordprocessingml.document" || name.endsWith(".docx")

    try {
        if (isPdf) {
            const parsed = await pdfParse(req.file.buffer)
            resumeText = parsed.text || ""
        } else if (isDocx) {
            const result = await mammoth.extractRawText({ buffer: req.file.buffer })
            resumeText = result.value || ""
        } else {
            return res.status(400).json({
                message: "Unsupported resume file type. Please upload a PDF or DOCX."
            })
        }
    } catch (err) {
        // If local parsing fails (scanned PDF / encrypted / corrupted),
        // fall back to letting Gemini read the original file directly.
        if (aiMimeType) {
            resumeFileForAi = {
                mimeType: aiMimeType,
                data: req.file.buffer.toString("base64")
            }
            resumeText = ""
        }
    }
}

let interViewReportByAi
try {
    interViewReportByAi = await generateInterviewReport({
        title: resolvedTitle,
        resume: resumeText,
        selfDescription: resolvedSelfDescription,
        jobDescription: resolvedJobDescription,
        resumeFile: resumeFileForAi
    })
} catch (err) {
    return res.status(502).json({
        message: "AI service failed to generate interview report. Please try again.",
    })
}

let interviewReport
try {
    interviewReport = await interviewReportModel.create({
        user: req.user.id,
        resume: resumeText,
        selfDescription: resolvedSelfDescription,
        ...interViewReportByAi,
        title: resolvedTitle,
        jobDescription: resolvedJobDescription
    })
} catch (err) {
    if (err?.name === "ValidationError") {
        return res.status(400).json({
            message: err.message
        })
    }
    throw err
}

res.status(201).json({
    message: "Interview report generated successfully.",
    interviewReport
})

const interviewReportSchema = z.object({
    matchScore: z.number().describe("A score between 0 and 100 indicating how well the candidate's profile matches the job describe"),
    technicalQuestions: z.array(z.object({
        question: z.string().describe("The technical question can be asked in the interview"),
        intention: z.string().describe("The intention of interviewer behind asking this question"),
        answer: z.string().describe("How to answer this question, what points to cover, what approach to take etc.")
    })).describe("Technical questions that can be asked in the interview along with their intention and how to answer them"),
    behavioralQuestions: z.array(z.object({
        question: z.string().describe("The technical question can be asked in the interview"),
        intention: z.string().describe("The intention of interviewer behind asking this question"),
        answer: z.string().describe("How to answer this question, what points to cover, what approach to take etc.")
    })).describe("Behavioral questions that can be asked in the interview along with their intention and how to answer them"),
    skillGaps: z.array(z.object({
        skill: z.string().describe("The skill which the candidate is lacking"),
        severity: z.enum([ "low", "medium", "high" ]).describe("The severity of this skill gap")
    })).describe("List of skill gaps in the candidate's profile along with their severity"),
    preparationPlan: z.array(z.object({
        day: z.number().describe("The day number in the preparation plan, starting from 1"),
        focus: z.string().describe("The main focus of this day in the preparation plan"),
        tasks: z.array(z.string()).describe("List of tasks to be done on this day")
    })).describe("A day-wise preparation plan for the candidate"),
    title: z.string().describe("The title of the job for which the interview report is generated"),
})

const interviewReportSchema = new mongoose.Schema({
    jobDescription: {
        type: String,
        required: [ true, "Job description is required" ]
    },
    resume: {
        type: String,
    },
    selfDescription: {
        type: String,
    },
    matchScore: {
        type: Number,
        min: 0,
        max: 100,
    },
    technicalQuestions: [ technicalQuestionSchema ],
    behavioralQuestions: [ behavioralQuestionSchema ],
    skillGaps: [ skillGapSchema ],
    preparationPlan: [ preparationPlanSchema ],
    user: {
        type: mongoose.Schema.Types.ObjectId,
        ref: "users"
    },
    title: {
        type: String,
        required: [ true, "Job title is required" ]
    }
}, {
    timestamps: true
})

const scoreColor =
    report.matchScore >= 80 ? 'score--high' :
        report.matchScore >= 60 ? 'score--mid' : 'score--low'

<div className='skill-gaps'>
    <p className='skill-gaps__label'>Skill Gaps</p>
    <div className='skill-gaps__list'>
        {report.skillGaps.map((gap, i) => (
            <span key={i} className={`skill-tag skill-tag--${gap.severity}`}>
                {gap.skill}
            </span>
        ))}
    </div>
</div>

async function getAllInterviewReportsController(req, res) {
    const interviewReports = await interviewReportModel.find({ user: req.user.id })
        .sort({ createdAt: -1 })
        .select("-resume -selfDescription -jobDescription -__v -technicalQuestions -behavioralQuestions -skillGaps -preparationPlan")

    res.status(200).json({
        message: "Interview reports fetched successfully.",
        interviewReports
    })
}

{reports.length > 0 && (
    <section className='recent-reports'>
        <h2>My Recent Interview Plans</h2>
        <ul className='reports-list'>
            {reports.map(report => (
                <li key={report._id} className='report-item' onClick={() => navigate(`/interview/${report._id}`)}>
                    <h3>{report.title || 'Untitled Position'}</h3>
                    <p className='report-meta'>Generated on {new Date(report.createdAt).toLocaleDateString()}</p>
                    <p className={`match-score ${report.matchScore >= 80 ? 'score--high' : report.matchScore >= 60 ? 'score--mid' : 'score--low'}`}>
                        Match Score: {report.matchScore}%
                    </p>
                </li>
            ))}
        </ul>
    </section>
)}

const response = await ai.models.generateContent({
    model: "gemini-3-flash-preview",
    contents,
    config: {
        responseMimeType: "application/json",
        responseSchema: zodToJsonSchema(interviewReportSchema),
    }
})