from flask.views import MethodView
from flask_smorest import Blueprint
from src.views.timetable.utils import TimetableManager, TimetableBlockManager, TimetableGenerator
from src.views.tutor.utils import TutorManager
from flask import request, current_app
from src.utils import custom_response

timetable_router = Blueprint("Timetable Management Routes", __name__)

@timetable_router.route("/timetable/blocks/<string:block_id>/room")
class TimetableBlockRoomRouter(MethodView):
    def __init__(self) -> None:
        self.tutor_manager = TutorManager()

    @timetable_router.response(status_code=200)
    def put(self, block_id):
        """Update the room for a timetable block"""
        try:
            data = request.get_json()
            room = data.get('room', '').strip()
            
            current_app.logger.info(f"Room update request - Block ID: {block_id}, Room: '{room}', Data: {data}")
            
            return self.tutor_manager.update_timetable_block_room(block_id, room)
        except Exception as e:
            current_app.logger.error(f"Error in room update route: {str(e)}", exc_info=True)
            return custom_response(
                success=False,
                data=f"Route error: {str(e)}",
                status_code=500
            )

@timetable_router.route("/timetables/email/share")
class TimetableEmailShareRouter(MethodView):
    def __init__(self) -> None:
        self.manager = TimetableManager()

    @timetable_router.response(status_code=200)
    def post(self):
        """Send timetable emails to tutors"""
        try:
            data = request.get_json()
            timetable_id = data.get('timetable_id')
            tutor_ids = data.get('tutor_ids', [])
            requester_id = data.get('requester_id')
            
            current_app.logger.info(f"Email share request received - Data: {data}")
            
            if not timetable_id or not requester_id:
                current_app.logger.error(f"Missing required fields - timetable_id: {timetable_id}, requester_id: {requester_id}")
                return custom_response(
                    success=False,
                    data="Missing required fields: timetable_id and requester_id",
                    status_code=400
                )
            
            current_app.logger.info(f"Email share request - Timetable: {timetable_id}, Tutors: {tutor_ids}, Requester: {requester_id}")
            
            return self.manager.send_timetable_emails_to_tutors(timetable_id, tutor_ids, requester_id)
        except Exception as e:
            current_app.logger.error(f"Error in email share route: {str(e)}", exc_info=True)
            return custom_response(
                success=False,
                data=f"Route error: {str(e)}",
                status_code=500
            )

@timetable_router.route("/timetables")
class TimetableRouter(MethodView):
    def __init__(self) -> None:
        self.manager = TimetableManager()

    @timetable_router.response(status_code=201)
    def post(self):
        """Create a new timetable"""
        payload = request.get_json()
        return self.manager.create(payload)

    @timetable_router.response(status_code=200)
    def get(self):
        """Get the active timetable"""
        semester = request.args.get('semester')
        academic_year = request.args.get('academic_year')
        return self.manager.get_active_timetable(semester, academic_year)

@timetable_router.route("/timetables")
class TimetableDeleteRouter(MethodView):
    def __init__(self) -> None:
        self.manager = TimetableManager()

    @timetable_router.response(status_code=200)
    def delete(self):
        """Delete a timetable using query parameters"""
        timetable_id = request.args.get('id')
        requester_id = request.args.get('requester_id')
        
        if not timetable_id:
            return custom_response(
                success=False,
                data="timetable id is required for deletion",
                status_code=400
            )
        
        if not requester_id:
            return custom_response(
                success=False,
                data="requester_id is required for deletion",
                status_code=400
            )
        
        return self.manager.delete(timetable_id, requester_id)

