from flask.views import MethodView
from flask_smorest import Blueprint
from src.views.tutor.utils import TutorManager
from flask import request, current_app
from src.models.schema import (
    TutorSchema,
    TutorAvailabilitySchema,
    TeachingSessionSchema,
    AttendanceSchema,
    TimetableSchema,
)
from src.utils import custom_response
from datetime import datetime

tutor_router = Blueprint("Tutor Management Routes", __name__, description="Operations related to tutor management")

@tutor_router.route("/tutors")
class TutorRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200, schema=TutorSchema(many=True))
    def get(self):
        """Get all tutors with pagination or all tutors if limit is specified"""
        page = request.args.get('page', 1, type=int)
        per_page = request.args.get('per_page', 10, type=int)
        limit = request.args.get('limit', None, type=int)
        filters = request.args.to_dict()
        
        # If limit is specified, fetch all tutors up to that limit
        if limit:
            return self.tutor_manager.fetchAllTutors(filters=filters)
        
        # Otherwise use pagination
        return self.tutor_manager.fetchAll(page=page, per_page=per_page, filters=filters)

@tutor_router.route("/tutors/all")
class AllTutorsRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200, schema=TutorSchema(many=True))
    def get(self):
        """Get all tutors without pagination for dropdown/search purposes"""
        filters = request.args.to_dict()
        return self.tutor_manager.fetchAllTutors(filters=filters)

@tutor_router.route("/tutors/department/<string:department>/simple")
class TutorsByDepartmentSimpleRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200, schema=TutorSchema(many=True))
    def get(self, department: str):
        """Get all tutors in a specific department with simplified response"""
        return self.tutor_manager.get_tutors_by_department_simple(department)

@tutor_router.route("/tutors/department/<string:department>")
class TutorsByDepartmentRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200, schema=TutorSchema(many=True))
    def get(self, department: str):
        """Get all tutors in a specific department"""
        return self.tutor_manager.get_tutors_by_department(department)

@tutor_router.route("/tutors/department/<string:department>/detailed")
class TutorsByDepartmentDetailedRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200, schema=TutorSchema(many=True))
    def get(self, department: str):
        """Get all tutors in a specific department with detailed information for supervisor dashboard"""
        return self.tutor_manager.get_tutors_by_department_detailed(department)

@tutor_router.route("/tutors/available")
class AvailableTutorsRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200, schema=TutorSchema(many=True))
    def get(self):
        """Get all available tutors (not on leave and with availability)"""
        department = request.args.get('department')
        return self.tutor_manager.get_available_tutors(department)

@tutor_router.route("/tutors/statistics")
class TutorStatisticsRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def get(self):
        """Get comprehensive statistics about all tutors"""
        return self.tutor_manager.get_tutor_statistics()

@tutor_router.route("/tutors/search")
class TutorSearchRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200, schema=TutorSchema(many=True))
    def get(self):
        """Advanced search for tutors with multiple criteria"""
        search_query = request.args.get('q', '')
        filters = request.args.to_dict()
        # Remove the search query from filters
        if 'q' in filters:
            del filters['q']
        return self.tutor_manager.search_tutors(search_query, filters)

@tutor_router.route("/tutors/search-simple")
class TutorSimpleSearchRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200, schema=TutorSchema(many=True))
    def get(self):
        """Simple search for tutors by name - optimized for course creation forms"""
        name_query = request.args.get('name', '')
        limit = request.args.get('limit', 20, type=int)
        return self.tutor_manager.search_tutors_by_name_simple(name_query, limit)

@tutor_router.route("/tutors/by-ids")
class TutorsByIdsRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200, schema=TutorSchema(many=True))
    def get(self):
        """Get tutor details by a list of IDs"""
        tutor_ids = request.args.getlist('ids')
        return self.tutor_manager.get_tutors_by_ids(tutor_ids)

@tutor_router.route("/tutors/cleanup-datetime", methods=["POST"])
class TutorCleanupRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def post(self):
        """Clean up corrupted datetime data in the database"""
        return self.tutor_manager.cleanup_corrupted_datetime_data()

