import json
from pydantic import ValidationError
from schemas.requests import QuizCreateSchema, UserAnswerSchema
from schemas.response import QuizCreationResponse
from schemas import MetaSchema
from services import QuizService, AnswerService
from helpers import make_response, make_error_response
from exception import ValidationException


class QuizController:
    def __init__(self, quiz_service: QuizService, answer_service: AnswerService):
        self.quiz_service = quiz_service
        self.answer_service = answer_service

    def get_quiz(self, quiz_id):
        try:
            result = self.quiz_service.get_quiz(quiz_id)
            if not result:
                return make_response(message="Quiz not found", status_code=404)
            return make_response(message="Quiz Found", data=result.dict())
        except Exception as e:
            return make_error_response(e)

    def create_quiz(self, quiz_data):
        try:
            quiz_obj = QuizCreateSchema(**quiz_data)
            quiz_id = self.quiz_service.create_quiz(quiz_obj)
            return make_response(
                message="Quiz created",
                data=QuizCreationResponse(quiz_id=quiz_id),
                status_code=201,
            )
        except (ValidationError, ValidationException) as e:
            return make_response(e.errors(), status_code=400)
        except Exception as e:
            return make_error_response(e)

    # def update_quiz(self, quiz_id, quiz_data):
    #     try:
    #         quiz_obj = QuizUpdateSchema(**quiz_data)
    #         success = self.quiz_service.update_quiz(
    #             quiz_id, quiz_obj.dict(exclude_unset=True)
    #         )
    #         if not success:
    #             return jsonify({"error": "Quiz not found or update failed"}), 400
    #         return jsonify({"message": "Quiz updated"}), 200
    #     except ValidationError as e:
    #         return jsonify({"error": "Validation error", "detail": e.errors()}), 400

    # def delete_quiz(self, quiz_id):
    #     success = self.quiz_service.delete_quiz(quiz_id)
    #     if not success:
    #         return jsonify({"error": "Quiz not found"}), 400
    #     return jsonify({"message": "Quiz deleted"}), 200

    def quiz_recomendation(self):
        try:
            result = self.quiz_service.get_quiz_recommendation()
            if not result:
                return make_response(message="Quiz not found", status_code=404)
            return make_response(message="Quiz Found", data=result.dict())
        except Exception as e:
            return make_error_response(e)

    def submit_answer(self, answer_data):
        try:
            answer_obj = UserAnswerSchema(**answer_data)
            answer_id = self.answer_service.create_answer(answer_obj)
            return make_response(
                message="Answer submitted",
                data={"answer_id": answer_id},
                status_code=201,
            )
        except ValidationError as e:
            return make_response(
                message="validation error", data=json.loads(e.json()), status_code=400
            )
        except ValidationException as e:
            return make_response(
                message=f"validation issue {e.message}", status_code=400
            )
        except Exception as e:
            return make_error_response(e)

    def get_answer(self, quiz_id, user_id, session_id):
        try:
            # self.answer_service.
            print("yps")
        except Exception as e:
            return make_error_response(e)

    def get_user_quiz(self, user_id, page=1, page_size=10):
        try:
            result = self.quiz_service.get_user_quiz(
                user_id=user_id, page=page, page_size=page_size
            )
            return make_response(
                message="User quizzes retrieved successfully",
                data=result.quizzes,
                page=page,
                page_size=page_size,
                total_all_data=result.total,
            )
        except Exception as e:
            return make_error_response(e)