import json
import uuid
from concurrent.futures import ThreadPoolExecutor, TimeoutError as FuturesTimeout
from datetime import datetime, timedelta, timezone
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, SystemSettings, 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 import ocr_filter as ocr_filter_service
from app.services.student_access import get_student_for_user

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


def _short_error(exc: BaseException, prefix: str = "") -> str:
    msg = str(exc).strip() or type(exc).__name__
    if len(msg) > 500:
        msg = msg[:500] + "…"
    return f"{prefix}{msg}" if prefix else msg


def _is_still_processing(wq: WrongQuestion) -> bool:
    if wq.status == WrongQuestionStatus.pending:
        return True
    if wq.status == WrongQuestionStatus.ocr_done and not wq.question_text and not wq.error_message:
        return True
    return False


def _expire_stale_processing(wq: WrongQuestion, db: Session) -> None:
    if not _is_still_processing(wq):
        return
    created = wq.created_at
    if created.tzinfo is None:
        created = created.replace(tzinfo=timezone.utc)
    age = datetime.now(timezone.utc) - created
    if age <= timedelta(minutes=settings.PROCESS_STALE_MINUTES):
        return
    wq.status = WrongQuestionStatus.failed
    wq.error_message = f"处理超时（超过 {settings.PROCESS_STALE_MINUTES} 分钟），请点击「重新识别标注」重试"
    db.commit()


def _ocr_service_url(db: Session) -> str | None:
    row = db.get(SystemSettings, 1)
    if row and row.ocr_service_url:
        return row.ocr_service_url.strip() or None
    return ocr_service.resolve_ocr_service_url()


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),
        has_cropped_image=bool(wq.cropped_image_path),
        error_message=wq.error_message,
        status=wq.status,
        created_at=wq.created_at,
    )


async def _run_ai_pipeline(
    wq: WrongQuestion,
    db: Session,
    ocr_lines: list[dict],
    printed_text: str,
    *,
    hw_indices: list[int] | None = None,
):
    import asyncio

    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)
    timeout = settings.AI_TIMEOUT_SECONDS

    candidate_indices = hw_indices if hw_indices else list(range(len(ocr_lines)))
    candidate_lines = [ocr_lines[i] for i in candidate_indices if 0 <= i < len(ocr_lines)]
    if not candidate_lines:
        candidate_lines = ocr_lines
        candidate_indices = list(range(len(ocr_lines)))

    try:
        detect_resp = await asyncio.wait_for(
            llm_service.detect_wrong_line_ids(ai_cfg, subject_name, candidate_lines, school_level),
            timeout=min(90, timeout),
        )
        local_wrong = annotation_service.parse_wrong_line_ids(detect_resp, candidate_lines)
        wrong_ids = [candidate_indices[i] for i in local_wrong if i < len(candidate_indices)]
    except Exception:
        local_wrong = annotation_service.heuristic_wrong_line_ids(candidate_lines)
        wrong_ids = [candidate_indices[i] for i in local_wrong if i < len(candidate_indices)]

    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
    )
    db.commit()

    question_text = await asyncio.wait_for(
        llm_service.format_question(ai_cfg, subject_name, printed_text, school_level),
        timeout=timeout,
    )
    solution_full = await asyncio.wait_for(
        llm_service.generate_solution(
            ai_cfg, subject_name, question_text, school_level, olympiad=olympiad
        ),
        timeout=timeout,
    )
    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
    wq.error_message = None


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

        wq.error_message = None
        image_full = Path(settings.UPLOAD_DIR) / wq.image_path
        ocr_url = _ocr_service_url(db)
        try:
            with ThreadPoolExecutor(max_workers=1) as pool:
                future = pool.submit(
                    ocr_service.run_ocr_with_regions, str(image_full), ocr_url
                )
                ocr_result = future.result(timeout=settings.OCR_TIMEOUT_SECONDS)
            ocr_text = ocr_result["text"]
            ocr_lines = ocr_result["lines"]
            img_height = int(ocr_result.get("height") or 0)
            printed_ids, hw_ids = ocr_filter_service.split_printed_handwriting(
                ocr_lines,
                img_height,
                answer_zone_ratio=settings.OCR_ANSWER_ZONE_RATIO,
                enabled=settings.OCR_FILTER_HANDWRITING,
            )
            printed_text = ocr_filter_service.text_from_indices(ocr_lines, printed_ids)
            if not printed_text:
                printed_text = ocr_text
            wq.ocr_raw_text = printed_text or None
            if not ocr_text:
                wq.status = WrongQuestionStatus.failed
                wq.error_message = "OCR 未识别到文字，请拍摄更清晰、光线充足的题目照片"
                db.commit()
                return
            wq.status = WrongQuestionStatus.ocr_done
            db.commit()
        except FuturesTimeout:
            wq.status = WrongQuestionStatus.failed
            wq.error_message = (
                f"OCR 识别超时（>{settings.OCR_TIMEOUT_SECONDS}秒），请点「重新识别标注」重试"
            )
            db.commit()
            return
        except Exception as exc:
            wq.status = WrongQuestionStatus.failed
            msg = _short_error(exc, "OCR 识别失败：")
            if "libGL" in str(exc):
                msg += " 请在服务器执行: sudo bash deploy/install-ocr-deps.sh && systemctl restart grade-archive"
            elif ocr_url:
                if "OCR 服务" not in msg:
                    msg += " 诊断: bash deploy/ocr-screen.sh status && bash deploy/ocr-worker/test-ocr.sh"
            wq.error_message = msg
            db.commit()
            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,
                    printed_text,
                    hw_indices=hw_ids,
                )
            )
            db.commit()
        except Exception as exc:
            wq.status = WrongQuestionStatus.failed
            detail = _short_error(exc, "AI 处理失败：")
            if "Timeout" in type(exc).__name__ or "timeout" in str(exc).lower():
                detail = "AI 处理超时，请检查 Ollama/OpenAI 是否可用后重试"
            wq.error_message = detail
            db.commit()
        finally:
            loop.close()
    except Exception as exc:
        if wq is not None:
            wq.status = WrongQuestionStatus.failed
            wq.error_message = _short_error(exc, "处理失败：")
            db.commit()
    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()
    for w in items:
        _expire_stale_processing(w, db)
    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="错题不存在")
    _expire_stale_processing(wq, db)
    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
    crop_full = Path(settings.UPLOAD_DIR) / wq.cropped_image_path if wq.cropped_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()
    if crop_full and crop_full.exists():
        crop_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
    wq.error_message = None
    wq.cropped_image_path = None
    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)


@router.get("/wrong-questions/{question_id}/cropped-image")
def get_wrong_question_cropped_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.cropped_image_path:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="裁剪图尚未生成")

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