@tutor_router.route("/tutors/test-basic")
class TutorTestRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def get(self):
        """Test basic tutor fetching without complex queries"""
        return self.tutor_manager.test_basic_tutor_fetch()

@tutor_router.route("/tutors/debug-issues")
class TutorDebugRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def get(self):
        """Debug method to identify problematic tutor data"""
        return self.tutor_manager.debug_tutor_data_issues()

@tutor_router.route("/tutors/debug-departments")
class TutorDepartmentsDebugRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def get(self):
        """Debug method to check department data structure"""
        return self.tutor_manager.debug_departments_structure()

@tutor_router.route("/tutors/test-endpoint")
class TutorTestEndpointRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def get(self):
        """Test endpoint to verify API is working"""
        return custom_response(
            success=True,
            data={"message": "Tutor API is working", "timestamp": str(datetime.utcnow())},
            status_code=200
        )

@tutor_router.route("/tutors/<string:tutor_id>")
class TutorDetailRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200, schema=TutorSchema)
    def get(self, tutor_id):
        """Get a tutor by ID"""
        return self.tutor_manager.get(tutor_id)

    @tutor_router.response(status_code=200)
    def put(self, tutor_id):
        """Update a tutor"""
        payload = request.get_json()
        return self.tutor_manager.update(tutor_id, payload)

@tutor_router.route("/tutors/<string:tutor_id>/details")
class TutorDetailedAnalyticsRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def get(self, tutor_id: str):
        """Get comprehensive tutor analytics and detailed information"""
        return self.tutor_manager.get_tutor_detailed_analytics(tutor_id)

    @tutor_router.response(status_code=204)
    def delete(self, tutor_id):
        """Deactivate a tutor"""
        return self.tutor_manager.delete(tutor_id)
    


@tutor_router.route("/tutors/courses/<string:tutor_id>")
class TutorCourseDetailRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200, schema=TutorSchema)
    def get(self, tutor_id):
        """Get courses taught by a tutor"""
        return self.tutor_manager.get_tutor_courses_with_details(tutor_id)

@tutor_router.route("/users/courses/<string:user_id>")
class UserCoursesRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def get(self, user_id):
        """Get courses for any user (tutor or supervisor)"""
        return self.tutor_manager.get_user_courses(user_id)
    

@tutor_router.route("/tutor/students/<string:tutor_id>")
class TutorCourseDetailRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200, schema=TutorSchema)
    def get(self, tutor_id):
        """Get a tutor by ID"""
        return self.tutor_manager.get_tutor_students_with_details(tutor_id)
    
@tutor_router.route("/tutors/<string:tutor_id>/sessions/upcoming")
class TutorUpcomingSessionsRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200, schema=TeachingSessionSchema(many=True))
    def get(self, tutor_id):
        """Get upcoming sessions for a tutor"""
        days_ahead = request.args.get('days_ahead', 7, type=int)
        return self.tutor_manager.get_upcoming_sessions(tutor_id, days_ahead)


@tutor_router.route("/tutor/course/stats/<string:supervisor_id>")
class TutorStatsRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    def get(self, supervisor_id):
        return self.tutor_manager.get_supervised_tutors_with_stats(supervisor_id=supervisor_id)


@tutor_router.route("/tutors/course/stats/<string:supervisor_id>")
class TutorsStatsRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    def get(self, supervisor_id):
        """Get supervised tutors with statistics for a supervisor"""
        return self.tutor_manager.get_supervised_tutors_with_stats(supervisor_id=supervisor_id)



@tutor_router.route("/tutors/<string:tutor_id>/sessions/past")
class TutorPastSessionsRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200, schema=TeachingSessionSchema(many=True))
    def get(self, tutor_id):
        """Get past sessions for a tutor"""
        days_back = request.args.get('days_back', 30, type=int)
        return self.tutor_manager.get_past_sessions(tutor_id, days_back)

@tutor_router.route("/tutors/<string:tutor_id>/sessions/record", methods=["POST"])
class TutorRecordSessionRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.arguments(schema=TeachingSessionSchema, location='json')
    @tutor_router.response(status_code=200)
    def post(self, payload, tutor_id):
        """Record teaching session details (check-in/check-out)"""
        session_id = payload.get('session_id')
        return self.tutor_manager.record_teaching_session(tutor_id, session_id, payload)

