const express = require("express");
const router = express.Router();

const authMiddleware = require("../middleware/authMiddleware");
const authController = require("../controllers/authController");
const courseController = require("../controllers/courseController");
const scholarController = require("../controllers/scholarController");
const grantController = require("../controllers/grantController");
const serviceController = require("../controllers/servicesController");
const proffesionalismController = require("../controllers/proffessionalismController");
const rolesController = require("../controllers/rolecontroller");
const sessionController = require("../controllers/sessionController");
const userController = require("../controllers/usercontroller");
const departmentController = require("../controllers/departmentController");
const scoresController = require("../controllers/scorescontroller");
const evaluationMatrixController = require("../controllers/evaluationMatrixcontroller");
const evalluationcontoller = require("../controllers/evalluationcontoller");
const leaveController = require("../controllers/leaveController");

router.post("/signin", authController.signin);

//*** Courses */
router.post(
  "/courses",
  authMiddleware.verifyToken,
  courseController.courseEvaluations
);
router.post(
  "/courseById",
  authMiddleware.verifyToken,
  courseController.courseEvaluationById
);
router.post(
  "/createCourse",
  authMiddleware.verifyToken,
  courseController.createCourseEvaluation
);
router.post(
  "/updateCourse",
  authMiddleware.verifyToken,
  courseController.updateCourseEvaluation
);

router.post(
  "/pendingCourse",
  authMiddleware.verifyToken,
  courseController.pendingCourseEvaluation
);

router.post(
  "/dvcCourses",
  authMiddleware.verifyToken,
  courseController.actionDvcCourseEvaluation
);

router.post(
  "/userCourseCompilation",
  authMiddleware.verifyToken,
  courseController.courseForUserCompilation
);

router.post(
  "/hodCourseCompilation",
  authMiddleware.verifyToken,
  courseController.courseForHodCompilation
);

/**
 * Scholarly
 */
router.post(
  "/scholars",
  authMiddleware.verifyToken,
  scholarController.scholarEvaluations
);
router.post(
  "/scholarById",
  authMiddleware.verifyToken,
  scholarController.scholarEvaluationById
);
router.post(
  "/createScholar",
  authMiddleware.verifyToken,
  scholarController.createScholarEvaluation
);
router.post(
  "/updateScholar",
  authMiddleware.verifyToken,
  scholarController.updateGrantEvaluation
);

router.post(
  "/pendingScholar",
  authMiddleware.verifyToken,
  scholarController.pendingScholarEvaluation
);

router.post(
  "/dvcScholar",
  authMiddleware.verifyToken,
  scholarController.actionDvcScholarEvaluation
);

router.post(
  "/userScholarCompilation",
  authMiddleware.verifyToken,
  scholarController.scholarForUserCompilation
);

router.post(
  "/hodScholarCompilation",
  authMiddleware.verifyToken,
  scholarController.scholarForHodCompilation
);

/**
 * Grants
 */
router.post(
  "/grants",
  authMiddleware.verifyToken,
  grantController.grantsEvaluations
);
router.post(
  "/grantsById",
  authMiddleware.verifyToken,
  grantController.grantsEvaluationById
);
router.post(
  "/createGrant",
  authMiddleware.verifyToken,
  grantController.createCourseEvaluation
);
router.post(
  "/updateGrant",
  authMiddleware.verifyToken,
  grantController.updateGrantEvaluation
);

router.post(
  "/pendingGrants",
  authMiddleware.verifyToken,
  grantController.pendingGrantsEvaluation
);

router.post(
  "/dvcGrants",
  authMiddleware.verifyToken,
  grantController.actionDvcGrantEvaluation
);

router.post(
  "/userGrantCompilation",
  authMiddleware.verifyToken,
  grantController.grantForUserCompilation
);

router.post(
  "/hodGrantCompilation",
  authMiddleware.verifyToken,
  grantController.grantForHodCompilation
);

/**
 * University Services
 */
router.post(
  "/services",
  authMiddleware.verifyToken,
  serviceController.servicesEvaluations
);
router.post(
  "/servicesById",
  authMiddleware.verifyToken,
  serviceController.servicesEvaluationById
);
router.post(
  "/createService",
  authMiddleware.verifyToken,
  serviceController.createServiceEvaluation
);
router.post(
  "/updateService",
  authMiddleware.verifyToken,
  serviceController.updateServiceEvaluation
);

router.post(
  "/pendingServices",
  authMiddleware.verifyToken,
  serviceController.pendingServiceEvaluation
);

router.post(
  "/dvcServices",
  authMiddleware.verifyToken,
  serviceController.actionDvcServiceEvaluation
);

router.post(
  "/userServiceCompilation",
  authMiddleware.verifyToken,
  serviceController.serviceForUserCompilation
);

