secondary-school-grade-archive/backend/app/routers/wrong_questions.py

import json
import uuid
from pathlib import Path

from fastapi import APIRouter, BackgroundTasks, Depends, File, Form, HTTPException, Query, UploadFile, status
from fastapi.responses import FileResponse
from sqlalchemy.orm import Session, joinedload

from app.core.config import settings
from app.core.database import SessionLocal, get_db
from app.core.deps import get_current_user
from app.models.user import Subject, User, WrongQuestion, WrongQuestionCategory, WrongQuestionStatus
from app.schemas import WrongQuestionCategoryEnum, WrongQuestionOut, WrongQuestionUpdate
from app.services import annotation as annotation_service
from app.services import llm as llm_service
from app.services import ocr as ocr_service
from app.services.student_access import get_student_for_user

router = APIRouter(tags=["wrong_questions"])


def _parse_mark_regions(raw: str | None) -> list[dict] | None:
    if not raw:
        return None
    try:
        data = json.loads(raw)
        return data if isinstance(data, list) else None
    except json.JSONDecodeError:
        return None


def _wq_to_out(wq: WrongQuestion) -> WrongQuestionOut:
    return WrongQuestionOut(
        id=wq.id,
        student_id=wq.student_id,
        subject_id=wq.subject_id,
        subject_name=wq.subject.name if wq.subject else None,
        category=wq.category,
        image_path=wq.image_path,
        ocr_raw_text=wq.ocr_raw_text,
        question_text=wq.question_text,
        solution_approach=wq.solution_approach,
        solution_text=wq.solution_text,
        mark_regions=_parse_mark_regions(wq.mark_regions_json),
        has_annotated_image=bool(wq.annotated_image_path),
        status=wq.status,
        created_at=wq.created_at,
    )


async def _run_ai_pipeline(wq: WrongQuestion, db: Session, ocr_lines: list[dict], ocr_text: str):
    subject_name = wq.subject.name if wq.subject else "综合"
    school_level = wq.student.school_level if wq.student else None
    olympiad = wq.category == WrongQuestionCategory.olympiad
    ai_cfg = llm_service.load_ai_config(db)
    image_full = str(Path(settings.UPLOAD_DIR) / wq.image_path)

    detect_resp = await llm_service.detect_wrong_line_ids(ai_cfg, subject_name, ocr_lines, school_level)
    wrong_ids = annotation_service.parse_wrong_line_ids(detect_resp, ocr_lines)
    regions = annotation_service.regions_from_lines(ocr_lines, wrong_ids)
    wq.mark_regions_json = json.dumps(regions, ensure_ascii=False)

    ann_rel = ocr_service.annotated_rel_path(wq.image_path)
    wq.annotated_image_path = annotation_service.draw_annotated_image(
        image_full, ocr_lines, wrong_ids, ann_rel
    )

    question_text = await llm_service.format_question(ai_cfg, subject_name, ocr_text, school_level)
    solution_full = await llm_service.generate_solution(
        ai_cfg, subject_name, question_text, school_level, olympiad=olympiad
    )
    approach, solution_body = annotation_service.split_solution_sections(solution_full)
    wq.question_text = question_text
    wq.solution_approach = approach
    wq.solution_text = solution_body if approach else solution_full
    wq.status = WrongQuestionStatus.solved


def _process_wrong_question(question_id: uuid.UUID):
    db = SessionLocal()
    try:
        wq = (
            db.query(WrongQuestion)
            .options(joinedload(WrongQuestion.subject), joinedload(WrongQuestion.student))
            .filter(WrongQuestion.id == question_id)
            .first()
        )
        if wq is None:
            return

        image_full = Path(settings.UPLOAD_DIR) / wq.image_path
        try:
            ocr_result = ocr_service.run_ocr_with_regions(str(image_full))
            ocr_text = ocr_result["text"]
            ocr_lines = ocr_result["lines"]
            wq.ocr_raw_text = ocr_text or None
            wq.status = WrongQuestionStatus.ocr_done if ocr_text else WrongQuestionStatus.failed
            db.commit()
        except Exception:
            wq.status = WrongQuestionStatus.failed
            db.commit()
            return

        if not ocr_text:
            return

        import asyncio

        loop = asyncio.new_event_loop()
        asyncio.set_event_loop(loop)
        try:
            loop.run_until_complete(_run_ai_pipeline(wq, db, ocr_lines, ocr_text))
            db.commit()
        except Exception:
            wq.status = WrongQuestionStatus.ocr_done
            db.commit()
        finally:
            loop.close()
    finally:
        db.close()


