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

import prisma from "../prisma/client.js";

// get doctors

export const getAllDoctors = async (req, res) => {
	try {
		const {admin} = req.query;

		const doctors = await prisma.doctor.findMany({
			where: admin === "true" ? {} : {isActive: true},
			include: {
				seo: true,
				departments: {
					include: {
						department: true,
						timing: true,
					},
				},
				specializations: {
					orderBy: {
						createdAt: "asc",
					},
				},
			},
			orderBy: [{globalSortOrder: "asc"}, {name: "asc"}],
		});

		const formatted = doctors.map((doc, index) => ({
			SL_NO: String(index + 1),
			doctorId: doc.doctorId,
			name: doc.name,
			image: doc.image ?? "",
			designation: doc.designation,
			workingStatus: doc.workingStatus,
			qualification: doc.qualification,
			isActive: doc.isActive,
			experience: doc.experience,
			professionalSummary: doc.professionalSummary,
			globalSortOrder: doc.globalSortOrder,
			specializations: doc.specializations.map((item) => ({
				id: item.id,
				name: item.name,
				description: item.description,
			})),
			seo: {
				seoTitle: doc.seo?.seoTitle ?? "",
				metaDescription: doc.seo?.metaDescription ?? "",
				focusKeyphrase: doc.seo?.focusKeyphrase ?? "",
				slug: doc.seo?.slug ?? "",
				tags: doc.seo?.tags ?? [],

				ogTitle: doc.seo?.ogTitle ?? "",
				ogDescription: doc.seo?.ogDescription ?? "",
				ogImage: doc.seo?.ogImage ?? "",
			},
			departments: doc.departments.map((d) => {
				const t = d.timing || {};
				const timingArray = [
					t.monday && `Monday ${t.monday}`,
					t.tuesday && `Tuesday ${t.tuesday}`,
					t.wednesday && `Wednesday ${t.wednesday}`,
					t.thursday && `Thursday ${t.thursday}`,
					t.friday && `Friday ${t.friday}`,
					t.saturday && `Saturday ${t.saturday}`,
					t.sunday && `Sunday ${t.sunday}`,
					t.additional && t.additional,
				].filter(Boolean);

				return {
					departmentId: d.department.departmentId,
					departmentName: d.department.name,
					timing: timingArray.join(" & "),
					deptSortOrder: d.sortOrder,
				};
			}),
		}));

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

// get doctor by id

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

		const doctor = await prisma.doctor.findUnique({
			where: {doctorId},
			include: {
				seo: true,
				specializations: true,
				departments: {
					include: {
						department: true,
						timing: true,
					},
				},
			},
		});

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

		const response = {
			doctorId: doctor.doctorId,
			name: doctor.name,
			image: doctor.image ?? "",
			designation: doctor.designation,
			workingStatus: doctor.workingStatus,
			qualification: doctor.qualification,
			experience: doctor.experience,
			professionalSummary: doctor.professionalSummary,
			seo: {
				seoTitle: doctor.seo?.seoTitle ?? "",
				metaDescription: doctor.seo?.metaDescription ?? "",
				focusKeyphrase: doctor.seo?.focusKeyphrase ?? "",
				slug: doctor.seo?.slug ?? "",
				tags: doctor.seo?.tags ?? [],
				ogTitle: doctor.seo?.ogTitle ?? "",
				ogDescription: doctor.seo?.ogDescription ?? "",
				ogImage: doctor.seo?.ogImage ?? "",
			},
			specializations:
				doctor.specializations?.map((item) => ({
					id: item.id,
					name: item.name,
					description: item.description,
				})) ?? [],
			departments: doctor.departments.map((d) => ({
				departmentId: d.department.departmentId,
				departmentName: d.department.name,
				timing: d.timing || {},
			})),
		};

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

// get doctors by department
export const getDoctorsByDepartmentId = async (req, res) => {
	try {
		const {Department_ID} = req.query;

		if (!Department_ID) {
			return res.status(400).json({
				success: false,
				message: "Department_ID is required",
			});
		}

		const department = await prisma.department.findUnique({
			where: {departmentId: Department_ID},
		});

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

		const doctorsInDept = await prisma.doctorDepartment.findMany({
			where: {
				departmentId: department.id,
				doctor: {isActive: true},
			},
			include: {
				doctor: true,
			},
			orderBy: {sortOrder: "asc"},
		});

		const result = doctorsInDept.map((d) => ({
			GG_ID: d.doctor.doctorId,
			Name: d.doctor.name,
			image: d.doctor.image ?? "",
			designation: d.doctor.designation,
			hierarchyOrder: d.sortOrder,
		}));

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

// add doctors
export const createDoctor = async (req, res) => {
	try {
		const {
			doctorId,
			name,
			image,
			designation,
			workingStatus,
			qualification,
			isActive,
			globalSortOrder,
			departments,
			experience,
			professionalSummary,
			seoTitle,
			metaDescription,
			focusKeyphrase,
			slug,
			tags,
			specializations,
			ogTitle,
			ogDescription,
			ogImage,
		} = req.body;
		const seo = await prisma.seo.create({
			data: {
				seoTitle,
				metaDescription,
				focusKeyphrase,
				slug: slug ? slug : null,
				tags: tags || [],

				// Open Graph
				ogTitle,
				ogDescription,
				ogImage,
			},
		});

		const doctor = await prisma.doctor.create({
			data: {
				doctorId,
				name,
				image,
				designation,
				workingStatus,
				qualification,
				experience: experience ? Number(experience) : null,
				professionalSummary,
				seoId: seo.id,
				isActive: isActive !== undefined ? isActive : true,
				globalSortOrder:
					globalSortOrder !== undefined ? Number(globalSortOrder) : 0,
			},
		});

		for (const dep of departments) {
			const department = await prisma.department.findUnique({
				where: {departmentId: dep.departmentId},
			});

			if (!department) continue;

			const doctorDepartment = await prisma.doctorDepartment.create({
				data: {
					doctorId: doctor.id,
					departmentId: department.id,
					sortOrder: dep.sortOrder !== undefined ? Number(dep.sortOrder) : 0,
				},
			});

			if (dep.timing) {
				await prisma.doctorTiming.create({
					data: {
						doctorDepartmentId: doctorDepartment.id,
						...dep.timing,
					},
				});
			}
		}
		if (specializations?.length) {
			await prisma.doctorSpecialization.createMany({
				data: specializations
					.filter((item) => item.name?.trim())
					.map((item) => ({
						name: item.name.trim(),
						description: item.description?.trim() || null,
						doctorId: doctor.id,
					})),
			});
		}

		res.status(201).json({
			success: true,
			message: "Doctor created successfully",
		});
	} catch (error) {
		console.error(error);
		res.status(500).json({
			success: false,
			message: "Failed to create doctor",
		});
	}
};

//update doctors
export const updateDoctor = async (req, res) => {
	try {
		const {doctorId} = req.params;
		const {
			name,
			designation,
			image,
			workingStatus,
			qualification,
			isActive,
			globalSortOrder,
			departments,
			experience,
			professionalSummary,
			seoTitle,
			metaDescription,
			focusKeyphrase,
			slug,
			tags,
			specializations,
		} = req.body;

		const doctor = await prisma.doctor.findUnique({where: {doctorId}});
		if (!doctor)
			return res
				.status(404)
				.json({success: false, message: "Doctor not found"});

		await prisma.doctor.update({
			where: {id: doctor.id},
			data: {
				name,
				designation,
				image,
				workingStatus,
				qualification,
				isActive,
				experience: experience ? Number(experience) : null,
				professionalSummary,
				globalSortOrder:
					globalSortOrder !== undefined ? Number(globalSortOrder) : undefined,
			},
		});
		const existingDepartments = await prisma.doctorDepartment.findMany({
			where: {
				doctorId: doctor.id,
			},
			include: {
				timing: true,
			},
		});

		for (const dep of departments) {
			const department = await prisma.department.findUnique({
				where: {departmentId: dep.departmentId},
			});

			if (!department) continue;

			const existing = existingDepartments.find(
				(d) => d.departmentId === department.id,
			);

			const newSortOrder =
				dep.sortOrder !== undefined ? Number(dep.sortOrder) : 0;

			const isSameDepartment = existing && existing.sortOrder === newSortOrder;

			const isSameTiming =
				JSON.stringify(existing?.timing || {}) ===
				JSON.stringify(dep.timing || {});

			if (isSameDepartment && isSameTiming) {
				continue;
			}

			let doctorDepartment = existing;

			if (!existing) {
				doctorDepartment = await prisma.doctorDepartment.create({
					data: {
						doctorId: doctor.id,
						departmentId: department.id,
						sortOrder: newSortOrder,
					},
				});
			} else if (existing.sortOrder !== newSortOrder) {
				doctorDepartment = await prisma.doctorDepartment.update({
					where: {id: existing.id},
					data: {
						sortOrder: newSortOrder,
					},
				});
			}

			if (dep.timing) {
				if (existing?.timing) {
					await prisma.doctorTiming.update({
						where: {id: existing.timing.id},
						data: dep.timing,
					});
				} else {
					await prisma.doctorTiming.create({
						data: {
							doctorDepartmentId: doctorDepartment.id,
							...dep.timing,
						},
					});
				}
			}
		}
		if (doctor.seoId) {
			await prisma.seo.update({
				where: {
					id: doctor.seoId,
				},
				data: {
					seoTitle,
					metaDescription,
					focusKeyphrase,
					slug: slug ? slug : null,
					tags: tags || [],
				},
			});
		} else {
			const seo = await prisma.seo.create({
				data: {
					seoTitle,
					metaDescription,
					focusKeyphrase,
					slug: slug ? slug : null,
					tags: tags || [],
				},
			});

			await prisma.doctor.update({
				where: {
					id: doctor.id,
				},
				data: {
					seoId: seo.id,
				},
			});
		}

		const hasTimingData = departments?.some(
			(dep) => dep.timing && Object.keys(dep.timing).length > 0,
		);

		// Update Specializations
		if (Array.isArray(specializations)) {
			await prisma.doctorSpecialization.deleteMany({
				where: {
					doctorId: doctor.id,
				},
			});

			if (specializations.length) {
				await prisma.doctorSpecialization.createMany({
					data: specializations
						.filter((item) => item.name?.trim())
						.map((item) => ({
							name: item.name.trim(),
							description: item.description?.trim() || null,
							doctorId: doctor.id,
						})),
				});
			}
		}

		if (departments && Array.isArray(departments) && hasTimingData) {
			const oldRelations = await prisma.doctorDepartment.findMany({
				where: {doctorId: doctor.id},
			});

			for (const rel of oldRelations) {
				await prisma.doctorTiming.deleteMany({
					where: {doctorDepartmentId: rel.id},
				});
			}

			await prisma.doctorDepartment.deleteMany({
				where: {doctorId: doctor.id},
			});

			for (const dep of departments) {
				const targetDept = await prisma.department.findUnique({
					where: {departmentId: dep.departmentId},
				});
				if (!targetDept) continue;

				const newDD = await prisma.doctorDepartment.create({
					data: {
						doctorId: doctor.id,
						departmentId: targetDept.id,
						sortOrder: dep.sortOrder !== undefined ? Number(dep.sortOrder) : 0,
					},
				});

				if (dep.timing) {
					const {id, doctorDepartmentId, createdAt, updatedAt, ...cleanTiming} =
						dep.timing;
					await prisma.doctorTiming.create({
						data: {doctorDepartmentId: newDD.id, ...cleanTiming},
					});
				}
			}
		}

		res
			.status(200)
			.json({success: true, message: "Doctor updated successfully"});
	} catch (error) {
		console.error("Update Error:", error);
		res.status(500).json({success: false, message: "Failed to update doctor"});
	}
};
//delete doctor

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

		const doctor = await prisma.doctor.findUnique({
			where: {doctorId},
		});

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

		const doctorDepartments = await prisma.doctorDepartment.findMany({
			where: {doctorId: doctor.id},
		});

		for (const dd of doctorDepartments) {
			await prisma.doctorTiming.deleteMany({
				where: {doctorDepartmentId: dd.id},
			});
		}

		await prisma.doctorDepartment.deleteMany({
			where: {doctorId: doctor.id},
		});

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

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

// get doctor timings

export const getDoctorTimings = async (req, res) => {
	try {
		const doctors = await prisma.doctor.findMany({
			include: {
				departments: {
					include: {
						timing: true,
					},
				},
			},
		});

		const result = doctors.map((doc) => {
			const timing = doc.departments[0]?.timing || {};

			return {
				Doctor_ID: doc.doctorId,
				Doctor: doc.name,
				Monday: timing.monday || "",
				Tuesday: timing.tuesday || "",
				Wednesday: timing.wednesday || "",
				Thursday: timing.thursday || "",
				Friday: timing.friday || "",
				Saturday: timing.saturday || "",
				Sunday: timing.sunday || "",
				Additional: timing.additional || "",
			};
		});

		res.status(200).json({
			success: true,
			data: result,
		});
	} catch (error) {
		console.error(error);
		res.status(500).json({
			success: false,
			message: "Failed to fetch doctor timings",
		});
	}
};
// get doctor timings by id

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

		const doctor = await prisma.doctor.findUnique({
			where: {doctorId},
			include: {
				departments: {
					include: {
						department: true,
						timing: true,
					},
				},
			},
		});

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

		const result = {
			doctorId: doctor.doctorId,
			doctorName: doctor.name,
			departments: doctor.departments.map((d) => ({
				departmentId: d.department.departmentId,
				departmentName: d.department.name,
				deptSortOrder: d.sortOrder,
				timing: d.timing || {},
			})),
		};

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