"""教材 / 课程目录：读取对登录用户开放，增删改仅管理员。"""
from __future__ import annotations

from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy import func
from sqlalchemy.orm import Session

from database import get_db
from dependencies import get_current_user, require_permission
from models import (
    Chapter,
    EbookProgress,
    ChapterKnowledge,
    Knowledge,
    LlmSetting,
    Question,
    Textbook,
    User,
)
from schemas import (
    ChapterCreate,
    EbookProgressOut,
    ChapterOut,
    ChapterUpdate,
    ChaptersGenerateIn,
    ChaptersGenerateOut,
    ChaptersOrganizeIn,
    TextbookCreate,
    TextbookOut,
    TextbookUpdate,
)
from services import ebooks as ebook_store
from services.catalog_generator import (
    generate_chapters,
    organize_reference_chapters,
)
from services.isbn_lookup import fetch_isbn_context
from services.llm_config import get_default_channel
from services.knowledge_service import (
    set_chapter_knowledge_names,
    set_chapter_knowledge_ids,
)


router = APIRouter(prefix="/textbooks", tags=["catalog"])


def _chapter_out(db: Session, chapter: Chapter) -> ChapterOut:
    question_count = (
        db.query(func.count(Question.id))
        .filter(Question.chapter_id == chapter.id)
        .scalar()
        or 0
    )
    knowledge_rows = (
        db.query(Knowledge.id, Knowledge.name)
        .join(ChapterKnowledge, ChapterKnowledge.knowledge_id == Knowledge.id)
        .filter(ChapterKnowledge.chapter_id == chapter.id)
        .order_by(ChapterKnowledge.id.asc())
        .all()
    )
    knowledge_names = [name for _, name in knowledge_rows]
    return ChapterOut(
        id=chapter.id,
        textbook_id=chapter.textbook_id,
        name=chapter.name,
        position=chapter.position,
        summary=chapter.summary,
        ebook_page=chapter.ebook_page,
        question_count=question_count,
        knowledge_names=[str(name) for name in knowledge_names],
        knowledge_ids=[kid for kid, _ in knowledge_rows],
    )


def _textbook_out(
    db: Session, textbook: Textbook, user: User | None = None
) -> TextbookOut:
    chapters = (
        db.query(Chapter)
        .filter(Chapter.textbook_id == textbook.id)
        .order_by(Chapter.position.asc(), Chapter.id.asc())
        .all()
    )
    return TextbookOut(
        id=textbook.id,
        name=textbook.name,
        author=textbook.author,
        publisher=textbook.publisher,
        isbn=textbook.isbn,
        edition=textbook.edition,
        grade=textbook.grade,
        link=textbook.link,
        description=textbook.description,
        position=textbook.position,
        chapters=[_chapter_out(db, chapter) for chapter in chapters],
        ebook_file=textbook.ebook_file,
        ebook_format=textbook.ebook_format,
        ebook_name=textbook.ebook_name,
        ebook_size=textbook.ebook_size,
        ebook_pages=textbook.ebook_pages,
        ebook_uploaded_at=textbook.ebook_uploaded_at,
        ebook_progress=_ebook_progress_out(db, textbook, user),
    )


def _ebook_progress_out(
    db: Session, textbook: Textbook, user: User | None
) -> EbookProgressOut | None:
    if user is None or not textbook.ebook_file:
        return None
    row = (
        db.query(EbookProgress)
        .filter(
            EbookProgress.user_id == user.id,
            EbookProgress.textbook_id == textbook.id,
        )
        .first()
    )
    if row is None:
        return None
    return EbookProgressOut.model_validate(row)


def _load_textbook(db: Session, textbook_id: int) -> Textbook:
    textbook = db.get(Textbook, textbook_id)
    if textbook is None:
        raise HTTPException(status_code=404, detail="教材不存在")
    return textbook


def _resolve_channel(db: Session, channel_id: int | None) -> LlmSetting:
    if channel_id is not None:
        channel = db.get(LlmSetting, channel_id)
        if channel is None:
            raise HTTPException(status_code=404, detail="指定的模型通道不存在")
        return channel
    channel = get_default_channel(db)
    if channel is None:
        raise HTTPException(
            status_code=400,
            detail="尚未配置模型通道，请先在“模型配置”新增并设为默认",
        )
    return channel


