from flask.views import MethodView
from flask_smorest import Blueprint
from src.views.quiz.utils import QuizManager
from src.views.quiz.security_utils import QuizSecurityManager
from flask import request, current_app

quiz_router = Blueprint("Quiz Management Routes", __name__, description="Operations on quizzes")

@quiz_router.route("/courses/<string:course_id>/quizzes")
class CourseQuizzesRouter(MethodView):
    def __init__(self) -> None:
        self.quiz_manager = QuizManager()

    def get(self, course_id):
        """Get all quizzes for a course"""
        requester_id = request.args.get('requester_id', type=str)
        requester_type = request.args.get('requester_type', type=str)
        
        if not requester_id or not requester_type:
            return {"message": "requester_id and requester_type parameters are required"}, 400
            
        return self.quiz_manager.get_course_quizzes(course_id, requester_id, requester_type)

    def post(self, course_id):
        """Create a new quiz for a course"""
        payload = request.get_json()
        requester_id = request.args.get('requester_id', type=str)
        requester_type = request.args.get('requester_type', type=str)
        
        if not requester_id or not requester_type:
            return {"message": "requester_id and requester_type parameters are required"}, 400
        
        payload['course_id'] = course_id
        payload['requester_id'] = requester_id
        payload['requester_type'] = requester_type
        
        return self.quiz_manager.create_quiz(payload)

@quiz_router.route("/quizzes/<string:quiz_id>")
class QuizDetailRouter(MethodView):
    def __init__(self) -> None:
        self.quiz_manager = QuizManager()

    def get(self, quiz_id):
        """Get quiz details"""
        requester_id = request.args.get('requester_id', type=str)
        requester_type = request.args.get('requester_type', type=str)
        
        if not requester_id or not requester_type:
            return {"message": "requester_id and requester_type parameters are required"}, 400
            
        return self.quiz_manager.get_quiz(quiz_id, requester_id, requester_type)

    def put(self, quiz_id):
        """Update quiz details"""
        payload = request.get_json()
        requester_id = request.args.get('requester_id', type=str)
        requester_type = request.args.get('requester_type', type=str)
        
        if not requester_id or not requester_type:
            return {"message": "requester_id and requester_type parameters are required"}, 400
        
        payload['requester_id'] = requester_id
        payload['requester_type'] = requester_type
        
        return self.quiz_manager.update_quiz(quiz_id, payload)

    def delete(self, quiz_id):
        """Delete a quiz"""
        requester_id = request.args.get('requester_id', type=str)
        requester_type = request.args.get('requester_type', type=str)
        
        if not requester_id or not requester_type:
            return {"message": "requester_id and requester_type parameters are required"}, 400
            
        return self.quiz_manager.delete_quiz(quiz_id, requester_id, requester_type)

@quiz_router.route("/quizzes/<string:quiz_id>/questions")
class QuizQuestionsRouter(MethodView):
    def __init__(self) -> None:
        self.quiz_manager = QuizManager()

    def get(self, quiz_id):
        """Get all questions for a quiz"""
        requester_id = request.args.get('requester_id', type=str)
        requester_type = request.args.get('requester_type', type=str)
        
        if not requester_id or not requester_type:
            return {"message": "requester_id and requester_type parameters are required"}, 400
            
        return self.quiz_manager.get_quiz_questions(quiz_id, requester_id, requester_type)

    def post(self, quiz_id):
        """Add a question to a quiz"""
        payload = request.get_json()
        requester_id = request.args.get('requester_id', type=str)
        requester_type = request.args.get('requester_type', type=str)
        
        if not requester_id or not requester_type:
            return {"message": "requester_id and requester_type parameters are required"}, 400
        
        payload['quiz_id'] = quiz_id
        payload['requester_id'] = requester_id
        payload['requester_type'] = requester_type
        
        return self.quiz_manager.add_question(payload)

@quiz_router.route("/quizzes/questions/<string:question_id>")
class QuizQuestionDetailRouter(MethodView):
    def __init__(self) -> None:
        self.quiz_manager = QuizManager()

    def put(self, question_id):
        """Update a question"""
        payload = request.get_json()
        requester_id = request.args.get('requester_id', type=str)
        requester_type = request.args.get('requester_type', type=str)
        
        if not requester_id or not requester_type:
            return {"message": "requester_id and requester_type parameters are required"}, 400
        
        payload['requester_id'] = requester_id
        payload['requester_type'] = requester_type
        
        return self.quiz_manager.update_question(question_id, payload)

    def delete(self, question_id):
        """Delete a question"""
        requester_id = request.args.get('requester_id', type=str)
        requester_type = request.args.get('requester_type', type=str)
        
        if not requester_id or not requester_type:
            return {"message": "requester_id and requester_type parameters are required"}, 400
            
        return self.quiz_manager.delete_question(question_id, requester_id, requester_type)