router.post(
  "/hodServiceCompilation",
  authMiddleware.verifyToken,
  serviceController.serviceForHodCompilation
);

/**
 * Proffessionalism
 */
router.post(
  "/professionalism",
  authMiddleware.verifyToken,
  proffesionalismController.proffesionalismEvaluations
);
router.post(
  "/proffesionalismById",
  authMiddleware.verifyToken,
  proffesionalismController.proffesionalismEvaluationById
);
router.post(
  "/createProffesionalism",
  authMiddleware.verifyToken,
  proffesionalismController.createProffesionalismEvaluation
);
router.post(
  "/updateProffesionalism",
  authMiddleware.verifyToken,
  proffesionalismController.updateProffesionalismEvaluation
);

router.post(
  "/pendingProffesionalism",
  authMiddleware.verifyToken,
  proffesionalismController.pendingProffesionalism
);

router.post(
  "/dvcProffessionalism",
  authMiddleware.verifyToken,
  proffesionalismController.actionDvcProffesionalismEvaluation
);

router.post(
  "/userProffessionalismCompilation",
  authMiddleware.verifyToken,
  proffesionalismController.proffessionalismForUserCompilation
);

router.post(
  "/hodProffessionalismCompilation",
  authMiddleware.verifyToken,
  proffesionalismController.proffessionalismForHodCompilation
);

/**
 * Roles
 */
router.post("/roles", authMiddleware.verifyToken, rolesController.roles);
router.post("/rolesById", authMiddleware.verifyToken, rolesController.roleById);
router.post(
  "/createRole",
  authMiddleware.verifyToken,
  rolesController.createRole
);
router.post(
  "/updateRole",
  authMiddleware.verifyToken,
  rolesController.updateAvailableRole
);

/**
 * Session
 */
router.post(
  "/sessions",
  authMiddleware.verifyToken,
  sessionController.sessions
);
router.post(
  "/sessionsById",
  authMiddleware.verifyToken,
  sessionController.sessionById
);
router.post(
  "/activeSession",
  authMiddleware.verifyToken,
  sessionController.activeSessions
);
router.post(
  "/createSession",
  authMiddleware.verifyToken,
  sessionController.createSession
);
router.post(
  "/updateSession",
  authMiddleware.verifyToken,
  sessionController.updateAvailableSession
);

/**
 * Users
 */
router.post("/createUser", userController.register);
router.post("/resetUser", userController.resetUserPassword);
router.post(
  "/activeDepUsers",
  authMiddleware.verifyToken,
  userController.departmentUsers
);

router.post(
  "/hrUsers",
  authMiddleware.verifyToken,
  userController.hrUsers
);

router.post(
  "/userType",
  authMiddleware.verifyToken,
  userController.allUserTypes
);
router.post(
  "/activeHods",
  authMiddleware.verifyToken,
  userController.headofDepartmentUsers
);

/**
 * Department
 */
router.post(
  "/departments",
  authMiddleware.verifyToken,
  departmentController.departments
);
router.post(
  "/departmentById",
  authMiddleware.verifyToken,
  departmentController.departmentById
);
router.post(
  "/createDepartment",
  authMiddleware.verifyToken,
  departmentController.createDepartment
);
router.post(
  "/updateDepartment",
  authMiddleware.verifyToken,
  departmentController.updateAvailableDepartment
);

/**Scores */

router.post("/scores", authMiddleware.verifyToken, scoresController.scores);
router.post(
  "/scoreById",
  authMiddleware.verifyToken,
  scoresController.scoreById
);
router.post(
  "/createscore",
  authMiddleware.verifyToken,
  scoresController.createScore
);
router.post(
  "/updateScore",
  authMiddleware.verifyToken,
  scoresController.updateAvailableScore
);

/**
 * Evaluation Matrix
 */
router.post(
  "/evaluationMatrices",
  authMiddleware.verifyToken,
  evaluationMatrixController.matrices
);
router.post(
  "/evaluationMatricesById",
  authMiddleware.verifyToken,
  evaluationMatrixController.matrixById
);
router.post(
  "/createEvaluationMatrix",
  authMiddleware.verifyToken,
  evaluationMatrixController.createMatrix
);
router.post(
  "/updateEvaluationMatrix",
  authMiddleware.verifyToken,
  evaluationMatrixController.updateAvailableMatrix
);

/**
 * Evaluations
 */