def _book_graph_context(db: Session, textbook: Textbook) -> list[str]:
    name = textbook.name
    category_hints: list[str] = []
    if "代数" in name:
        category_hints = ["数与式", "方程与不等式", "函数与图像", "数列与证明"]
    elif "几何" in name:
        category_hints = ["平面几何"]
    elif "坐标" in name:
        category_hints = ["坐标与解析几何"]
    elif "三角" in name:
        category_hints = ["三角函数"]
    elif "函数" in name or "图像" in name:
        category_hints = ["函数与图像", "坐标与解析几何"]
    if category_hints:
        return [
            node_name
            for (node_name,) in db.query(Knowledge.name)
            .filter(Knowledge.category.in_(category_hints))
            .all()
        ]
    # 兜底：给常见初等图谱节点
    return [
        node_name
        for (node_name,) in db.query(Knowledge.name)
        .filter(Knowledge.domain == "初等", Knowledge.category != "总纲")
        .all()
    ]


@router.get("", response_model=list[TextbookOut])
def list_textbooks(
    db: Session = Depends(get_db),
    user: User = Depends(get_current_user),
):
    textbooks = (
        db.query(Textbook)
        .order_by(Textbook.position.asc(), Textbook.id.asc())
        .all()
    )
    return [_textbook_out(db, textbook, user) for textbook in textbooks]


@router.get("/{textbook_id}/chapters", response_model=list[ChapterOut])
def list_chapters(
    textbook_id: int,
    db: Session = Depends(get_db),
    _: User = Depends(get_current_user),
):
    textbook = _load_textbook(db, textbook_id)
    chapters = (
        db.query(Chapter)
        .filter(Chapter.textbook_id == textbook.id)
        .order_by(Chapter.position.asc(), Chapter.id.asc())
        .all()
    )
    return [_chapter_out(db, chapter) for chapter in chapters]


@router.post("", response_model=TextbookOut)
def create_textbook(
    payload: TextbookCreate,
    db: Session = Depends(get_db),
    _: User = Depends(require_permission("catalog:manage")),
):
    if db.query(Textbook).filter(Textbook.name == payload.name).first():
        raise HTTPException(status_code=400, detail="同名教材已存在")
    max_position = db.query(Textbook).count()
    textbook = Textbook(
        name=payload.name,
        author=payload.author,
        publisher=payload.publisher,
        isbn=payload.isbn,
        edition=payload.edition,
        grade=payload.grade,
        link=payload.link,
        description=payload.description,
        position=max_position,
    )
    db.add(textbook)
    db.commit()
    return _textbook_out(db, textbook)


@router.put("/{textbook_id}", response_model=TextbookOut)
def update_textbook(
    textbook_id: int,
    payload: TextbookUpdate,
    db: Session = Depends(get_db),
    _: User = Depends(require_permission("catalog:manage")),
):
    textbook = _load_textbook(db, textbook_id)
    fields = payload.model_dump(exclude_unset=True)
    if "name" in fields and fields["name"] != textbook.name:
        exists = (
            db.query(Textbook)
            .filter(Textbook.name == fields["name"], Textbook.id != textbook.id)
            .first()
        )
        if exists:
            raise HTTPException(status_code=400, detail="同名教材已存在")
    for field, value in fields.items():
        setattr(textbook, field, value)
    db.commit()
    return _textbook_out(db, textbook)


@router.delete("/{textbook_id}")
def delete_textbook(
    textbook_id: int,
    db: Session = Depends(get_db),
    _: User = Depends(require_permission("catalog:manage")),
):
    textbook = _load_textbook(db, textbook_id)
    question_count = (
        db.query(func.count(Question.id))
        .join(Chapter, Chapter.id == Question.chapter_id)
        .filter(Chapter.textbook_id == textbook.id)
        .scalar()
        or 0
    )
    if question_count > 0:
        raise HTTPException(
            status_code=400,
            detail=f"该书下还有 {question_count} 道题目，不能删除教材，只能修改",
        )
    db.query(Chapter).filter(Chapter.textbook_id == textbook.id).delete()
    ebook_store.drop_progress(db, textbook.id)
    ebook_store.drop_book_files(textbook.id)
    db.delete(textbook)
    db.commit()
    return {"deleted": textbook_id}