@quiz_router.route("/quizzes/<string:quiz_id>/start-attempt")
class QuizStartAttemptRouter(MethodView):
    def __init__(self) -> None:
        self.quiz_manager = QuizManager()

    def post(self, quiz_id):
        """Start a new quiz attempt (Student only)"""
        payload = request.get_json()
        student_id = request.args.get('student_id', type=str) or payload.get('student_id')
        
        if not student_id:
            return {"message": "student_id parameter is required"}, 400
        
        return self.quiz_manager.start_quiz_attempt(quiz_id, student_id)

@quiz_router.route("/quizzes/<string:quiz_id>/submit")
class QuizSubmissionRouter(MethodView):
    def __init__(self) -> None:
        self.quiz_manager = QuizManager()

    def post(self, quiz_id):
        """Submit quiz answers (Student only)"""
        payload = request.get_json()
        student_id = request.args.get('student_id', type=str)
        
        if not student_id:
            return {"message": "student_id parameter is required"}, 400
        
        answers = payload.get('answers', [])
        return self.quiz_manager.submit_quiz(quiz_id, student_id, answers)

@quiz_router.route("/quiz-security/log")
class QuizSecurityLogRouter(MethodView):
    def __init__(self) -> None:
        self.security_manager = QuizSecurityManager()

    def post(self):
        """Log a security event during quiz attempt"""
        payload = request.get_json()
        return self.security_manager.log_security_event(payload)

@quiz_router.route("/quiz-security/screenshot")
class QuizScreenshotRouter(MethodView):
    def __init__(self) -> None:
        self.security_manager = QuizSecurityManager()

    def post(self):
        """Upload quiz screenshot"""
        try:
            current_app.logger.info(f"📸 Screenshot upload request received")
            current_app.logger.info(f"Form data: {request.form.keys()}")
            current_app.logger.info(f"Files: {request.files.keys()}")
            
            attempt_id = request.form.get('attempt_id')
            student_id = request.form.get('student_id')
            quiz_id = request.form.get('quiz_id')
            
            current_app.logger.info(f"Attempt: {attempt_id}, Student: {student_id}, Quiz: {quiz_id}")
            
            if not all([attempt_id, student_id, quiz_id]):
                return {"success": False, "message": "attempt_id, student_id, and quiz_id are required"}, 400
            
            # Get screenshot from form data or JSON
            if 'screenshot' in request.files:
                screenshot = request.files['screenshot']
                current_app.logger.info(f"Screenshot file received: {screenshot.filename}, size: {screenshot.content_length}")
            elif 'screenshot_data' in request.form:
                screenshot = request.form.get('screenshot_data')
                current_app.logger.info(f"Screenshot data received (base64)")
            else:
                return {"success": False, "message": "screenshot file or screenshot_data is required"}, 400
            
            return self.security_manager.upload_screenshot(attempt_id, student_id, quiz_id, screenshot)
            
        except Exception as e:
            import traceback
            current_app.logger.error(f"Error in screenshot upload endpoint: {str(e)}")
            current_app.logger.error(traceback.format_exc())
            return {"success": False, "message": f"Error: {str(e)}"}, 500

@quiz_router.route("/quiz-security/violations/<string:attempt_id>")
class QuizViolationsRouter(MethodView):
    def __init__(self) -> None:
        self.security_manager = QuizSecurityManager()

    def get(self, attempt_id):
        """Get violation count for an attempt"""
        return self.security_manager.get_violation_count(attempt_id)

@quiz_router.route("/quiz-security/summary/<string:attempt_id>")
class QuizSecuritySummaryRouter(MethodView):
    def __init__(self) -> None:
        self.security_manager = QuizSecurityManager()

    def get(self, attempt_id):
        """Get security summary for an attempt"""
        return self.security_manager.get_attempt_security_summary(attempt_id)

@quiz_router.route("/quiz-security/webcam")
class QuizWebcamRouter(MethodView):
    def __init__(self) -> None:
        self.security_manager = QuizSecurityManager()

    def post(self):
        """Upload webcam video chunk"""
        try:
            current_app.logger.info(f"🎥 Webcam video upload request received")
            
            attempt_id = request.form.get('attempt_id')
            student_id = request.form.get('student_id')
            quiz_id = request.form.get('quiz_id')
            
            if not all([attempt_id, student_id, quiz_id]):
                return {"success": False, "message": "attempt_id, student_id, and quiz_id are required"}, 400
            
            # Get video file
            if 'video' in request.files:
                video_file = request.files['video']
                current_app.logger.info(f"Video chunk received: {video_file.filename}")
            elif 'video_data' in request.form:
                video_file = request.form.get('video_data')
                current_app.logger.info(f"Video data received (base64)")
            else:
                return {"success": False, "message": "video file or video_data is required"}, 400
            
            return self.security_manager.upload_webcam_video(attempt_id, student_id, quiz_id, video_file)
            
        except Exception as e:
            import traceback
            current_app.logger.error(f"Error in webcam upload endpoint: {str(e)}")
            current_app.logger.error(traceback.format_exc())
            return {"success": False, "message": f"Error: {str(e)}"}, 500