router.post(
  "/evaluations",
  authMiddleware.verifyToken,
  evalluationcontoller.evaluations
);
router.post(
  "/evaluationById",
  authMiddleware.verifyToken,
  evalluationcontoller.evaluationById
);
router.post(
  "/hodEvaluations",
  authMiddleware.verifyToken,
  evalluationcontoller.evaluationForHod
);
router.post(
  "/myEvaluations",
  authMiddleware.verifyToken,
  evalluationcontoller.myEvaluations
);
router.post(
  "/sessionEvaluations",
  authMiddleware.verifyToken,
  evalluationcontoller.evaluationsForSession
);
router.post(
  "/createEvaluation",
  authMiddleware.verifyToken,
  evalluationcontoller.createEvaluation
);
router.post(
  "/updateEvaluation",
  authMiddleware.verifyToken,
  evalluationcontoller.updateAvailableUserEvaluation
);

/**
 * Recomendations
 */
router.post(
  "/dvcRecommendations",
  authMiddleware.verifyToken,
  evalluationcontoller.dvcRecomendEvaluation
);
router.post(
  "/vcRecommendations",
  authMiddleware.verifyToken,
  evalluationcontoller.vcRecomendEvaluation
);

// Reports evaluationEvaluatedGraphReport
router.post(
  "/evaluatedChartReport",
  authMiddleware.verifyToken,
  evalluationcontoller.evaluationEvaluatedGraphReport
);

router.post(
  "/exceedExpecChartReport",
  authMiddleware.verifyToken,
  evalluationcontoller.evaluationUsersExceGraphReport
);

router.post(
  "/meetExpecChartReport",
  authMiddleware.verifyToken,
  evalluationcontoller.evaluationUsersMetGraphReport
);

router.post(
  "/approachingExpecChartReport",
  authMiddleware.verifyToken,
  evalluationcontoller.evaluationUsersApproachingGraphReport
);

router.post(
  "/failedExpecChartReport",
  authMiddleware.verifyToken,
  evalluationcontoller.evaluationUsersFailedGraphReport
);

router.post(
  "/generalFacultyReport",
  authMiddleware.verifyToken,
  evalluationcontoller.evaluationGeneralFucultyGraphReport
);

/**Leave Starts Here */

// Leave Application
router.post(
  "/leaveType",
  authMiddleware.verifyToken,
  leaveController.allLeaveTypes
);

// Post Leave application

router.post(
  "/leaveApplication",
  authMiddleware.verifyToken,
  leaveController.createLeave
);

// my Leave history
router.post(
  "/getMyappliedLeaves",
  authMiddleware.verifyToken,
  leaveController.findMyLeaves
);

// All Leaves
router.post(
  "/allLeaves",
  authMiddleware.verifyToken,
  leaveController.allLeaves
);

// Leave by ID
router.post(
  "/leaveById",
  authMiddleware.verifyToken,
  leaveController.leaveById
);

// Get supervisors details
router.post(
  "/supervisors",
  authMiddleware.verifyToken,
  userController.findSupervisorsLeave
);

router.post(
  "/supervisorsHod",
  authMiddleware.verifyToken,
  userController.findSupervisorsLeaveHod
);

router.post(
  "/supervisorsDVC",
  authMiddleware.verifyToken,
  userController.findSupervisorsLeaveDvc
);

router.post(
  "/leaveAprrovalDVC",
  authMiddleware.verifyToken,
  leaveController.findDVCLeavesApproval
);

router.post(
  "/leaveAprrovalHod",
  authMiddleware.verifyToken,
  leaveController.findHodLeavesApproval
);

router.post(
  "/cloasedLeaveDVC",
  authMiddleware.verifyToken,
  leaveController.findDVCLeavesClosed
);

router.post(
  "/closedLeaveHod",
  authMiddleware.verifyToken,
  leaveController.findHodLeavesClosed
);

router.post(
  "/rejectedLeaveDVC",
  authMiddleware.verifyToken,
  leaveController.findDVCLeavesRejected
);

router.post(
  "/rejectedLeaveHod",
  authMiddleware.verifyToken,
  leaveController.findHodLeavesRejected
);

router.post(
  "/acceptLeaveRequest",
  authMiddleware.verifyToken,
  leaveController.acceptLeaveRequest
);

router.post(
  "/declineLeaveRequest",
  authMiddleware.verifyToken,
  leaveController.declineLeaveRequest
);

router.post(
  "/approveLeaveRequest",
  authMiddleware.verifyToken,
  leaveController.approveLeaveRequest
);

router.post(
  "/rejectLeaveRequest",
  authMiddleware.verifyToken,
  leaveController.rejectLeaveRequest
);

/**Reports
 * HOD Approved
 * HOD Accepted
 * HOD Declined
 * HOD Rejected
 * DVC Approved
 * DVC Rejected
 */