@router.post("/{textbook_id}/chapters", response_model=ChapterOut)
def create_chapter(
    textbook_id: int,
    payload: ChapterCreate,
    db: Session = Depends(get_db),
    _: User = Depends(require_permission("catalog:manage")),
):
    textbook = _load_textbook(db, textbook_id)
    chapter = Chapter(
        textbook_id=textbook.id,
        name=payload.name,
        position=db.query(Chapter).filter(Chapter.textbook_id == textbook.id).count(),
        summary=payload.summary,
    )
    db.add(chapter)
    db.flush()
    if payload.knowledge_ids:
        set_chapter_knowledge_ids(db, chapter.id, payload.knowledge_ids)
    else:
        set_chapter_knowledge_names(db, chapter.id, payload.knowledge_names)
    db.commit()
    return _chapter_out(db, chapter)


@router.post("/{textbook_id}/chapters/generate", response_model=ChaptersGenerateOut)
def generate_catalog_chapters(
    textbook_id: int,
    payload: ChaptersGenerateIn,
    db: Session = Depends(get_db),
    _: User = Depends(require_permission("catalog:manage")),
):
    textbook = _load_textbook(db, textbook_id)
    existing = (
        db.query(Chapter)
        .filter(Chapter.textbook_id == textbook.id)
        .order_by(Chapter.position.asc(), Chapter.id.asc())
        .all()
    )
    existing_names = {chapter.name for chapter in existing}
    external_context: dict = {}
    lookup_titles: list[str] = []
    if textbook.isbn:
        external_context = fetch_isbn_context(textbook.isbn)
        lookup_titles = external_context.get("chapter_titles") or []
    fixed_titles: list[str] | None = None
    generation_count = payload.count if payload.count is not None else 60
    source_note = "已结合书名 / ISBN / 作者信息自动获取章节"
    if lookup_titles:
        missing_titles = [
            title for title in lookup_titles if title not in existing_names
        ]
        if missing_titles:
            fixed_titles = missing_titles[:12]
            generation_count = len(fixed_titles)
            source_note = "已按 ISBN 查询到的正式章节名生成摘要"

    selected_names: list[str] = []
    if payload.knowledge_ids:
        rows = (
            db.query(Knowledge.name)
            .filter(Knowledge.id.in_(payload.knowledge_ids))
            .all()
        )
        selected_names = [name for (name,) in rows]
    else:
        selected_names = _book_graph_context(db, textbook)
    channel = _resolve_channel(db, payload.channel_id)
    if not channel.api_key or not channel.base_url or not channel.model:
        raise HTTPException(
            status_code=400, detail="模型通道未完整配置，请先补全并测试"
        )
    try:
        proposed = generate_chapters(
            setting=channel,
            textbook=textbook,
            count=generation_count,
            existing_names=sorted(existing_names),
            instructions=(
                f"可挂接的知识图谱节点参考：{'、'.join(selected_names)}。\n"
                if selected_names
                else ""
            ) + payload.instructions.strip(),
            fixed_titles=fixed_titles,
            external_context=external_context,
            graph_context=selected_names or None,
        )
    except ValueError as exc:
        raise HTTPException(status_code=400, detail=f"生成失败：{exc}") from exc

    max_position = (
        db.query(func.max(Chapter.position))
        .filter(Chapter.textbook_id == textbook.id)
        .scalar()
    )
    position = (max_position if max_position is not None else -1) + 1
    inserted: list[Chapter] = []
    skipped: list[str] = []
    for item in proposed:
        if item["name"] in existing_names:
            skipped.append(item["name"])
            continue
        existing_names.add(item["name"])
        chapter = Chapter(
            textbook_id=textbook.id,
            name=item["name"],
            summary=item["summary"],
            position=position,
        )
        db.add(chapter)
        db.flush()
        if payload.knowledge_ids:
            try:
                set_chapter_knowledge_ids(
                    db, chapter.id, payload.knowledge_ids
                )
            except ValueError as exc:
                raise HTTPException(status_code=400, detail=str(exc)) from exc
        else:
            item_names = item.get("knowledge_names") or []
            valid_names = [
                node_name
                for (node_name,) in (
                    db.query(Knowledge.name)
                    .filter(Knowledge.name.in_(item_names))
                    .all()
                )
            ] if item_names else []
            if valid_names:
                set_chapter_knowledge_names(db, chapter.id, valid_names)
        inserted.append(chapter)
        position += 1
    db.flush()
    created = [_chapter_out(db, chapter) for chapter in inserted]
    db.commit()
    message = f"{source_note}：已新增 {len(created)} 个章节" if source_note else f"已新增 {len(created)} 个章节"
    if skipped:
        message += f"，跳过重复章节 {len(skipped)} 个"
    return ChaptersGenerateOut(
        created=created,
        skipped_duplicates=skipped,
        message=message,
    )