@quiz_router.route("/quiz-security/webcam/<string:attempt_id>/stop")
class QuizWebcamStopRouter(MethodView):
    def __init__(self) -> None:
        self.security_manager = QuizSecurityManager()

    def post(self, attempt_id):
        """Stop webcam recording"""
        return self.security_manager.stop_webcam_recording(attempt_id)

@quiz_router.route("/quiz-security/upload-evidence")
class QuizEvidenceRouter(MethodView):
    def __init__(self) -> None:
        self.security_manager = QuizSecurityManager()

    def post(self):
        """Upload exam evidence (grade screenshot with metadata)"""
        try:
            current_app.logger.info(f"📸 Exam evidence upload request received")
            
            attempt_id = request.form.get('attempt_id')
            student_id = request.form.get('student_id')
            quiz_id = request.form.get('quiz_id')
            evidence_type = request.form.get('evidence_type', 'grade_result')
            
            if not all([attempt_id, student_id, quiz_id]):
                return {"success": False, "message": "attempt_id, student_id, and quiz_id are required"}, 400
            
            # Get screenshot file
            screenshot_file = None
            if 'screenshot' in request.files:
                screenshot_file = request.files['screenshot']
                current_app.logger.info(f"Screenshot file received: {screenshot_file.filename}, size: {screenshot_file.content_length}")
            
            if not screenshot_file:
                return {"success": False, "message": "screenshot file is required"}, 400
            
            # Get additional metadata for portfolio
            evidence_data = request.form.get('evidence_data')
            portfolio_tag = request.form.get('portfolio_tag', 'exam_evidence')
            grade = request.form.get('grade')
            max_grade = request.form.get('max_grade')
            percentage = request.form.get('percentage')
            
            return self.security_manager.upload_exam_evidence(
                attempt_id=attempt_id,
                student_id=student_id,
                quiz_id=quiz_id,
                screenshot_file=screenshot_file,
                evidence_type=evidence_type,
                evidence_data=evidence_data,
                portfolio_tag=portfolio_tag,
                grade=grade,
                max_grade=max_grade,
                percentage=percentage
            )
            
        except Exception as e:
            import traceback
            current_app.logger.error(f"Error in exam evidence upload endpoint: {str(e)}")
            current_app.logger.error(traceback.format_exc())
            return {"success": False, "message": f"Error: {str(e)}"}, 500

@quiz_router.route("/test-quiz-creation")
class TestQuizCreationRouter(MethodView):
    def __init__(self) -> None:
        self.quiz_manager = QuizManager()

    def post(self):
        """Test quiz creation with sample data"""
        # Get a random course ID from the database
        from src.models import DatabaseContextManager
        from src.models.models import Course
        
        with DatabaseContextManager() as ctx:
            course = ctx.session.query(Course).first()
            if not course:
                return {"success": False, "message": "No courses found in database"}
            
            test_payload = {
                'quiz_title': 'Test Quiz',
                'quiz_description': 'Test quiz for debugging',
                'quiz_type': 'mixed',
                'max_attempts': 3,
                'time_limit_minutes': 30,
                'max_points': 100.0,
                'passing_score': 60.0,
                'is_randomized': False,
                'show_correct_answers': True,
                'is_published': True,
                'requester_id': 'test-user',
                'requester_type': 'tutor',
                'course_id': course.id,
                'questions': [
                    {
                        'question_text': 'What is 2+2?',
                        'question_type': 'multiple_choice',
                        'points': 1.0,
                        'question_order': 1,
                        'options': [
                            {'option_text': '3', 'is_correct': False, 'option_order': 1},
                            {'option_text': '4', 'is_correct': True, 'option_order': 2},
                            {'option_text': '5', 'is_correct': False, 'option_order': 3},
                            {'option_text': '6', 'is_correct': False, 'option_order': 4}
                        ]
                    }
                ]
            }
            
            current_app.logger.info("🧪 Testing quiz creation with sample data")
            return self.quiz_manager.create_quiz(test_payload)

@quiz_router.route("/quizzes/<string:quiz_id>/attempts")
class QuizStudentAttemptsRouter(MethodView):
    def __init__(self) -> None:
        self.quiz_manager = QuizManager()

    def get(self, quiz_id):
        """Get all attempts for a quiz by a student"""
        student_id = request.args.get('student_id', type=str)
        
        if not student_id:
            return {"success": False, "message": "student_id parameter is required"}, 400
        
        return self.quiz_manager.get_student_quiz_attempts(quiz_id, student_id)