@tutor_router.route("/tutors/<string:tutor_id>/sessions/verify", methods=["POST"])
class TutorVerifySessionRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.arguments(schema=TeachingSessionSchema, location='json')
    @tutor_router.response(status_code=200)
    def post(self, payload, tutor_id):
        """Verify a teaching session"""
        session_id = payload.get('session_id')
        return self.tutor_manager.verify_teaching_session(tutor_id, session_id, payload)

@tutor_router.route("/tutors/<string:tutor_id>/logs")
class TutorTeachingLogsRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def get(self, tutor_id):
        """Get teaching logs for a tutor"""
        page = request.args.get('page', 1, type=int)
        per_page = request.args.get('per_page', 10, type=int)
        return self.tutor_manager.get_teaching_logs(tutor_id, page, per_page)

@tutor_router.route("/tutors/<string:tutor_id>/availability")
class TutorAvailabilityRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200, schema=TutorAvailabilitySchema(many=True))
    def get(self, tutor_id):
        """Get tutor availability"""
        return self.tutor_manager.get_availability(tutor_id)

    @tutor_router.arguments(schema=TutorAvailabilitySchema(many=True), location='json')
    @tutor_router.response(status_code=200)
    def put(self, payload, tutor_id):
        """Update tutor availability"""
        return self.tutor_manager.update_availability(tutor_id, payload)

@tutor_router.route("/tutors/<string:tutor_id>/availability/<string:availability_id>")
class TutorSingleAvailabilityRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200, schema=TutorAvailabilitySchema)
    def get(self, tutor_id, availability_id):
        """Get a specific availability slot"""
        return self.tutor_manager.get_single_availability(tutor_id, availability_id)

    @tutor_router.arguments(schema=TutorAvailabilitySchema, location='json')
    @tutor_router.response(status_code=200)
    def put(self, payload, tutor_id, availability_id):
        """Update a specific availability slot"""
        return self.tutor_manager.update_single_availability(tutor_id, availability_id, payload)

    @tutor_router.response(status_code=204)
    def delete(self, tutor_id, availability_id):
        """Delete a specific availability slot"""
        return self.tutor_manager.delete_availability(tutor_id, availability_id)

@tutor_router.route("/tutors/<string:tutor_id>/availability/<string:availability_id>/cancel")
class TutorAvailabilityCancelRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def post(self, tutor_id, availability_id):
        """Cancel an availability slot with reason"""
        payload = request.get_json()
        reason = payload.get('reason', 'No reason provided')
        return self.tutor_manager.cancel_availability(tutor_id, availability_id, reason)

@tutor_router.route("/tutors/availability/<string:availability_id>")
class TutorAvailabilityUpdateRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.arguments(schema=TutorAvailabilitySchema, location='json')
    @tutor_router.response(status_code=200)
    def put(self, payload, availability_id):
        """Update a specific availability slot (alternative route)"""
        # Extract tutor_id from the availability record
        return self.tutor_manager.update_availability_by_id(availability_id, payload)

@tutor_router.route("/tutors/<string:tutor_id>/statistics")
class TutorStatisticsRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def get(self, tutor_id):
        """Get teaching statistics for a tutor"""
        period = request.args.get('period', 'month')
        return self.tutor_manager.get_teaching_statistics(tutor_id, period)

@tutor_router.route("/tutors/<string:tutor_id>/supervisor")
class TutorSupervisorRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def get(self, tutor_id):
        """Get supervisor information for a tutor"""
        return self.tutor_manager.get_supervisor(tutor_id)

@tutor_router.route("/tutors/<string:tutor_id>/leave", methods=["POST", "DELETE"])
class TutorLeaveRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def post(self, tutor_id):
        """Request leave as a tutor"""
        payload = request.get_json()
        return self.tutor_manager.request_leave(tutor_id, payload)

    @tutor_router.response(status_code=200)
    def delete(self, tutor_id):
        """Cancel active leave for a tutor"""
        return self.tutor_manager.cancel_leave(tutor_id)