@router.post("/{textbook_id}/chapters/organize", response_model=ChaptersGenerateOut)
def organize_textbook_chapters(
    textbook_id: int,
    payload: ChaptersOrganizeIn,
    db: Session = Depends(get_db),
    _: User = Depends(require_permission("catalog:manage")),
):
    textbook = _load_textbook(db, textbook_id)
    existing = (
        db.query(Chapter)
        .filter(Chapter.textbook_id == textbook.id)
        .order_by(Chapter.position.asc(), Chapter.id.asc())
        .all()
    )
    existing_names = {chapter.name for chapter in existing}
    channel = _resolve_channel(db, payload.channel_id)
    if not channel.api_key or not channel.base_url or not channel.model:
        raise HTTPException(
            status_code=400, detail="模型通道未完整配置，请先补全并测试"
        )
    graph_context = _book_graph_context(db, textbook)
    try:
        proposed = organize_reference_chapters(
            setting=channel,
            textbook=textbook,
            reference_text=payload.reference_text.strip(),
            existing_names=sorted(existing_names),
            graph_context=graph_context,
        )
    except ValueError as exc:
        raise HTTPException(status_code=400, detail=f"整理失败：{exc}") from exc

    max_position = (
        db.query(func.max(Chapter.position))
        .filter(Chapter.textbook_id == textbook.id)
        .scalar()
    )
    position = (max_position if max_position is not None else -1) + 1
    inserted: list[Chapter] = []
    skipped: list[str] = []
    for item in proposed:
        if item["name"] in existing_names:
            skipped.append(item["name"])
            continue
        existing_names.add(item["name"])
        chapter = Chapter(
            textbook_id=textbook.id,
            name=item["name"],
            summary=item["summary"],
            position=position,
        )
        db.add(chapter)
        db.flush()
        item_names = item.get("knowledge_names") or []
        valid_names = (
            [
                node_name
                for (node_name,) in (
                    db.query(Knowledge.name)
                    .filter(Knowledge.name.in_(item_names))
                    .all()
                )
            ]
            if item_names
            else []
        )
        if valid_names:
            set_chapter_knowledge_names(db, chapter.id, valid_names)
        inserted.append(chapter)
        position += 1
    created = [_chapter_out(db, chapter) for chapter in inserted]
    db.commit()
    message = f"AI 整理完成：已新增 {len(created)} 个章节并关联知识图谱"
    if skipped:
        message += f"，跳过重复 {len(skipped)} 个"
    return ChaptersGenerateOut(
        created=created,
        skipped_duplicates=skipped,
        message=message,
    )


@router.put("/chapters/{chapter_id}", response_model=ChapterOut)
def update_chapter(
    chapter_id: int,
    payload: ChapterUpdate,
    db: Session = Depends(get_db),
    _: User = Depends(require_permission("catalog:manage")),
):
    chapter = db.get(Chapter, chapter_id)
    if chapter is None:
        raise HTTPException(status_code=404, detail="章节不存在")
    update_fields = payload.model_dump(exclude_unset=True)
    knowledge_names = update_fields.pop("knowledge_names", None)
    knowledge_ids = update_fields.pop("knowledge_ids", None)
    for field, value in update_fields.items():
        setattr(chapter, field, value)
    if knowledge_ids is not None:
        try:
            set_chapter_knowledge_ids(db, chapter.id, knowledge_ids)
        except ValueError as exc:
            raise HTTPException(status_code=400, detail=str(exc)) from exc
    elif knowledge_names is not None:
        set_chapter_knowledge_names(db, chapter.id, knowledge_names)
    db.commit()
    return _chapter_out(db, chapter)


@router.delete("/chapters/{chapter_id}")
def delete_chapter(
    chapter_id: int,
    db: Session = Depends(get_db),
    _: User = Depends(require_permission("catalog:manage")),
):
    chapter = db.get(Chapter, chapter_id)
    if chapter is None:
        raise HTTPException(status_code=404, detail="章节不存在")
    question_count = (
        db.query(func.count(Question.id))
        .filter(Question.chapter_id == chapter.id)
        .scalar()
        or 0
    )
    if question_count > 0:
        raise HTTPException(
            status_code=400,
            detail=f"该章节下有 {question_count} 道题目，不能删除，只能修改章节",
        )
    db.delete(chapter)
    db.commit()
    return {"deleted": chapter_id}