@router.get("/students/{student_id}/wrong-questions", response_model=list[WrongQuestionOut])
def list_wrong_questions(
    student_id: uuid.UUID,
    subject_id: int | None = Query(None),
    category: WrongQuestionCategoryEnum | None = Query(None),
    q: str | None = Query(None),
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    get_student_for_user(db, student_id, current_user.id)
    query = (
        db.query(WrongQuestion)
        .options(joinedload(WrongQuestion.subject))
        .filter(WrongQuestion.student_id == student_id)
    )
    if subject_id is not None:
        query = query.filter(WrongQuestion.subject_id == subject_id)
    if category is not None:
        query = query.filter(WrongQuestion.category == category.value)
    if q:
        pattern = f"%{q}%"
        query = query.filter(
            (WrongQuestion.question_text.ilike(pattern))
            | (WrongQuestion.solution_text.ilike(pattern))
            | (WrongQuestion.ocr_raw_text.ilike(pattern))
        )
    items = query.order_by(WrongQuestion.created_at.desc()).all()
    return [_wq_to_out(w) for w in items]


@router.post(
    "/students/{student_id}/wrong-questions",
    response_model=WrongQuestionOut,
    status_code=status.HTTP_201_CREATED,
)
async def upload_wrong_question(
    student_id: uuid.UUID,
    background_tasks: BackgroundTasks,
    subject_id: int = Form(...),
    file: UploadFile = File(...),
    category: WrongQuestionCategoryEnum = Form(WrongQuestionCategoryEnum.regular),
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    get_student_for_user(db, student_id, current_user.id)
    subject = db.get(Subject, subject_id)
    if subject is None:
        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="科目不存在")
    if category == WrongQuestionCategoryEnum.olympiad and subject.name != "数学":
        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="奥数区仅支持数学科目")

    content = await file.read()
    if len(content) > settings.MAX_UPLOAD_SIZE:
        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="文件超过10MB限制")

    wq = WrongQuestion(
        student_id=student_id,
        subject_id=subject_id,
        image_path="",
        category=WrongQuestionCategory(category.value),
        status=WrongQuestionStatus.pending,
    )
    db.add(wq)
    db.flush()

    rel_path = ocr_service.save_upload_file(
        str(current_user.id), str(wq.id), file.filename or "image.jpg", content
    )
    wq.image_path = rel_path
    db.commit()
    db.refresh(wq)
    wq = (
        db.query(WrongQuestion)
        .options(joinedload(WrongQuestion.subject))
        .filter(WrongQuestion.id == wq.id)
        .first()
    )

    background_tasks.add_task(_process_wrong_question, wq.id)
    return _wq_to_out(wq)


@router.get("/wrong-questions/{question_id}", response_model=WrongQuestionOut)
def get_wrong_question(
    question_id: uuid.UUID,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    wq = (
        db.query(WrongQuestion)
        .options(joinedload(WrongQuestion.subject), joinedload(WrongQuestion.student))
        .filter(WrongQuestion.id == question_id)
        .first()
    )
    if wq is None or wq.student.user_id != current_user.id:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="错题不存在")
    return _wq_to_out(wq)


@router.patch("/wrong-questions/{question_id}", response_model=WrongQuestionOut)
def update_wrong_question(
    question_id: uuid.UUID,
    data: WrongQuestionUpdate,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    wq = (
        db.query(WrongQuestion)
        .options(joinedload(WrongQuestion.subject), joinedload(WrongQuestion.student))
        .filter(WrongQuestion.id == question_id)
        .first()
    )
    if wq is None or wq.student.user_id != current_user.id:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="错题不存在")

    if data.subject_id is not None:
        if db.get(Subject, data.subject_id) is None:
            raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="科目不存在")
        wq.subject_id = data.subject_id
    if data.question_text is not None:
        wq.question_text = data.question_text
    if data.solution_text is not None:
        wq.solution_text = data.solution_text
    if data.solution_approach is not None:
        wq.solution_approach = data.solution_approach

    db.commit()
    db.refresh(wq)
    return _wq_to_out(wq)