@tutor_router.route("/tutors/<string:tutor_id>/leave/status")
class TutorLeaveStatusRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def get(self, tutor_id):
        """Get current leave status for a tutor"""
        return self.tutor_manager.get_leave_status(tutor_id)

@tutor_router.route("/tutors/<string:tutor_id>/availability")
class TutorAvailabilityRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200, schema=TimetableSchema)
    def get(self, tutor_id):
        """Get tutor's personal availability - only blocks where they are teaching"""
        week_start = request.args.get('week_start')
        return self.tutor_manager.get_tutor_availability(tutor_id, week_start)

@tutor_router.route("/tutors/<string:tutor_id>/timetable")
class TutorTimetableRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200, schema=TimetableSchema)
    def get(self, tutor_id):
        """Get weekly timetable for a tutor - personal schedule only"""
        return self.tutor_manager.get_tutor_approved_timetable(tutor_id)

@tutor_router.route("/tutors/<string:tutor_id>/department-timetable")
class TutorDepartmentTimetableRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200, schema=TimetableSchema)
    def get(self, tutor_id):
        """Get weekly department timetable for a tutor - all department courses"""
        week_start = request.args.get('week_start')
        return self.tutor_manager.get_timetable(tutor_id, week_start)

@tutor_router.route("/tutors/<string:tutor_id>/attendance")
class TutorAttendanceRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200, schema=AttendanceSchema(many=True))
    def get(self, tutor_id):
        """Get attendance records for a tutor's sessions"""
        session_id = request.args.get('session_id')
        page = request.args.get('page', 1, type=int)
        per_page = request.args.get('per_page', 20, type=int)
        return self.tutor_manager.get_attendance_records(tutor_id, session_id, page, per_page)

    @tutor_router.arguments(schema=AttendanceSchema, location='json')
    @tutor_router.response(status_code=200)
    def put(self, payload, tutor_id):
        """Update an attendance record"""
        attendance_id = payload.get('attendance_id')
        return self.tutor_manager.update_attendance_record(tutor_id, attendance_id, payload)

@tutor_router.route("/tutors/<string:tutor_id>/students")
class TutorStudentsRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def get(self, tutor_id):
        """Get students taught by a tutor"""
        course_id = request.args.get('course_id')
        return self.tutor_manager.get_students(tutor_id, course_id)

@tutor_router.route("/tutors/<string:tutor_id>/analytics")
class TutorAnalyticsRouter(MethodView):
    def __init__(self) -> None:
        from src.views.exam_portfolio.utils import ExamPortfolioManager
        self.exam_manager = ExamPortfolioManager()

    @tutor_router.response(status_code=200)
    def get(self, tutor_id):
        """Get exam analytics for a tutor"""
        timeframe = request.args.get('timeframe', 'all', type=str)
        course_id = request.args.get('course_id', type=str)
        return self.exam_manager.get_exam_analytics(tutor_id, 'tutor', timeframe, course_id)

@tutor_router.route("/tutors/<string:tutor_id>/students-analytics")
class TutorStudentsAnalyticsRouter(MethodView):
    def __init__(self) -> None:
        from src.views.exam_portfolio.utils import ExamPortfolioManager
        self.exam_manager = ExamPortfolioManager()

    @tutor_router.response(status_code=200)
    def get(self, tutor_id):
        """Get student analytics for a tutor"""
        timeframe = request.args.get('timeframe', 'all', type=str)
        return self.exam_manager.get_students_analytics(tutor_id, 'tutor', timeframe)

@tutor_router.route("/tutors/<string:tutor_id>/students/<string:student_id>/progress")
class TutorStudentProgressRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    def get(self, tutor_id, student_id):
        """Get progress for a specific student"""
        course_id = request.args.get('course_id')
        return self.tutor_manager.get_student_progress(tutor_id, student_id, course_id)

@tutor_router.route("/tutors/<string:tutor_id>/courses")
class TutorCoursesRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def get(self, tutor_id):
        """Get courses associated with a tutor"""
        return self.tutor_manager.get_courses(tutor_id)

    @tutor_router.response(status_code=200)
    def post(self, tutor_id):
        """Assign a course to a tutor"""
        payload = request.get_json()
        return self.tutor_manager.assign_course(tutor_id, payload)

    @tutor_router.response(status_code=200)
    def delete(self, tutor_id):
        """Remove a course from a tutor"""
        payload = request.get_json()
        return self.tutor_manager.remove_course(tutor_id, payload)

