gg-backend/backend/src/controllers/appointment.controller.js

import prisma from "../prisma/client.js";
import { sendEmail } from "../utils/sendEmail.js";
import { getEmailsByType } from "../utils/getEmailByTypes.js";

export const createAppointment = async (req, res) => {
	try {
		const { name, mobileNumber, email, message, date, doctorId, departmentId } =
			req.body;

		if (!name || !mobileNumber || !doctorId || !departmentId || !date) {
			return res.status(400).json({
				success: false,
				message: "Required fields missing",
			});
		}

		const appointment = await prisma.appointment.create({
			data: {
				name,
				mobileNumber,
				email,
				message,
				date: new Date(date),
				doctorId,
				departmentId,
			},
			include: {
				doctor: true,
				department: true,
			},
		});

		try {
			const emailList = await getEmailsByType("APPOINTMENT");

			if (emailList) {
				await sendEmail({
					to: emailList,
					subject: "New Appointment Booked",
					html: `
						<h2>New Appointment Booked</h2>
						<p><b>Name:</b> ${name}</p>
						<p><b>Phone:</b> ${mobileNumber}</p>
						<p><b>Email:</b> ${email || "-"}</p>
						<p><b>Doctor:</b> ${appointment.doctor?.name}</p>
						<p><b>Department:</b> ${appointment.department?.name}</p>
						<p><b>Date:</b> ${new Date(date).toLocaleDateString()}</p>
						<p><b>Message:</b> ${message || "-"}</p>
					`,
				});
			}
		} catch (err) {
			console.error("Email failed:", err);
		}

		res.status(201).json({
			success: true,
			message: "Appointment booked successfully",
			data: appointment,
		});
	} catch (error) {
		console.error(error);
		res.status(500).json({
			success: false,
			message: "Failed to create appointment",
		});
	}
};

// GET ALL APPOINTMENTS

export const getAppointments = async (req, res) => {
	try {
		const page = parseInt(req.query.page) || 1;
		const limit = parseInt(req.query.limit) || 10;
		const skip = (page - 1) * limit;
		const { date, search } = req.query;

		const where = {};

		if (date) {
			const start = new Date(date);
			const end = new Date(date);
			end.setDate(end.getDate() + 1);
			where.date = { gte: start, lt: end };
		}

		if (search) {
			where.OR = [
				{ name: { contains: search, mode: "insensitive" } },
				{ mobileNumber: { contains: search } },
				{ email: { contains: search, mode: "insensitive" } },
			];
		}

		const [appointments, total] = await Promise.all([
			prisma.appointment.findMany({
				where,
				include: { doctor: true, department: true },
				orderBy: { createdAt: "desc" },
				skip,
				take: limit,
			}),
			prisma.appointment.count({ where }),
		]);

		res.status(200).json({
			success: true,
			data: appointments,
			pagination: { total, page, limit, totalPages: Math.ceil(total / limit) },
		});
	} catch (error) {
		console.error(error);
		res
			.status(500)
			.json({ success: false, message: "Failed to fetch appointments" });
	}
};

// GET SINGLE APPOINTMENT

export const getAppointment = async (req, res) => {
	try {
		const { id } = req.params;

		const appointment = await prisma.appointment.findUnique({
			where: {
				id: Number(id),
			},
			include: {
				doctor: true,
				department: true,
			},
		});

		if (!appointment) {
			return res.status(404).json({
				success: false,
				message: "Appointment not found",
			});
		}

		res.status(200).json({
			success: true,
			data: appointment,
		});
	} catch (error) {
		console.error(error);
		res.status(500).json({
			success: false,
			message: "Failed to fetch appointment",
		});
	}
};

// GET APPOINTMENTS BY DOCTOR

export const getAppointmentsByDoctor = async (req, res) => {
	try {
		const { doctorId } = req.params;

		const appointments = await prisma.appointment.findMany({
			where: {
				doctorId,
			},
			include: {
				doctor: true,
				department: true,
			},
			orderBy: {
				date: "asc",
			},
		});

		res.status(200).json({
			success: true,
			data: appointments,
		});
	} catch (error) {
		console.error(error);
		res.status(500).json({
			success: false,
			message: "Failed to fetch doctor appointments",
		});
	}
};

// GET APPOINTMENTS BY DEPARTMENT

export const getAppointmentsByDepartment = async (req, res) => {
	try {
		const { departmentId } = req.params;

		const appointments = await prisma.appointment.findMany({
			where: {
				departmentId,
			},
			include: {
				doctor: true,
				department: true,
			},
		});

		res.status(200).json({
			success: true,
			data: appointments,
		});
	} catch (error) {
		console.error(error);
		res.status(500).json({
			success: false,
			message: "Failed to fetch department appointments",
		});
	}
};

// UPDATE APPOINTMENT

export const updateAppointment = async (req, res) => {
	try {
		const { id } = req.params;

		const appointment = await prisma.appointment.update({
			where: {
				id: Number(id),
			},
			data: req.body,
			include: {
				doctor: true,
				department: true,
			},
		});

		res.status(200).json({
			success: true,
			message: "Appointment updated successfully",
			data: appointment,
		});
	} catch (error) {
		console.error(error);
		res.status(500).json({
			success: false,
			message: "Failed to update appointment",
		});
	}
};

//DELETE APPOINTMENT

export const deleteAppointment = async (req, res) => {
	try {
		const { id } = req.params;

		await prisma.appointment.delete({
			where: {
				id: Number(id),
			},
		});

		res.status(200).json({
			success: true,
			message: "Appointment deleted successfully",
		});
	} catch (error) {
		console.error(error);
		res.status(500).json({
			success: false,
			message: "Failed to delete appointment",
		});
	}
};