@timetable_router.route("/timetables/<string:timetable_id>")
class TimetableDetailRouter(MethodView):
    def __init__(self) -> None:
        self.manager = TimetableManager()

    @timetable_router.response(status_code=200)
    def get(self, timetable_id):
        """Get a specific timetable with optional filtering"""
        # Get query parameters for filtering
        speciality_id = request.args.get('speciality_id')
        year_level = request.args.get('year_level')
        term = request.args.get('term')
        academic_year = request.args.get('academic_year')
        tutor_id = request.args.get('tutor_id')
        search_term = request.args.get('search_term')
        
        filters = {
            'speciality_id': speciality_id,
            'year_level': year_level,
            'term': term,
            'academic_year': academic_year,
            'tutor_id': tutor_id,
            'search_term': search_term
        }
        
        return self.manager.get(timetable_id, filters)

    @timetable_router.response(status_code=200)
    def put(self, timetable_id):
        """Update a timetable"""
        payload = request.get_json()
        return self.manager.update(timetable_id, payload)

@timetable_router.route("/timetables/<string:timetable_id>/submit")
class TimetableSubmitRouter(MethodView):
    def __init__(self) -> None:
        self.manager = TimetableManager()

    @timetable_router.response(status_code=200)
    def post(self, timetable_id):
        """Submit a timetable for approval"""
        supervisor_id = request.get_json().get('supervisor_id')
        return self.manager.submit_for_approval(timetable_id, supervisor_id)

@timetable_router.route("/timetables/<string:timetable_id>/approve")
class TimetableApproveRouter(MethodView):
    def __init__(self) -> None:
        self.manager = TimetableManager()

    @timetable_router.response(status_code=200)
    def post(self, timetable_id):
        """Approve a timetable"""
        supervisor_id = request.get_json().get('supervisor_id')
        return self.manager.approve(timetable_id, supervisor_id)

@timetable_router.route("/timetables/<string:timetable_id>/approve-and-verify")
class TimetableApproveAndVerifyRouter(MethodView):
    def __init__(self) -> None:
        self.manager = TimetableManager()

    @timetable_router.response(status_code=200)
    def post(self, timetable_id):
        """Approve and verify a timetable in one action"""
        payload = request.get_json()
        supervisor_id = payload.get('supervisor_id')
        notes = payload.get('notes', '')
        return self.manager.approve_and_verify(timetable_id, supervisor_id, notes)

@timetable_router.route("/timetables/<string:timetable_id>/reject")
class TimetableRejectRouter(MethodView):
    def __init__(self) -> None:
        self.manager = TimetableManager()

    @timetable_router.response(status_code=200)
    def post(self, timetable_id):
        """Reject a timetable"""
        payload = request.get_json()
        return self.manager.reject(timetable_id, payload.get('supervisor_id'), payload.get('reason'))

@timetable_router.route("/timetables/<string:timetable_id>/disapprove")
class TimetableDisapproveRouter(MethodView):
    def __init__(self) -> None:
        self.manager = TimetableManager()

    @timetable_router.response(status_code=200)
    def post(self, timetable_id):
        """Disapprove a timetable (cancel teaching sessions)"""
        payload = request.get_json()
        return self.manager.disapprove(timetable_id, payload.get('supervisor_id'))

@timetable_router.route("/timetables/user/<string:user_id>")
class TimetableUserRouter(MethodView):
    def __init__(self) -> None:
        self.manager = TimetableManager()

    @timetable_router.response(status_code=200)
    def get(self, user_id):
        """Get timetables created by a specific user"""
        return self.manager.get_timetables_by_user(user_id)

@timetable_router.route("/timetables/supervisor/<string:supervisor_id>")
class TimetableSupervisorRouter(MethodView):
    def __init__(self) -> None:
        self.manager = TimetableManager()

    @timetable_router.response(status_code=200)
    def get(self, supervisor_id):
        """Get timetables for a supervisor"""
        return self.manager.get_timetables_for_supervisor(supervisor_id)

@timetable_router.route("/timetables/generate")
class TimetableGenerateRouter(MethodView):
    def __init__(self) -> None:
        self.manager = TimetableGenerator()

    @timetable_router.response(status_code=200)
    def post(self):
        """Generate a new timetable"""
        payload = request.get_json()

        return self.manager.generate_simple_timetable(
            timetable_name=payload.get('name', 'Generated Timetable'),
            semester=payload.get('semester'),
            academic_year=payload.get('academic_year'),
            created_by=payload.get('created_by'),
            year_level=payload.get('year_level'),
            supervisor_id=payload.get('supervisor_id')
        )