@router.delete("/wrong-questions/{question_id}", status_code=status.HTTP_204_NO_CONTENT)
def delete_wrong_question(
    question_id: uuid.UUID,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    wq = (
        db.query(WrongQuestion)
        .options(joinedload(WrongQuestion.student))
        .filter(WrongQuestion.id == question_id)
        .first()
    )
    if wq is None or wq.student.user_id != current_user.id:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="错题不存在")

    image_full = Path(settings.UPLOAD_DIR) / wq.image_path
    ann_full = Path(settings.UPLOAD_DIR) / wq.annotated_image_path if wq.annotated_image_path else None
    db.delete(wq)
    db.commit()
    if image_full.exists():
        image_full.unlink()
    if ann_full and ann_full.exists():
        ann_full.unlink()


@router.post("/wrong-questions/{question_id}/retry-ocr", response_model=WrongQuestionOut)
def retry_ocr(
    question_id: uuid.UUID,
    background_tasks: BackgroundTasks,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    wq = (
        db.query(WrongQuestion)
        .options(joinedload(WrongQuestion.subject), joinedload(WrongQuestion.student))
        .filter(WrongQuestion.id == question_id)
        .first()
    )
    if wq is None or wq.student.user_id != current_user.id:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="错题不存在")

    wq.status = WrongQuestionStatus.pending
    db.commit()
    background_tasks.add_task(_process_wrong_question, wq.id)
    return _wq_to_out(wq)


@router.post("/wrong-questions/{question_id}/regenerate-solution", response_model=WrongQuestionOut)
async def regenerate_solution(
    question_id: uuid.UUID,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    wq = (
        db.query(WrongQuestion)
        .options(joinedload(WrongQuestion.subject), joinedload(WrongQuestion.student))
        .filter(WrongQuestion.id == question_id)
        .first()
    )
    if wq is None or wq.student.user_id != current_user.id:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="错题不存在")

    if not wq.question_text and not wq.ocr_raw_text:
        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="缺少题目内容")

    subject_name = wq.subject.name if wq.subject else "综合"
    school_level = wq.student.school_level if wq.student else None
    olympiad = wq.category == WrongQuestionCategory.olympiad
    question_text = wq.question_text or wq.ocr_raw_text or ""
    ai_cfg = llm_service.load_ai_config(db)

    try:
        if not wq.question_text and wq.ocr_raw_text:
            wq.question_text = await llm_service.format_question(
                ai_cfg, subject_name, wq.ocr_raw_text, school_level
            )
            question_text = wq.question_text
        solution_full = await llm_service.generate_solution(
            ai_cfg,
            subject_name,
            question_text,
            school_level,
            olympiad=olympiad,
        )
        approach, solution_body = annotation_service.split_solution_sections(solution_full)
        wq.solution_approach = approach
        wq.solution_text = solution_body if approach else solution_full
        wq.status = WrongQuestionStatus.solved
    except Exception as exc:
        raise HTTPException(
            status_code=status.HTTP_502_BAD_GATEWAY, detail=f"AI 调用失败: {exc}"
        ) from exc

    db.commit()
    db.refresh(wq)
    return _wq_to_out(wq)


@router.get("/wrong-questions/{question_id}/image")
def get_wrong_question_image(
    question_id: uuid.UUID,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    wq = (
        db.query(WrongQuestion)
        .options(joinedload(WrongQuestion.student))
        .filter(WrongQuestion.id == question_id)
        .first()
    )
    if wq is None or wq.student.user_id != current_user.id:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="错题不存在")

    image_full = Path(settings.UPLOAD_DIR) / wq.image_path
    if not image_full.exists():
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="图片不存在")
    return FileResponse(image_full)


@router.get("/wrong-questions/{question_id}/annotated-image")
def get_wrong_question_annotated_image(
    question_id: uuid.UUID,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    wq = (
        db.query(WrongQuestion)
        .options(joinedload(WrongQuestion.student))
        .filter(WrongQuestion.id == question_id)
        .first()
    )
    if wq is None or wq.student.user_id != current_user.id:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="错题不存在")
    if not wq.annotated_image_path:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="标注图尚未生成")

    image_full = Path(settings.UPLOAD_DIR) / wq.annotated_image_path
    if not image_full.exists():
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="标注图不存在")
    return FileResponse(image_full)