router.post(
  "/approvedLeaveReportHOD",
  authMiddleware.verifyToken,
  leaveController.findApprovedReportForHod
);
router.post(
  "/rejectedLeaveReportHOD",
  authMiddleware.verifyToken,
  leaveController.findRejectedReportForHod
);
router.post(
  "/acceptedLeaveReportHOD",
  authMiddleware.verifyToken,
  leaveController.findAcceptedReportForHod
);
router.post(
  "/declinedLeaveReportHOD",
  authMiddleware.verifyToken,
  leaveController.findDeclinedReportForHod
);
router.post(
  "/approvedLeaveReportDVC",
  authMiddleware.verifyToken,
  leaveController.findApprovedReportForDvc
);
router.post(
  "/rejectedLeaveReportDVC",
  authMiddleware.verifyToken,
  leaveController.findRejectedReportForDvc
);

/**Open reports for HR and VC */
router.post(
  "/openLeaveReports",
  authMiddleware.verifyToken,
  leaveController.findOpenLeavesReport
);
router.post(
  "/approvedLeaveReports",
  authMiddleware.verifyToken,
  leaveController.findApprovedLeavesReport
);
router.post(
  "/declinedLeaveReports",
  authMiddleware.verifyToken,
  leaveController.findDeclinedLeavesReport
);
router.post(
  "/rejectedLeaveReports",
  authMiddleware.verifyToken,
  leaveController.findRejectedLeavesReport
);
router.post(
  "/chartLeaveReports",
  authMiddleware.verifyToken,
  leaveController.findRejectedReportForDvc
);


/**ChartWise Report */
// LeaveType
router.post(
  "/chartWeeklyLeaveTypeReports",
  authMiddleware.verifyToken,
  leaveController.findWeeklyLeaveTypeGraph
);
router.post(
  "/chartMonthlyLeaveTypeReports",
  authMiddleware.verifyToken,
  leaveController.findMonthlyLeaveTypeGraph
);
//DepartmentWise

router.post(
  "/chartWeeklyDepartmentWiseReports",
  authMiddleware.verifyToken,
  leaveController.findWeeklyLeaveDepartmentGraph
);

router.post(
  "/chartMonthlyDepartmentWiseReports",
  authMiddleware.verifyToken,
  leaveController.findMothlyLeaveDepartmentGraph
);

/**
 * MOthly Report (JAN)
 */
router.post(
  "/januaryChartReports",
  authMiddleware.verifyToken,
  leaveController.findJanuaryGraph
);

/**
 * MOthly Report (FEB)
 */
router.post(
  "/februaryChartReports",
  authMiddleware.verifyToken,
  leaveController.findFebruaryGraph
);

/**
 * MOthly Report (MAR)
 */
router.post(
  "/marchChartReports",
  authMiddleware.verifyToken,
  leaveController.findMarchGraph
);

/**
 * MOthly Report (APRIL)
 */
router.post(
  "/aprilChartReports",
  authMiddleware.verifyToken,
  leaveController.findAprilGraph
);

/**
 * MOthly Report (MAY)
 */
router.post(
  "/mayChartReports",
  authMiddleware.verifyToken,
  leaveController.findMayGraph
);

/**
 * MOthly Report (JUNE)
 */
router.post(
  "/juneChartReports",
  authMiddleware.verifyToken,
  leaveController.findJuneGraph
);

/**
 * MOthly Report (JULY)
 */
router.post(
  "/julyChartReports",
  authMiddleware.verifyToken,
  leaveController.findJulyGraph
);

/**
 * MOthly Report (AUG)
 */
router.post(
  "/augustChartReports",
  authMiddleware.verifyToken,
  leaveController.findAugustGraph
);

/**
 * MOthly Report (SEP)
 */
router.post(
  "/septemberChartReports",
  authMiddleware.verifyToken,
  leaveController.findSeptemberGraph
);

/**
 * MOthly Report (OCT)
 */
router.post(
  "/octoberChartReports",
  authMiddleware.verifyToken,
  leaveController.findOctoberGraph
);

/**
 * MOthly Report (NOV)
 */
router.post(
  "/novemberChartReports",
  authMiddleware.verifyToken,
  leaveController.findNovemberGraph
);

/**
 * MOthly Report (DEC)
 */
router.post(
  "/decemberChartReports",
  authMiddleware.verifyToken,
  leaveController.findDecemberGraph
);

/**
 * Yearly Applied Report 
 */
router.post(
  "/appliedChartReports",
  authMiddleware.verifyToken,
  leaveController.findAppliedChatGraph
);

/**
 * Yearly Approved Report 
 */
router.post(
  "/approvedChartReports",
  authMiddleware.verifyToken,
  leaveController.findApprovedChatGraph
);

/**
 * Yearly Rejected Report 
 */
router.post(
  "/rejectedChartReports",
  authMiddleware.verifyToken,
  leaveController.findRejectedChatGraph
);
/**
 * All Users
 */
router.post(
  "/getAllUsers",
  authMiddleware.verifyToken,
  userController.findAllUsers
);
module.exports = router;