@timetable_router.route("/timetables/<string:timetable_id>/verify")
class TimetableVerifyRouter(MethodView):
    def __init__(self) -> None:
        self.manager = TimetableManager()

    @timetable_router.response(status_code=200)
    def post(self, timetable_id):
        """Verify a timetable and create teaching sessions"""
        payload = request.get_json()
        return self.manager.verify_timetable(timetable_id, payload)

@timetable_router.route("/timetables/verified")
class VerifiedTimetablesRouter(MethodView):
    def __init__(self) -> None:
        self.manager = TimetableManager()

    @timetable_router.response(status_code=200)
    def get(self):
        """Get all verified timetables for admin view"""
        return self.manager.get_verified_timetables()

@timetable_router.route("/timetables/verified/blocks")
class VerifiedTimetableBlocksRouter(MethodView):
    def __init__(self) -> None:
        self.manager = TimetableManager()

    @timetable_router.response(status_code=200)
    def get(self):
        """Get all blocks from active timetables for admin view"""
        return self.manager.get_all_active_timetable_blocks()

@timetable_router.route("/timetables/admin/all")
class AdminAllTimetablesRouter(MethodView):
    def __init__(self) -> None:
        self.manager = TimetableManager()

    @timetable_router.response(status_code=200)
    def get(self):
        """Get all timetables for admin management view"""
        return self.manager.get_all_timetables_for_admin()

@timetable_router.route("/timetables/debug/verified-count")
class DebugVerifiedCountRouter(MethodView):
    def __init__(self) -> None:
        self.manager = TimetableManager()

    @timetable_router.response(status_code=200)
    def get(self):
        """Debug endpoint to check verified timetables count"""
        return self.manager.debug_verified_count()

@timetable_router.route("/timetables/<string:timetable_id>/share-email")
class TimetableEmailShareRouter(MethodView):
    def __init__(self) -> None:
        self.manager = TimetableManager()

    @timetable_router.response(status_code=200)
    def post(self, timetable_id):
        """Share timetable via email to tutors"""
        payload = request.get_json()
        return self.manager.share_timetable_email(timetable_id, payload)

@timetable_router.route("/timetables/<string:timetable_id>/teaching-sessions")
class TeachingSessionsRouter(MethodView):
    def __init__(self) -> None:
        self.manager = TimetableManager()

    @timetable_router.response(status_code=200)
    def get(self, timetable_id):
        """Get teaching sessions for a timetable"""
        return self.manager.get_teaching_sessions(timetable_id)

@timetable_router.route("/timetables/<string:timetable_id>/create-sessions")
class CreateTeachingSessionsRouter(MethodView):
    def __init__(self) -> None:
        self.manager = TimetableManager()

    @timetable_router.response(status_code=200)
    def post(self, timetable_id):
        """Create teaching sessions from timetable blocks"""
        return self.manager.create_teaching_sessions(timetable_id)

@timetable_router.route("/timetables/block")
class TimetableBlockRouter(MethodView):
    def __init__(self) -> None:
        self.manager = TimetableBlockManager()

    @timetable_router.response(status_code=201)
    def post(self):
        """Create a new timetable block"""
        payload = request.get_json()
        return self.manager.create(payload)

@timetable_router.route("/timetables/block/<string:block_id>")
class TimetableBlockDetailRouter(MethodView):
    def __init__(self) -> None:
        self.manager = TimetableBlockManager()

    @timetable_router.response(status_code=200)
    def get(self, block_id):
        """Get a specific timetable block"""
        return self.manager.get(block_id)

    @timetable_router.response(status_code=200)
    def put(self, block_id):
        """Update a timetable block"""
        payload = request.get_json()
        return self.manager.update(block_id, payload)

    @timetable_router.response(status_code=200)
    def delete(self, block_id):
        """Delete a timetable block"""
        return self.manager.delete(block_id)