@tutor_router.route("/tutors/<string:tutor_id>/departments")
class TutorDepartmentRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def get(self, tutor_id):
        """Get all departments for a tutor"""
        return self.tutor_manager.get_tutor_departments(tutor_id)

    @tutor_router.response(status_code=201)
    def post(self, tutor_id):
        """Add a department to a tutor"""
        payload = request.get_json()
        return self.tutor_manager.add_department_to_tutor(tutor_id, payload)

@tutor_router.route("/tutors/<string:tutor_id>/departments/<string:department_id>")
class TutorDepartmentDetailRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def put(self, tutor_id, department_id):
        """Update a department assignment for a tutor"""
        payload = request.get_json()
        return self.tutor_manager.update_tutor_department(tutor_id, department_id, payload)

    @tutor_router.response(status_code=204)
    def delete(self, tutor_id, department_id):
        """Remove a department from a tutor"""
        return self.tutor_manager.remove_department_from_tutor(tutor_id, department_id)

@tutor_router.route("/tutors/<string:tutor_id>/departments/remove-by-name")
class TutorDepartmentRemoveByNameRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def post(self, tutor_id):
        """Remove a department from a tutor by department name"""
        payload = request.get_json()
        department_name = payload.get('department_name')
        
        if not department_name:
            return custom_response(
                success=False,
                data="Department name is required",
                status_code=400
            )
        
        return self.tutor_manager.remove_department_by_name(tutor_id, department_name)

@tutor_router.route("/tutors/<string:tutor_id>/departments/bulk-remove")
class TutorDepartmentBulkRemoveRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def post(self, tutor_id):
        """Remove multiple departments from a tutor"""
        payload = request.get_json()
        department_names = payload.get('department_names', [])
        
        if not department_names or not isinstance(department_names, list):
            return custom_response(
                success=False,
                data="Department names list is required",
                status_code=400
            )
        
        return self.tutor_manager.bulk_remove_departments(tutor_id, department_names)

@tutor_router.route("/tutors/departments/<string:department_id>/permanent-delete")
class TutorDepartmentPermanentDeleteRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def delete(self, department_id):
        """Permanently delete a department assignment"""
        return self.tutor_manager.delete_department_permanently(department_id)

@tutor_router.route("/tutor/performance/<string:tutor_id>")
class TutorPerformanceRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def get(self, tutor_id):
        """Get comprehensive performance data for a specific tutor"""
        return self.tutor_manager.get_tutor_performance(tutor_id)

@tutor_router.route("/tutors/workload/<string:supervisor_id>")
class TutorWorkloadRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    def get(self, supervisor_id):
        """Get tutor workload data filtered by supervisor_id"""
        return self.tutor_manager.get_tutor_workload_by_supervisor(supervisor_id)

@tutor_router.route("/tutors/<string:tutor_id>/workload/detailed")
class TutorDetailedWorkloadRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    def get(self, tutor_id):
        """Get comprehensive detailed workload breakdown for a specific tutor"""
        supervisor_id = request.args.get('supervisor_id', None)
        return self.tutor_manager.get_detailed_tutor_workload(tutor_id, supervisor_id)

@tutor_router.route("/tutors/migrate-department")
class TutorDepartmentMigrationRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def post(self):
        """Bulk migrate tutors from one department to another"""
        payload = request.get_json()
        old_department = payload.get('old_department')
        new_department = payload.get('new_department')
        assigned_by = payload.get('assigned_by')
        
        if not old_department or not new_department:
            return custom_response(
                success=False,
                data="Both old_department and new_department are required",
                status_code=400
            )
        
        return self.tutor_manager.bulk_update_department_assignment(
            old_department=old_department,
            new_department=new_department,
            assigned_by=assigned_by
        )

@tutor_router.route("/tutors/migrate-business-to-computing")
class BusinessToComputingMigrationRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def post(self):
        """Migrate tutors from Business Administration to Computing and Informatics"""
        payload = request.get_json()
        assigned_by = payload.get('assigned_by') if payload else None
        
        return self.tutor_manager.migrate_business_admin_to_computing(assigned_by=assigned_by)

