from fastapi import FastAPI, Depends, HTTPException, status, Request, UploadFile, File, Form, BackgroundTasks
from fastapi.responses import StreamingResponse
from fastapi.middleware.cors import CORSMiddleware
from sqlmodel import Session, select
from contextlib import asynccontextmanager
from typing import List, Dict, Any, Optional
from uuid import UUID
from datetime import datetime, timedelta, date
from pydantic import BaseModel

from database import init_db, get_session
import models
from ai_coach import calculate_sm2
from analytics import generate_parent_report
from billing import generate_mock_order, verify_webhook_signature
from llm import stream_tutor_response
from predictor import calculate_readiness_score
from growth import generate_referral_link, process_referral_reward

@asynccontextmanager
async def lifespan(app: FastAPI):
    init_db()
    yield

app = FastAPI(
    title="PragatiVeer Core Engine",
    version="1.0.0",
    lifespan=lifespan
)

app.add_middleware(
    CORSMiddleware,
    allow_origins=["http://localhost:3000", "http://127.0.0.1:3000"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

@app.get("/health", tags=["System"])
def health_check():
    return {"status": "operational", "engine": "FastAPI Async", "environment": "local_dev"}

# --- ACCESS CONTROL DEPENDENCY ---

def require_tier(allowed_tiers: List[models.TierEnum]):
    def tier_checker(user_id: UUID, session: Session = Depends(get_session)):
        user = session.get(models.User, user_id)
        if not user:
            raise HTTPException(status_code=404, detail="User not found.")
        if user.tier not in allowed_tiers:
            raise HTTPException(
                status_code=403,
                detail=f"Access denied. Requires one of: {[t.value for t in allowed_tiers]}"
            )
        return user
    return tier_checker

# --- AUTHENTICATION ---

@app.post("/api/auth/otp-request", tags=["Authentication"])
def request_otp(phone_or_email: str):
    return {"message": "Verification code dispatched successfully", "debug_otp": "123456"}

@app.post("/api/auth/otp-verify", tags=["Authentication"])
def verify_otp(phone_or_email: str, code: str, session: Session = Depends(get_session)):
    return {"status": "authenticated", "token": "mock_jwt_session_token_string"}

# --- CBT ENGINE ---

@app.get("/api/tests", response_model=List[models.Test], tags=["CBT Engine"])
def list_active_tests(exam_pattern: Optional[str] = None, type: Optional[str] = None, session: Session = Depends(get_session)):
    query = select(models.Test).where(models.Test.is_active == True)
    if exam_pattern:
        query = query.where(models.Test.exam_pattern == exam_pattern)
    if type:
        query = query.where(models.Test.type == type)
    else:
        query = query.where(models.Test.type != "DPS")
    return session.exec(query).all()

@app.get("/api/tests/{test_id}", response_model=models.Test, tags=["CBT Engine"])
def get_test_by_id(test_id: UUID, user_id: UUID, session: Session = Depends(get_session)):
    test = session.get(models.Test, test_id)
    if not test:
        raise HTTPException(status_code=404, detail="Requested examination structure not found.")
    return test

@app.get("/api/tests/{test_id}/questions", response_model=List[models.Question], tags=["CBT Engine"])
def get_questions_by_test_id(test_id: UUID, session: Session = Depends(get_session)):
    test = session.get(models.Test, test_id)
    if not test:
        raise HTTPException(status_code=404, detail="Requested examination structure not found.")
    
    # Extract all question IDs from sections
    question_ids = []
    for section_name, section_data in test.sections.items():
        question_ids.extend(section_data.get("questions", []))
    
    # Fetch all questions in one query
    if not question_ids:
        return []
    
    # Ensure they are UUID objects
    import uuid
    valid_ids = []
    for q_id in question_ids:
        if isinstance(q_id, str):
            try:
                valid_ids.append(uuid.UUID(q_id))
            except ValueError:
                continue
        elif isinstance(q_id, uuid.UUID):
            valid_ids.append(q_id)
            
    query = select(models.Question).where(models.Question.id.in_(valid_ids))
    questions = session.exec(query).all()
    
    # Order them to match the section order if needed, but the frontend currently doesn't rely on it strictly 
    # except for section bounds which it reconstructs.
    return questions

@app.get("/api/questions/{question_id}", response_model=models.Question, tags=["CBT Engine"])
def get_question_by_id(question_id: UUID, session: Session = Depends(get_session)):
    question = session.get(models.Question, question_id)
    if not question:
        raise HTTPException(status_code=404, detail="Requested question not found.")
    return question

@app.post("/api/attempts/submit", response_model=models.Attempt, tags=["CBT Engine"])
def submit_test_attempt(payload: Dict[str, Any], session: Session = Depends(get_session)):
    user_id = payload.get("user_id")
    source_type_raw = payload.get("source_type", "Test")
    source_id = payload.get("source_id")
    client_answers = payload.get("answers", [])

    if not user_id or not source_id:
        raise HTTPException(status_code=400, detail="Missing required deployment metadata parameters.")

    # Normalize source_type string to match SourceTypeEnum values
    _st_map = {"dps": "DPS", "test": "Test", "microtest": "MicroTest"}
    source_type = _st_map.get(str(source_type_raw).lower(), "Test")

    total_questions = len(client_answers)
    correct_count = 0
    processed_answers = []

    attempt_id_str = payload.get("id")
    import uuid as _uuid
    attempt_id = _uuid.UUID(attempt_id_str) if attempt_id_str else _uuid.uuid4()
    
    # Check if this is a retake
    existing_attempts_query = select(models.Attempt).where(
        models.Attempt.user_id == user_id,
        models.Attempt.source_id == source_id
    )
    existing_attempts = session.exec(existing_attempts_query).all()
    is_retake = len(existing_attempts) > 0

    attempt_record = models.Attempt(
        id=attempt_id,
        user_id=user_id,
        source_type=models.SourceTypeEnum(source_type),
        source_id=source_id,
        started_at=datetime.utcnow() - timedelta(seconds=payload.get("time_taken", 0)),
        submitted_at=datetime.utcnow(),
        time_taken=payload.get("time_taken", 0),
        answers=[],
        score=0,
        total_questions=total_questions,
        accuracy=0.0,
        status="Submitted",
        is_retake=is_retake
    )
    session.add(attempt_record)
    session.flush()

    for item in client_answers:
        q_id = item.get("question_id")
        selected = item.get("selected_answer")
        is_subjective = item.get("is_subjective", False)

        try:
            question = session.get(models.Question, q_id)
        except Exception:
            continue
        if not question:
            continue

        correct_ans = question.correct_answer or {}
        # Support both {"value": "A"} and {"correct": "A"} key formats
        correct_value = correct_ans.get("value") or correct_ans.get("correct")

        if is_subjective:
            # Subjective: award credit for any non-trivial written answer
            student_text = str(selected or "").strip()
            is_correct = len(student_text) > 5
        elif isinstance(correct_value, list):
            # Multiple Choice (Multi-Correct)
            selected_list = sorted([s.strip() for s in str(selected or "").split(",") if s.strip()])
            correct_list = sorted([str(c).strip() for c in correct_value])
            is_correct = (selected_list == correct_list)
        else:
            is_correct = bool(correct_value) and str(correct_value).strip() == str(selected or "").strip()

        if is_correct:
            correct_count += 1

        processed_answers.append({
            "question_id": str(q_id),
            "selected_answer": selected,
            "is_correct": is_correct,
            "is_subjective": is_subjective,
            "time_spent": item.get("time_spent", 0)
        })

        # Track mistakes only for objective wrong answers
        if not is_correct and not is_subjective:
            try:
                existing_mistake = session.exec(
                    select(models.Mistake).where(
                        models.Mistake.user_id == user_id,
                        models.Mistake.question_id == q_id
                    )
                ).first()
            except Exception:
                existing_mistake = None

            if existing_mistake:
                interval, ef = calculate_sm2(q=1, repetitions=existing_mistake.review_count, ease_factor=2.5, previous_interval=1)
                existing_mistake.review_count += 1
                existing_mistake.next_review = datetime.utcnow() + timedelta(days=interval)
                existing_mistake.consecutive_correct = 0
                session.add(existing_mistake)
            else:
                new_mistake = models.Mistake(
                    user_id=user_id,
                    question_id=q_id,
                    attempt_id=attempt_id,
                    error_type=models.ErrorTypeEnum.CONCEPTUAL,
                    topic=question.topic,
                    subtopic=question.subtopic,
                    next_review=datetime.utcnow() + timedelta(days=1),
                    review_count=1,
                    consecutive_correct=0,
                    is_mastered=False
                )
                session.add(new_mistake)

    accuracy = (correct_count / total_questions) * 100 if total_questions > 0 else 0.0

    attempt_record.answers = processed_answers
    attempt_record.score = correct_count
    attempt_record.accuracy = accuracy

    session.add(attempt_record)
    session.commit()
    session.refresh(attempt_record)

    return attempt_record

# --- AI COACH SPACED REPETITION ENDPOINTS ---

@app.get("/api/mistakes/today", tags=["AI Coach"])
def get_todays_mistakes(user_id: UUID, session: Session = Depends(get_session)):
    now = datetime.utcnow()
    statement = select(models.Mistake, models.Question).join(
        models.Question, models.Mistake.question_id == models.Question.id
    ).where(
        models.Mistake.user_id == user_id,
        models.Mistake.is_mastered == False,
        models.Mistake.next_review <= now
    )
    results = session.exec(statement).all()
    response_data = []
    for mistake, question in results:
        response_data.append({"mistake": mistake, "question": question})
    return response_data

@app.post("/api/mistakes/review", tags=["AI Coach"])
def submit_mistake_review(payload: Dict[str, Any], session: Session = Depends(get_session)):
    mistake_id = payload.get("mistake_id")
    selected_answer = payload.get("selected_answer")

    if not mistake_id or not selected_answer:
        raise HTTPException(status_code=400, detail="Missing mistake_id or selected_answer")

    mistake = session.get(models.Mistake, mistake_id)
    if not mistake:
        raise HTTPException(status_code=404, detail="Mistake not found.")

    question = session.get(models.Question, mistake.question_id)
    correct_ans = question.correct_answer or {}
    correct_value = correct_ans.get("value") or correct_ans.get("correct")
    
    if isinstance(correct_value, list):
        # Multiple Choice (Multi-Correct)
        selected_list = sorted([s.strip() for s in str(selected_answer or "").split(",") if s.strip()])
        correct_list = sorted([str(c).strip() for c in correct_value])
        is_correct = (selected_list == correct_list)
    else:
        is_correct = bool(correct_value) and str(correct_value).strip() == str(selected_answer or "").strip()

    q_value = 4 if is_correct else 1
    days_since_creation = (datetime.utcnow() - mistake.created_at).days
    prev_interval = max(1, days_since_creation)
    interval, ef = calculate_sm2(q=q_value, repetitions=mistake.review_count, ease_factor=2.5, previous_interval=prev_interval)

    if is_correct:
        mistake.consecutive_correct += 1
        if mistake.consecutive_correct >= 3:
            mistake.is_mastered = True
    else:
        mistake.consecutive_correct = 0

    mistake.review_count += 1
    mistake.next_review = datetime.utcnow() + timedelta(days=interval)

    session.add(mistake)
    session.commit()
    session.refresh(mistake)

    return {"mistake": mistake, "is_correct": is_correct, "correct_answer": correct_value}

# --- PARENT SUBSYSTEM ---

@app.post("/api/parent/register", response_model=models.Parent, tags=["Parent Subsystem"])
def register_parent(parent_data: models.Parent, session: Session = Depends(get_session)):
    session.add(parent_data)
    session.commit()
    session.refresh(parent_data)
    return parent_data

@app.post("/api/parent/link-student", tags=["Parent Subsystem"])
def link_student_to_parent(parent_id: UUID, student_phone_or_email: str, session: Session = Depends(get_session)):
    parent = session.get(models.Parent, parent_id)
    if not parent:
        raise HTTPException(status_code=404, detail="Parent account context not found.")

    student = session.exec(
        select(models.User).where(
            (models.User.phone == student_phone_or_email) |
            (models.User.email == student_phone_or_email)
        )
    ).first()

    if not student:
        raise HTTPException(status_code=404, detail="Target student profile could not be verified.")

    current_links = list(parent.linked_students or [])
    if str(student.id) not in current_links:
        current_links.append(str(student.id))
        parent.linked_students = current_links
        session.add(parent)
        session.commit()

    return {"message": "Student successfully linked to parent context.", "linked_student_id": student.id}

@app.get("/api/parent/{parent_id}/dashboard/{student_id}", tags=["Parent Subsystem"])
def get_parent_dashboard_metrics(parent_id: UUID, student_id: UUID, session: Session = Depends(get_session)):
    parent = session.get(models.Parent, parent_id)
    if not parent:
        raise HTTPException(status_code=404, detail="Unauthorized parent profile access attempt.")

    if str(student_id) not in (parent.linked_students or []):
        raise HTTPException(status_code=403, detail="Access denied to requested student dashboard data.")

    report = generate_parent_report(student_id, session)
    return report

# --- BILLING & SUBSCRIPTION ---

@app.post("/api/billing/create-order", tags=["Subscription Engine"])
def create_subscription_order(user_id: UUID, plan_tier: str, session: Session = Depends(get_session)):
    user = session.get(models.User, user_id)
    if not user:
        raise HTTPException(status_code=404, detail="User not found.")

    pricing_map = {"Pro": 29900, "Al_Coach": 59900}
    amount = pricing_map.get(plan_tier)
    if not amount:
        raise HTTPException(status_code=400, detail="Invalid subscription tier requested.")

    order = generate_mock_order(user_id, plan_tier, amount)
    return {"order_id": order["id"], "amount": amount, "currency": "INR"}

@app.post("/api/billing/webhook/razorpay", tags=["Subscription Engine"])
async def razorpay_webhook_handler(request: Request, session: Session = Depends(get_session)):
    payload_bytes = await request.body()
    payload_str = payload_bytes.decode("utf-8")
    signature = request.headers.get("X-Razorpay-Signature", "")

    if not verify_webhook_signature(payload_str, signature):
        raise HTTPException(status_code=400, detail="Invalid webhook signature.")

    import json
    data = json.loads(payload_str)

    if data.get("event") == "payment.captured":
        notes = data["payload"]["payment"]["entity"]["notes"]
        user_id = notes.get("user_id")
        tier_requested = notes.get("tier_requested")

        user = session.get(models.User, user_id)
        if user and tier_requested:
            user.tier = models.TierEnum(tier_requested)
            session.add(user)
            new_sub = models.Subscription(
                user_id=user.id,
                tier=models.TierEnum(tier_requested),
                billing_cycle="Monthly",
                start_date=datetime.utcnow(),
                end_date=datetime.utcnow() + timedelta(days=30),
                amount=data["payload"]["payment"]["entity"]["amount"],
                payment_id=data["payload"]["payment"]["entity"]["id"],
                status="Active"
            )
            session.add(new_sub)
            session.commit()

    return {"status": "Webhook processed successfully"}

# --- STUDY PLAN ---

@app.get("/api/ai-coach/study-plan/today", tags=["AI Coach"])
def get_todays_study_plan(user_id: UUID, session: Session = Depends(get_session), current_user=Depends(require_tier([models.TierEnum.AI_COACH]))):
    today = datetime.utcnow().date()
    plan = session.exec(
        select(models.StudyPlan)
        .where(models.StudyPlan.user_id == user_id)
        .where(models.StudyPlan.date == today)
    ).first()

    if not plan:
        raise HTTPException(status_code=404, detail="No study plan generated for today yet.")

    return plan

class ChatRequest(BaseModel):
    user_id: UUID
    message: str

@app.post("/api/ai-coach/chat/stream", tags=["AI Coach"])
async def ai_tutor_chat_stream(request: ChatRequest, session: Session = Depends(get_session)):
    user = session.get(models.User, request.user_id)
    if not user:
        raise HTTPException(status_code=404, detail="Student profile not found.")
    if user.tier != models.TierEnum.AI_COACH:
        raise HTTPException(status_code=403, detail="Access denied. Gated to AI_COACH tier.")

    return StreamingResponse(
        stream_tutor_response(request.user_id, request.message, session),
        media_type="text/event-stream"
    )

@app.get("/api/ai-coach/readiness/{user_id}", tags=["AI Coach"])
def get_exam_readiness(user_id: UUID, session: Session = Depends(get_session), current_user=Depends(require_tier([models.TierEnum.AI_COACH]))):
    readiness_data = calculate_readiness_score(user_id, session)
    if not readiness_data:
        raise HTTPException(status_code=404, detail="Could not calculate readiness score.")
    return readiness_data

@app.get("/api/growth/referral/{user_id}", tags=["Viral Growth"])
def get_referral_dashboard(user_id: UUID, session: Session = Depends(get_session)):
    user = session.get(models.User, user_id)
    if not user:
        raise HTTPException(status_code=404, detail="User not found.")

    link = generate_referral_link(user_id)
    return {
        "referral_link": link,
        "total_referrals": 0,
        "rewards_earned_days": 0,
        "share_message": f"I'm on a {user.streak_count}-day study streak on PragatiVeer! Use my link to get 7 days of the AI Coach for free: {link}"
    }

# --- USERS ---

@app.get("/api/users/{user_id}", response_model=models.User, tags=["Users"])
def get_user_profile(user_id: UUID, session: Session = Depends(get_session)):
    user = session.get(models.User, user_id)
    if not user:
        raise HTTPException(status_code=404, detail="User not found")
        
    # Snapchat-style daily active streak check
    now = datetime.utcnow()
    today = now.date()
    last_active_date = user.last_active.date()
    delta = (today - last_active_date).days
    
    changed = False
    if user.streak_count == 0:
        user.streak_count = 1
        user.longest_streak = max(user.longest_streak, 1)
        user.last_active = now
        changed = True
    elif delta == 1:
        user.streak_count += 1
        user.longest_streak = max(user.longest_streak, user.streak_count)
        user.last_active = now
        changed = True
    elif delta > 1:
        user.streak_count = 1
        user.last_active = now
        changed = True
        
    if changed:
        session.add(user)
        session.commit()
        session.refresh(user)
        
    return user

class UserUpdate(BaseModel):
    name: Optional[str] = None
    target_exam: Optional[models.ExamEnum] = None
    student_class: Optional[models.ClassEnum] = None
    school: Optional[str] = None
    state: Optional[str] = None

@app.put("/api/users/{user_id}", response_model=models.User, tags=["Users"])
def update_user_profile(user_id: UUID, payload: UserUpdate, session: Session = Depends(get_session)):
    user = session.get(models.User, user_id)
    if not user:
        raise HTTPException(status_code=404, detail="User not found")

    if payload.name is not None: user.name = payload.name
    if payload.target_exam is not None: user.target_exam = payload.target_exam
    if payload.student_class is not None: user.student_class = payload.student_class
    if payload.school is not None: user.school = payload.school
    if payload.state is not None: user.state = payload.state

    session.add(user)
    session.commit()
    session.refresh(user)
    return user

class UserSessionUpdate(BaseModel):
    session_token: str

@app.post("/api/users/{user_id}/session", response_model=models.User, tags=["Users"])
def update_user_session(user_id: UUID, payload: UserSessionUpdate, session: Session = Depends(get_session)):
    user = session.get(models.User, user_id)
    if not user:
        raise HTTPException(status_code=404, detail="User not found")
    
    user.active_session_token = payload.session_token
    session.add(user)
    session.commit()
    session.refresh(user)
    return user

from storage import upload_file

@app.post("/api/users/{user_id}/upload-avatar", tags=["Users"])
async def upload_user_avatar(user_id: UUID, file: UploadFile = File(...), session: Session = Depends(get_session)):
    user = session.get(models.User, user_id)
    if not user:
        raise HTTPException(status_code=404, detail="User not found")

    contents = await file.read()
    file_extension = file.filename.split(".")[-1] if "." in file.filename else "jpg"
    current_year = datetime.utcnow().year
    object_name = f"avatars/{current_year}/avatar_{user_id}.{file_extension}"
    public_url = upload_file(contents, object_name, content_type=file.content_type)

    if not public_url:
        raise HTTPException(status_code=500, detail="Failed to upload image to Minio.")

    return {"url": public_url}

@app.get("/api/users/{user_id}/attempts", tags=["Users"])
def get_user_attempts(user_id: UUID, session: Session = Depends(get_session)):
    query = select(models.Attempt).where(models.Attempt.user_id == user_id)
    return session.exec(query).all()

# --- ADMIN ROUTES ---

@app.get("/api/admin/tests", tags=["Admin"])
def get_admin_tests(session: Session = Depends(get_session)):
    tests = session.exec(select(models.Test)).all()
    return tests

class ManualQuestionInput(BaseModel):
    section: str = "General"
    subject: str
    topic: str
    subtopic: str
    difficulty: str
    type: str
    question_text: str
    options: Optional[Dict[str, Any]] = None
    correct_answer: Dict[str, Any]
    solution_text: str
    language: str

class ManualTestCreate(BaseModel):
    title: str
    exam_pattern: str
    time_limit: int
    scheduled_date: Optional[datetime] = None
    end_date: Optional[datetime] = None
    admin_id: UUID
    questions_json: List[ManualQuestionInput]

@app.post("/api/admin/tests/upload", tags=["Admin"])
async def upload_admin_test(
    file: UploadFile = File(...),
    title: str = Form(...),
    exam_pattern: str = Form(...),
    time_limit: int = Form(...),
    scheduled_date: Optional[datetime] = Form(None),
    admin_id: UUID = Form(...),
    session: Session = Depends(get_session)
):
    import storage
    import uuid
    from worker import process_pdf_test

    pdf_bytes = await file.read()
    current_year = datetime.utcnow().year
    object_name = f"tests/{current_year}/{uuid.uuid4()}_{file.filename}"
    url = storage.upload_file(pdf_bytes, object_name, content_type="application/pdf")
    if not url:
        raise HTTPException(status_code=500, detail="Failed to upload PDF to MinIO")

    test_obj = models.Test(
        title=title,
        type="Mock",
        exam_pattern=models.ExamEnum(exam_pattern),
        sections={},
        total_time=time_limit,
        difficulty="Medium",
        scheduled_date=scheduled_date,
        is_active=False,
        created_by=admin_id
    )
    session.add(test_obj)
    session.commit()
    session.refresh(test_obj)

    process_pdf_test.delay(
        test_id_str=str(test_obj.id),
        object_name=object_name,
        admin_id_str=str(admin_id),
        exam_pattern=exam_pattern
    )

    return {"status": "processing", "test_id": test_obj.id, "message": "Test is being processed by AI"}

@app.post("/api/admin/tests/create_manual", tags=["Admin"])
def create_manual_test(
    data: ManualTestCreate,
    session: Session = Depends(get_session)
):
    import uuid
    # 1. Create the test object
    test_obj = models.Test(
        title=data.title,
        type="Mock",
        exam_pattern=models.ExamEnum(data.exam_pattern),
        sections={},
        total_time=data.time_limit,
        difficulty="Medium",
        scheduled_date=data.scheduled_date,
        end_date=data.end_date,
        is_active=True,
        created_by=data.admin_id
    )
    session.add(test_obj)

    # 2. Parse and create questions
    sections_dict = {}
    
    for q_data in data.questions_json:
        q_obj = models.Question(
            subject=q_data.subject,
            topic=q_data.topic,
            subtopic=q_data.subtopic,
            difficulty=q_data.difficulty,
            type=models.QuestionTypeEnum(q_data.type),
            question_text=q_data.question_text,
            options=q_data.options,
            correct_answer=q_data.correct_answer,
            solution_text=q_data.solution_text,
            language=models.MediumEnum(q_data.language),
            created_by=data.admin_id
        )
        session.add(q_obj)

        sec_name = q_data.section
        if sec_name not in sections_dict:
            sections_dict[sec_name] = {
                "name": sec_name,
                "questions": [],
                "time_limit": None
            }
        sections_dict[sec_name]["questions"].append(str(q_obj.id))

    # 3. Update the test with the sections
    test_obj.sections = sections_dict
    session.add(test_obj)
    session.commit()
    
    return {"message": "Test created successfully", "test_id": test_obj.id}

@app.put("/api/admin/tests/{test_id}/toggle", tags=["Admin"])
def toggle_test_status(test_id: UUID, session: Session = Depends(get_session)):
    test_obj = session.get(models.Test, test_id)
    if not test_obj:
        raise HTTPException(status_code=404, detail="Test not found")

    test_obj.is_active = not test_obj.is_active
    session.add(test_obj)
    session.commit()

    return {"status": "success", "is_active": test_obj.is_active}

@app.delete("/api/admin/tests/{test_id}", tags=["Admin"])
def delete_test(test_id: UUID, session: Session = Depends(get_session)):
    from sqlmodel import select
    test_obj = session.get(models.Test, test_id)
    if not test_obj:
        raise HTTPException(status_code=404, detail="Test not found")
        
    # 1. Identify all question IDs associated with the test
    question_ids = []
    if test_obj.sections:
        for section_name, section_data in test_obj.sections.items():
            question_ids.extend(section_data.get("questions", []))
            
    # Convert question IDs to UUIDs
    import uuid
    q_uuids = []
    for q_id in question_ids:
        try:
            q_uuids.append(uuid.UUID(q_id) if isinstance(q_id, str) else q_id)
        except ValueError:
            continue

    # 2. Identify all attempts associated with this test
    attempts_query = select(models.Attempt).where(
        models.Attempt.source_id == test_id
    )
    attempts = session.exec(attempts_query).all()
    attempt_ids = [att.id for att in attempts]

    # 3. Delete Mistake records referencing these attempts
    if attempt_ids:
        mistakes_by_attempt_query = select(models.Mistake).where(
            models.Mistake.attempt_id.in_(attempt_ids)
        )
        mistakes_by_attempt = session.exec(mistakes_by_attempt_query).all()
        for mistake in mistakes_by_attempt:
            session.delete(mistake)

    # 4. Delete Mistake records referencing these questions
    if q_uuids:
        mistakes_by_q_query = select(models.Mistake).where(
            models.Mistake.question_id.in_(q_uuids)
        )
        mistakes_by_q = session.exec(mistakes_by_q_query).all()
        for mistake in mistakes_by_q:
            try:
                session.delete(mistake)
            except Exception:
                pass

    # 5. Delete the Attempt records
    for att in attempts:
        session.delete(att)

    # 6. Delete the Question records
    for q_uuid in q_uuids:
        q_obj = session.get(models.Question, q_uuid)
        if q_obj:
            session.delete(q_obj)
            
    # 7. Delete the Test itself
    session.delete(test_obj)
    session.commit()
    return {"status": "success", "message": "Test and all associated questions, attempts, and mistakes deleted successfully"}

# --- COUPON CRUD ROUTES ---

class CouponCreate(BaseModel):
    code: str
    discount_percent: float
    max_discount_amount: float
    is_active: bool = True
    expires_at: Optional[datetime] = None

class CouponUpdate(BaseModel):
    code: Optional[str] = None
    discount_percent: Optional[float] = None
    max_discount_amount: Optional[float] = None
    is_active: Optional[bool] = None
    expires_at: Optional[datetime] = None

@app.get("/api/admin/coupons", tags=["Admin"])
def get_admin_coupons(session: Session = Depends(get_session)):
    coupons = session.exec(select(models.Coupon)).all()
    return coupons

@app.post("/api/admin/coupons", tags=["Admin"])
def create_coupon(payload: CouponCreate, session: Session = Depends(get_session)):
    coupon = models.Coupon(**payload.dict())
    session.add(coupon)
    session.commit()
    session.refresh(coupon)
    return coupon

@app.put("/api/admin/coupons/{coupon_id}", tags=["Admin"])
def update_coupon(coupon_id: UUID, payload: CouponUpdate, session: Session = Depends(get_session)):
    coupon = session.get(models.Coupon, coupon_id)
    if not coupon:
        raise HTTPException(status_code=404, detail="Coupon not found")
    
    update_data = payload.dict(exclude_unset=True)
    for key, value in update_data.items():
        setattr(coupon, key, value)
    
    session.add(coupon)
    session.commit()
    session.refresh(coupon)
    return coupon

@app.delete("/api/admin/coupons/{coupon_id}", tags=["Admin"])
def delete_coupon(coupon_id: UUID, session: Session = Depends(get_session)):
    coupon = session.get(models.Coupon, coupon_id)
    if not coupon:
        raise HTTPException(status_code=404, detail="Coupon not found")
    
    session.delete(coupon)
    session.commit()
    return {"status": "success", "message": "Coupon deleted successfully"}