@timetable_router.route("/timetables/tutor/<string:tutor_id>/blocks")
class TimetableTutorBlocksRouter(MethodView):
    def __init__(self) -> None:
        self.manager = TimetableBlockManager()

    @timetable_router.response(status_code=200)
    def get(self, tutor_id):
        """Get timetable blocks for a tutor"""
        week_start = request.args.get('week_start')
        return self.manager.get_blocks_for_tutor(tutor_id, week_start)

@timetable_router.route("/timetables/<string:timetable_id>/pdf")
class TimetablePDFRouter(MethodView):
    def __init__(self) -> None:
        self.manager = TimetableManager()

    @timetable_router.response(status_code=200)
    def get(self, timetable_id):
        """Generate beautifully styled PDF for a timetable"""
        return self.manager.generate_pdf(timetable_id)

@timetable_router.route("/timetables/<string:timetable_id>/statistics")
class TimetableStatisticsRouter(MethodView):
    def __init__(self) -> None:
        self.manager = TimetableManager()

    @timetable_router.response(status_code=200)
    def get(self, timetable_id):
        """Get timetable statistics"""
        return self.manager.get_timetable_statistics(timetable_id)

@timetable_router.route("/timetables/<string:timetable_id>/export-pdf")
class TimetableExportPDFRouter(MethodView):
    def __init__(self) -> None:
        self.manager = TimetableManager()

    def get(self, timetable_id):
        """Export timetable as PDF with filters"""
        # Get filter parameters from query string
        export_type = request.args.get('export_type', 'full')
        speciality_id = request.args.get('speciality_id')
        year_level = request.args.get('year_level')
        term = request.args.get('term')
        academic_year = request.args.get('academic_year')
        tutor_id = request.args.get('tutor_id')
        search_term = request.args.get('search_term')
        
        # Create filters dict
        filters = {
            'export_type': export_type,
            'speciality_id': speciality_id,
            'year_level': year_level,
            'term': term,
            'academic_year': academic_year,
            'tutor_id': tutor_id,
            'search_term': search_term
        }
        
        return self.manager.export_pdf_with_filters(timetable_id, filters)

@timetable_router.route("/timetables/block/generate-from-availability")
class TimetableBlockGenerateRouter(MethodView):
    def __init__(self) -> None:
        self.manager = TimetableBlockManager()

    @timetable_router.response(status_code=201)
    def post(self):
        """Generate timetable blocks from tutor availability"""
        payload = request.get_json()
        return self.manager.generate_blocks_from_availability(
            payload.get('tutor_id'),
            payload.get('course_id'),
            payload.get('timetable_id')
        )

@timetable_router.route("/timetables/debug/departments")
class TimetableDebugDepartmentsRouter(MethodView):
    def __init__(self) -> None:
        self.manager = TimetableGenerator()

    @timetable_router.response(status_code=200)
    def get(self):
        """Debug endpoint to get all departments with timetables"""
        return self.manager.get_all_departments_with_timetables()

@timetable_router.route("/timetables/department/<string:department>/blocks/<user_id>")
class TimetableDepartmentBlocksRouter(MethodView):
    def __init__(self) -> None:
        self.manager = TimetableBlockManager()

    @timetable_router.response(status_code=200)
    def get(self, department, user_id):
        """Get timetable blocks for a specific department"""
        return self.manager.get_blocks_for_department(department, user_id)

@timetable_router.route("/timetables/student/<string:student_id>/blocks")
class StudentTimetableBlocksRouter(MethodView):
    def __init__(self) -> None:
        self.manager = TimetableManager()

    @timetable_router.response(status_code=200)
    def get(self, student_id):
        """Get timetable blocks filtered by student's enrolled specialities"""
        return self.manager.get_student_timetable_blocks(student_id)