@tutor_router.route("/user-management/tutors/workload")
class TutorWorkloadRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def get(self):
        """Get workload information for all tutors based on course credits"""
        return self.tutor_manager.get_tutors_workload()

    @tutor_router.response(status_code=200)
    def put(self):
        """Update tutor workload assignments"""
        payload = request.get_json()
        return self.tutor_manager.update_tutor_workload(payload)

@tutor_router.route("/user-management/tutors/workload/by-department")
class TutorWorkloadByDepartmentRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def get(self):
        """Get workload information grouped by department"""
        department = request.args.get('department')
        return self.tutor_manager.get_workload_by_department(department)

@tutor_router.route("/user-management/tutors/workload/summary")
class TutorWorkloadSummaryRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def get(self):
        """Get workload summary and analytics"""
        return self.tutor_manager.get_workload_summary()

@tutor_router.route("/user-management/tutors/workload/alerts")
class TutorWorkloadAlertsRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def get(self):
        """Get workload alerts and recommendations"""
        return self.tutor_manager.get_workload_alerts()

@tutor_router.route("/user-management/tutors/attendance")
class TutorAttendanceRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def get(self):
        """Get attendance information for all tutors"""
        return self.tutor_manager.get_tutors_attendance()

    @tutor_router.response(status_code=200)
    def post(self):
        """Record tutor attendance for a session"""
        payload = request.get_json()
        return self.tutor_manager.record_tutor_attendance(payload)

    @tutor_router.response(status_code=200)
    def put(self):
        """Update tutor attendance record"""
        payload = request.get_json()
        return self.tutor_manager.update_tutor_attendance(payload)

@tutor_router.route("/user-management/tutors/attendance/summary")
class TutorAttendanceSummaryRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def get(self):
        """Get attendance summary and analytics"""
        return self.tutor_manager.get_attendance_summary()

@tutor_router.route("/user-management/tutors/attendance/by-department")
class TutorAttendanceByDepartmentRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def get(self):
        """Get attendance information grouped by department"""
        department = request.args.get('department')
        return self.tutor_manager.get_attendance_by_department(department)

@tutor_router.route("/user-management/tutors/attendance/trends")
class TutorAttendanceTrendsRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def get(self):
        """Get attendance trends over time"""
        period = request.args.get('period', 'week')
        return self.tutor_manager.get_attendance_trends(period)

@tutor_router.route("/user-management/tutors/attendance/alerts")
class TutorAttendanceAlertsRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def get(self):
        """Get attendance alerts and recommendations"""
        return self.tutor_manager.get_attendance_alerts()

@tutor_router.route("/tutors/<string:tutor_id>/courses/workload")
class TutorCoursesWorkloadRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def get(self, tutor_id):
        """Get courses with workload information for a tutor"""
        return self.tutor_manager.get_tutor_courses_workload(tutor_id)

@tutor_router.route("/tutors/<string:tutor_id>/daily-teaching-sessions")
class TutorDailyTeachingSessionsRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def get(self, tutor_id):
        """Get all daily teaching sessions for a tutor"""
        return self.tutor_manager.get_daily_teaching_sessions(tutor_id)

@tutor_router.route("/tutors/<string:tutor_id>/teaching-sessions")
class TutorTeachingSessionsRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def get(self, tutor_id):
        """Get teaching sessions for verification"""
        return self.tutor_manager.get_teaching_sessions_for_verification(tutor_id)

@tutor_router.route("/teaching-sessions/<string:session_id>/verify", methods=["PATCH"])
class TeachingSessionVerifyRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def patch(self, session_id):
        """Verify or update verification for a teaching session"""
        payload = request.get_json()
        return self.tutor_manager.verify_teaching_session_by_id(session_id, payload)

@tutor_router.route("/tutors/<string:tutor_id>/timetable-blocks")
class TutorTimetableBlocksRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @tutor_router.response(status_code=200)
    def get(self, tutor_id):
        """Get approved timetable blocks for a tutor"""
        return self.tutor_manager.get_tutor_timetable_blocks(tutor_id)