from flask import Blueprint, request, jsonify
from flask_restful import Resource, Api
from bson import ObjectId
from models.exam import Exam, StudyMaterial
from models.sub_exam import SubExam
from utils.jwt_service import jwt_required

exams_bp = Blueprint('exams', __name__)
exams_api = Api(exams_bp)

class ExamList(Resource):
    @jwt_required
    def get(self):
        exams = Exam.objects(status=1).order_by('exam_position')

        if not exams:
            return {
                "status": "false",
                "message": "No exams list available yet",
                "data": []
            }, 200

        exam_list = []
        for exam in exams:
            exam_list.append({
                "id": str(exam.id),
                "exam_title": exam.exam_title,
                "exam_description": exam.exam_description or "",
                "status": exam.status,
                "icon": exam.icon or "",
                "alloted_materials": exam.alloted_materials or "",
                "exam_position": exam.exam_position or None,
                "created_date": exam.created_date.isoformat()
            })

        return {
            "status": "true",
            "message": "Exam list fetched successfully",
            "data": exam_list
        }, 200

exams_api.add_resource(ExamList, '/exams_list')

@exams_bp.route('/get_sub_exams/<string:exam_id>', methods=['GET'])
@jwt_required
def get_sub_exams(exam_id):
    try:
        # Ensure exam_id is a valid ObjectId
        if not ObjectId.is_valid(exam_id):
            return jsonify({
                "status": "false",
                "message": "Invalid exam ID",
                "data": []
            }), 400
        
        sub_exam_list = SubExam.objects(exam_id=exam_id, status=1).order_by('position')
        if not sub_exam_list:
            return jsonify({
                "status": "false",
                "message": "No sub-exams found for this exam",
                "data": []
            }), 404

        result = []
        for sub_exam in sub_exam_list:
            result.append({
                "id": str(sub_exam.id),
                "icon": sub_exam.icon or "",
                "sub_exam_title": sub_exam.sub_exam_title,
                "sub_exam_description": sub_exam.sub_exam_description or "",
                "status": sub_exam.status,
                "position": sub_exam.position,
                "created_date": sub_exam.created_date.isoformat()
            })
        
        return jsonify({
            "status": "true",
            "message": "Sub-exams fetched successfully",
            "data": result
        }), 200
    except Exception as e:
        return jsonify({
            "status": "false",
            "message": f"An error occurred: {str(e)}",
            "data": []
        }), 500

class ExamListHome(Resource):
    def get(self):
        exams = Exam.objects(status=1).order_by('exam_position')

        if not exams:
            return {
                "status": "false",
                "message": "No exams list available yet",
                "data": []
            }, 200

        exam_list = []
        for exam in exams:
            exam_list.append({
                "id": str(exam.id),
                "exam_title": exam.exam_title,
                "exam_description": exam.exam_description or "",
                "status": exam.status,
                "icon": exam.icon or "",
                "alloted_materials": exam.alloted_materials or "",
                "exam_position": exam.exam_position or None,
                "created_date": exam.created_date.isoformat()
            })

        return {
            "status": "true",
            "message": "Exam list fetched successfully",
            "data": exam_list
        }, 200

exams_api.add_resource(ExamListHome, '/exams_list_home')

@exams_bp.route('/get_sub_exams_home/<string:exam_id>', methods=['GET'])
def get_sub_exams_home(exam_id):
    try:
        # Ensure exam_id is a valid ObjectId
        if not ObjectId.is_valid(exam_id):
            return jsonify({
                "status": "false",
                "message": "Invalid exam ID",
                "data": []
            }), 400
        
        sub_exam_list = SubExam.objects(exam_id=exam_id, status=1).order_by('position')
        if not sub_exam_list:
            return jsonify({
                "status": "false",
                "message": "No sub-exams found for this exam",
                "data": []
            }), 404

        result = []
        for sub_exam in sub_exam_list:
            result.append({
                "id": str(sub_exam.id),
                "icon": sub_exam.icon or "",
                "sub_exam_title": sub_exam.sub_exam_title,
                "sub_exam_description": sub_exam.sub_exam_description or "",
                "status": sub_exam.status,
                "position": sub_exam.position,
                "created_date": sub_exam.created_date.isoformat()
            })
        
        return jsonify({
            "status": "true",
            "message": "Sub-exams fetched successfully",
            "data": result
        }), 200
    except Exception as e:
        return jsonify({
            "status": "false",
            "message": f"An error occurred: {str(e)}",
            "data": []
        }), 500

