const express = require("express");
const router = express.Router();
const Appointment = require("../models/Appointment");
const Course = require("../models/Course");
const Faculty = require("../models/Faculty");

router.get("/consolidated-table", async (req, res) => {
  try {
    const appointments = await Appointment.find();
    const courses = await Course.find();
    const faculties = await Faculty.find();

    // Group by facultyId and courseId
    const groupedData = {};

    appointments.forEach((appointment) => {
      const key = `${appointment.facultyId}-${appointment.courseId}`;
      if (!groupedData[key]) {
        groupedData[key] = {
          facultyId: appointment.facultyId,
          courseId: appointment.courseId,
          facultyName: appointment.facultyName,
          courseName: appointment.courseName,
          semester: "",
          examType: "",
          year: "",
          marks: "100+25", // Dummy value, replace with actual logic
          affiliation: "KJSCE", // Replace with actual value
          qualification: "M.E.", // Replace with actual value
          experience: "20+", // Dummy value
          tasks: new Set(), // Use a set to avoid duplicate tasks
        };
      }
      groupedData[key].tasks.add(appointment.task);
    });

    // Add course details to the grouped data
    Object.values(groupedData).forEach((data) => {
      const course = courses.find((c) => c.courseId === data.courseId);
      if (course) {
        data.semester = course.semester;
        data.examType = course.scheme;
        data.year = course.program;
      }
    });

    // Format the tasks into separate columns
    const tableData = Object.values(groupedData).map((data, index) => ({
      srNo: index + 1,
      semester: data.semester,
      courseCode: data.courseId,
      courseName: data.courseName,
      examType: data.examType,
      year: data.year,
      marks: data.marks,
      Name: data.facultyName,
      affiliation: data.affiliation,
      qualification: data.qualification,
      experience: data.experience,
      oralPractical: data.tasks.has("oralsPracticals") ? "✔" : "",
      assessment: data.tasks.has("assessment") ? "✔" : "",
      reassessment: data.tasks.has("reassessment") ? "✔" : "",
      paperSetting: data.tasks.has("paperSetting") ? "✔" : "",
      moderation: data.tasks.has("moderation") ? "✔" : "",
      pwdPaperSetting: data.tasks.has("pwdPaperSetter") ? "✔" : "",
      facultyId: `${data.facultyId}`
    }));

    res.status(200).json(tableData);
  } catch (error) {
    console.error("Error fetching consolidated table data:", error);
    res.status(500).json({ message: "Failed to fetch consolidated table data" });
  }
});

router.get("/course-consolidated", async (req, res) => {
  try {
    const appointments = await Appointment.find();
    const courses = await Course.find();

    // Group appointments by courseId and task
    const groupedByCourse = {};

    appointments.forEach((appointment) => {
      const courseId = appointment.courseId;

      if (!groupedByCourse[courseId]) {
        groupedByCourse[courseId] = {
          courseId: courseId,
          courseName: appointment.courseName,
          tasks: {
            oralsPracticals: new Set(),
            assessment: new Set(),
            reassessment: new Set(),
            paperSetting: new Set(),
            moderation: new Set(),
            pwdPaperSetter: new Set(),
          },
          semester: "",
          examType: "",
          year: "",
        };
      }

      // Add the faculty name to the appropriate task
      if (appointment.task && groupedByCourse[courseId].tasks[appointment.task]) {
        groupedByCourse[courseId].tasks[appointment.task].add(appointment.facultyName);
      }
    });

    // Add course details to grouped data
    Object.values(groupedByCourse).forEach((group) => {
      const course = courses.find((c) => c.courseId === group.courseId);

      if (course) {
        group.semester = course.semester;
        group.examType = course.scheme;
        group.year = course.program;
      }
    });

    // Format the consolidated data
    const consolidatedData = Object.values(groupedByCourse).map((course, index) => ({
      courseCode: course.courseId,
      courseName: course.courseName,
      semester: course.semester,
      examType: course.examType,
      year: course.year,
      oralPracticalTeachers: Array.from(course.tasks.oralsPracticals),
      assessmentTeachers: Array.from(course.tasks.assessment),
      reassessmentTeachers: Array.from(course.tasks.reassessment),
      paperSettingTeachers: Array.from(course.tasks.paperSetting),
      moderationTeachers: Array.from(course.tasks.moderation),
      pwdPaperSettingTeachers: Array.from(course.tasks.pwdPaperSetter),
    }));

    res.status(200).json(consolidatedData);
  } catch (error) {
    console.error("Error fetching course consolidated data:", error);
    res.status(500).json({ message: "Failed to fetch course consolidated data" });
  }
});

module.exports = router;