const Proffesionalism = require("../models/professionalism");

module.exports = {
  proffesionalismEvaluations: async (req, res) => {
    try {
      const result = await Proffesionalism.findAllProffesionalism();
      if (!result) {
        return res.status(404).json({
          message: "Sorry no data for ProffesionalismEvaluation setup.",
        });
      }

      console.log(
        `proffesionalismEvaluation, successfully pulled on ${new Date()} `
      );

      return res.status(200).json(result);
    } catch (error) {
      console.error("Error occurred:", error);
      res.status(500).json({ error: true, message: "Internal Server Error" });
    }
  },

  proffesionalismEvaluationById: async (req, res) => {
    const { id } = req.body;
    try {
      const result = await Proffesionalism.findProffesionalismRecordById(id);
      if (!result) {
        return res.status(404).json({
          message: "Sorry their is no proffesionalismEvaluation with that id.",
        });
      }

      console.log(
        `ProffesionalismEvaluation with id ${id}, successfully pulled on ${new Date()} `
      );

      return res.status(200).json(result);
    } catch (error) {
      console.error("Error occurred:", error);
      res.status(500).json({ error: true, message: "Internal Server Error" });
    }
  },

  pendingProffesionalism: async (req, res) => {
    try {
      const result = await Proffesionalism.findPendingProffesionalismRecord(
        req.userId
      );
      if (!result) {
        return res.status(404).json({
          message: "Sorry no Pending proffesionalismEvaluation for this user.",
        });
      }

      console.log(
        `Pending ProffesionalismEvaluation for user with id ${
          req.userId
        }, successfully pulled on ${new Date()} `
      );

      return res.status(200).json(result);
    } catch (error) {
      console.error("Error occurred:", error);
      res.status(500).json({ error: true, message: "Internal Server Error" });
    }
  },

  actionDvcProffesionalismEvaluation: async (req, res) => {
    const { userId, sessionId } = req.body;

    try {
      const dvcData = {
        userId,
        sessionId,
      };
      const result = await Proffesionalism.findProffessionalismForEvaluationDvc(
        dvcData
      );
      if (!result) {
        return res.status(404).json({
          message: "Sorry no ProffesionalismEvaluation recored for this user.",
        });
      }

      console.log(
        `Existing ProffesionalismEvaluation for user with id ${
          dvcData.userId
        }, successfully pulled on ${new Date()} by DVC `
      );

      return res.status(200).json(result);
    } catch (error) {
      console.error("Error occurred:", error);
      res.status(500).json({ error: true, message: "Internal Server Error" });
    }
  },

  createProffesionalismEvaluation: async (req, res) => {
    const {
      matrixId,
      sessionId,
      proffesionalism_memeber_board,
      proffesionalism_exhibits_respect,
      proffesionalism_student_respect,
      proffesionalism_initiative,
      proffesionalism_manage_emotions,
      proffesionalism_continued_developement,
      proffesionalism_complete_tasks,
    } = req.body;

    try {
      const newProffesionalismEvaluation = {
        userId: req.userId,
        matrixId,
        sessionId,
        proffesionalism_memeber_board,
        proffesionalism_exhibits_respect,
        proffesionalism_student_respect,
        proffesionalism_initiative,
        proffesionalism_manage_emotions,
        proffesionalism_continued_developement,
        proffesionalism_complete_tasks,
        created_by: req.userId,
        self_submite_yn: "Y",
      };

      const result = await Proffesionalism.createProffesonalismRecord(
        newProffesionalismEvaluation
      );

      console.log(
        `successfully Created a new ProffesionalismEvaluation Record on ${new Date()}`
      );
      return res.status(201).json(result);
    } catch (error) {
      console.error("Error occurred:", error);
      res.status(500).json({ error: true, message: "Internal Server Error" });
    }
  },

  updateProffesionalismEvaluation: async (req, res) => {
    const {
      id,
      proffesionalism_memeber_board_h,
      proffesionalism_exhibits_respect_h,
      proffesionalism_student_respect_h,
      proffesionalism_initiative_h,
      proffesionalism_manage_emotions_h,
      proffesionalism_continued_developement_h,
      proffesionalism_complete_tasks_h,
    } = req.body;

    try {
      const serv = await Proffesionalism.findProffesionalismRecordById(id);
      if (!serv) {
        return res.status(400).json({
          message: "Sorry there seems to be a problem. Try again latter",
        });
      }

      const updatedProffesionalismEvaluation = {
        id,
        proffesionalism_memeber_board_h,
        proffesionalism_exhibits_respect_h,
        proffesionalism_student_respect_h,
        proffesionalism_initiative_h,
        proffesionalism_manage_emotions_h,
        proffesionalism_continued_developement_h,
        proffesionalism_complete_tasks_h,
        updated_by: req.userId,
        updatedAt: new Date(),
        hod_submited_yn: "Y",
      };

      const result = await Proffesionalism.updateProffesionalismRecord(
        updatedProffesionalismEvaluation
      );

      console.log(
        `successfully Updated ProfessionalismEvaluation ${
          updatedProffesionalismEvaluation.id
        } at ${new Date()}`
      );
      return res.status(201).json(result);
    } catch (error) {
      console.error("Error occurred:", error);
      res.status(500).json({ error: true, message: "Internal Server Error" });
    }
  },

  proffessionalismForUserCompilation: async (req, res) => {
    const { sessionId } = req.body;

    try {
      const userData = {
        userId: req.userId,
        sessionId,
      };
      const result =
        await Proffesionalism.findUserProffesionalismForCompilation(userData);
      if (!result) {
        return res.status(404).json({
          message: "Sorry no ProffessionalismEvaluation recored for this user.",
        });
      }

      console.log(
        `Existing User ProffessionalismEvaluation for user with id ${
          userData.userId
        }, successfully pulled on ${new Date()}  `
      );

      return res.status(200).json(result);
    } catch (error) {
      console.error("Error occurred:", error);
      res.status(500).json({ error: true, message: "Internal Server Error" });
    }
  },

  proffessionalismForHodCompilation: async (req, res) => {
    const { userId, sessionId } = req.body;

    try {
      const hodData = {
        userId,
        sessionId,
      };
      const result =
        await Proffesionalism.findHodProffessionalismForCompilation(hodData);
      if (!result) {
        return res.status(404).json({
          message: "Sorry no ProffessionalismEvaluation recored for this user.",
        });
      }

      console.log(
        `Existing HOD ProffessionalismEvaluation for user with id ${
          hodData.userId
        }, successfully pulled on ${new Date()} by ${req.email} `
      );

      return res.status(200).json(result);
    } catch (error) {
      console.error("Error occurred:", error);
      res.status(500).json({ error: true, message: "Internal Server Error" });
    }
  },
};