@exams_bp.route('/get_exam_materials/<string:exam_id>', methods=['GET'])
@jwt_required
def get_exam_materials(exam_id):
    try:
        # Ensure exam_id is a valid ObjectId
        if not ObjectId.is_valid(exam_id):
            return jsonify({
                "status": "false",
                "message": "Invalid exam ID",
                "data": []
            }), 400
        
        sub_exam_list = SubExam.objects(exam_id=exam_id, status=1).order_by('position')
        if not sub_exam_list:
            return jsonify({
                "status": "false",
                "message": "No sub-exams found for this exam",
                "data": []
            }), 404
        result = []
        for sub_exam in sub_exam_list:
            result.append({
                "id": str(sub_exam.id),
                "icon": sub_exam.icon or "",
                "sub_exam_title": sub_exam.sub_exam_title,
                "sub_exam_description": sub_exam.sub_exam_description or "",
                "status": sub_exam.status,
                "position": sub_exam.position,
                "created_date": sub_exam.created_date.isoformat()
            })
        return jsonify({
            "status": "true",
            "message": "Sub-exams fetched successfully",
            "data": result
        }), 200
    except Exception as e:
        return jsonify({
            "status": "false",
            "message": f"An error occurred: {str(e)}",
            "data": []
        }), 500


@exams_bp.route('/exams-with-subexams', methods=['GET'])
def get_exams_with_subexams():
    """
    GET /api/exams-with-subexams?q=sss

    - Finds all exams whose exam_title contains the search term (case-insensitive)
      e.g. 'sss' matches 'SSS', 'Exam sss test', etc.
    - Returns those exams along with their sub-exams.
    """

    # You can make this dynamic via ?q=..., but default to "sss" as you asked
    search_term = (request.args.get('exam_title') or 'sss').strip()

    if not search_term:
        return jsonify({
            "status": False,
            "message": "Search term (q) is required"
        }), 400

    try:
        # 1) Fetch exams whose title contains the search term (case-insensitive)
        #    status=1 filter is optional; remove if you want all exams
        exams_qs = Exam.objects(
            exam_title__icontains=search_term,
            status=1
        ).order_by('exam_position')

        # If no exams match, return empty list
        if not exams_qs:
            return jsonify({
                "status": True,
                "count": 0,
                "data": []
            }), 200

        # 2) Collect exam_ids to fetch sub-exams in one query
        exam_ids = [exam.id for exam in exams_qs]

        sub_exams_qs = SubExam.objects(
            exam_id__in=exam_ids,
            status=1
        ).order_by('position')

        # 3) Group sub-exams by exam_id for easy attachment
        sub_exams_by_exam = {}
        for sub_exam in sub_exams_qs:
            exam_id_str = str(sub_exam.exam_id.id)
            sub_exams_by_exam.setdefault(exam_id_str, []).append(sub_exam.to_json())

        # 4) Build final response structure
        data = []
        for exam in exams_qs:
            exam_dict = {
                "id": str(exam.id),
                "exam_title": exam.exam_title,
                "exam_description": exam.exam_description,
                "status": exam.status,
                "exam_position": exam.exam_position,
                "alloted_materials": exam.alloted_materials,
                "icon": exam.icon,
                "created_date": exam.created_date.isoformat() if exam.created_date else None,
                # all sub-exams that belong to this exam
                "sub_exams": sub_exams_by_exam.get(str(exam.id), [])
            }
            data.append(exam_dict)

        return jsonify({
            "status": True,
            "count": len(data),
            "data": data
        }), 200

    except Exception as e:
        # Basic error handling – you can improve logging if needed
        return jsonify({
            "status": False,
            "message": "Something went wrong while fetching exams",
            "error": str(e)
        }), 500