"""
内容管理 API 路由
复用新闻资讯模块的核心逻辑，关联到新的栏目（columns）体系
"""
import html
import os
import re
import shutil
import subprocess
from datetime import datetime
from typing import Optional, List
from fastapi import APIRouter, Depends, HTTPException, Query
from sqlalchemy.orm import Session, joinedload
from sqlalchemy import func
from pydantic import BaseModel, Field
from pypinyin import lazy_pinyin

from app.models.article import Article
from app.models.column import ColumnModel
from app.models.image import Image
from app.routers.auth import get_current_admin
from app.utils.file_utils import cleanup_file_by_path
from app.database import get_db

router = APIRouter(tags=["内容管理"])


# ========== 辅助函数 ==========

def extract_summary(content: str, max_length: int = 100) -> str:
    """从 HTML/Markdown 内容中提取纯文本摘要"""
    if not content:
        return ""
    text = re.sub(r'<[^>]+>', '', content)
    text = html.unescape(text)
    text = re.sub(r'[#*_`~\[\]\(\)!>-]', '', text)
    text = re.sub(r'\s+', ' ', text).strip()
    if len(text) > max_length:
        return text[:max_length] + "..."
    return text


def generate_slug(text: str) -> str:
    """将中文标题转为拼音 slug"""
    if not text:
        return ""
    py = lazy_pinyin(text, style=0)
    slug = "-".join(py)
    slug = re.sub(r"[^a-zA-Z0-9-]", "", slug).lower()
    slug = re.sub(r"-+", "-", slug).strip("-")
    return slug or f"article-{int(__import__('time').time())}"


TEMP_STORAGE_PREFIX = "/storage/tmp/crawl"


def get_upload_dir():
    """获取上传目录路径"""
    from app.config import get_settings
    settings = get_settings()
    base_dir = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
    return os.path.join(base_dir, settings.UPLOAD_DIR)


def get_crawl_temp_dir():
    """获取采集临时目录 - 跨平台"""
    if os.name == 'nt':
        base_dir = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
        return os.path.join(base_dir, 'storage', 'tmp', 'crawl')
    return '/tmp/news_crawl'


def migrate_temp_images(content: str, cover_image: Optional[str], db: Session):
    """将内容中的临时图片迁移到正式目录，并写入 images 表"""
    upload_dir = get_upload_dir()
    temp_dir = get_crawl_temp_dir()

    temp_paths = set()
    if cover_image and cover_image.startswith(TEMP_STORAGE_PREFIX):
        temp_paths.add(cover_image)

    pattern = re.escape(TEMP_STORAGE_PREFIX) + r'/[^\\)"\'>\s]+'
    for match in re.finditer(pattern, content):
        temp_paths.add(match.group())

    if not temp_paths:
        return content, cover_image

    # 按年月分目录存储（与 batch_crawl / wechat_crawl 一致）
    year_month = datetime.now().strftime("%Y%m")
    dest_dir = os.path.join(upload_dir, year_month)
    os.makedirs(dest_dir, exist_ok=True)

    path_mapping = {}
    for temp_path in temp_paths:
        filename = os.path.basename(temp_path)
        temp_file = os.path.join(temp_dir, filename)
        if not os.path.exists(temp_file):
            continue
        dest_file = os.path.join(dest_dir, filename)
        shutil.move(temp_file, dest_file)

        thumb_filename = f"{os.path.splitext(filename)[0]}.jpg"
        temp_thumb = os.path.join(temp_dir, "thumbnails", thumb_filename)
        dest_thumb = os.path.join(upload_dir, "thumbnails", thumb_filename)
        if os.path.exists(temp_thumb):
            shutil.move(temp_thumb, dest_thumb)

        formal_path = f"/storage/admin/images/{year_month}/{filename}"
        formal_thumb = f"/storage/admin/images/thumbnails/{thumb_filename}"
        path_mapping[temp_path] = formal_path

        try:
            file_size = os.path.getsize(dest_file)
        except OSError:
            file_size = 0
        existing = db.query(Image).filter(Image.file_path == formal_path).first()
        if not existing:
            img_record = Image(
                filename=filename,
                original_name=filename,
                file_path=formal_path,
                thumb_path=formal_thumb,
                file_size=file_size,
                module="articles"
            )
            db.add(img_record)

    new_content = content
    for temp_path, formal_path in path_mapping.items():
        new_content = new_content.replace(temp_path, formal_path)

    new_cover = cover_image
    if cover_image and cover_image in path_mapping:
        new_cover = path_mapping[cover_image]

    return new_content, new_cover


def _validate_column_for_article(column_id: int, db: Session, exclude_article_id: Optional[int] = None):
    """校验栏目是否可关联内容：
    - 栏目必须存在
    - 顶级栏目若有二级栏目，则禁止直接关联内容
    """
    column = db.query(ColumnModel).filter(ColumnModel.id == column_id).first()
    if not column:
        raise HTTPException(status_code=404, detail="栏目不存在")
    # 如果是顶级栏目，检查是否有子栏目
    if column.parent_id is None:
        child_count = db.query(ColumnModel).filter(ColumnModel.parent_id == column_id).count()
        if child_count > 0:
            raise HTTPException(status_code=400, detail="该栏目存在子栏目，内容必须关联到子栏目")
    return column


# ========== Pydantic 模型 ==========

class ArticleCreate(BaseModel):
    title: str = Field(..., min_length=1, max_length=200)
    slug: Optional[str] = Field(None, max_length=200)
    content: str = Field(..., min_length=1)
    content_type: str = Field(default="markdown", pattern="^(markdown|html)$")
    summary: Optional[str] = Field(None, max_length=500)
    cover_image: Optional[str] = Field(None, max_length=500)
    column_id: int
    author: Optional[str] = Field(None, max_length=50)
    status: str = Field(default="draft", pattern="^(published|draft)$")
    sort_order: int = Field(default=0)


class ArticleUpdate(BaseModel):
    title: Optional[str] = Field(None, min_length=1, max_length=200)
    slug: Optional[str] = Field(None, min_length=1, max_length=200)
    content: Optional[str] = Field(None, min_length=1)
    content_type: Optional[str] = Field(None, pattern="^(markdown|html)$")
    summary: Optional[str] = Field(None, max_length=500)
    cover_image: Optional[str] = Field(None, max_length=500)
    column_id: Optional[int] = None
    author: Optional[str] = Field(None, max_length=50)
    status: Optional[str] = Field(None, pattern="^(published|draft)$")
    sort_order: Optional[int] = None


class ArticlePublish(BaseModel):
    is_published: bool


class BatchDelete(BaseModel):
    ids: List[int]


class BatchMove(BaseModel):
    ids: List[int]
    column_id: int


# ========== API ==========

@router.get("/admin/articles")
def list_articles(
    page: int = Query(default=1, ge=1),
    size: int = Query(default=10, ge=1, le=100),
    column_id: Optional[int] = Query(default=None),
    keyword: Optional[str] = Query(default=None),
    status: Optional[str] = Query(default=None, pattern="^(published|draft|rewriting|all)$"),
    db: Session = Depends(get_db),
    current_admin=Depends(get_current_admin),
):
    """获取内容列表（分页 + 筛选）"""
    query = db.query(Article).options(joinedload(Article.column))

    if column_id:
        query = query.filter(Article.column_id == column_id)

    if keyword:
        query = query.filter(Article.title.contains(keyword))

    if status == "published":
        query = query.filter(Article.status == "published")
    elif status == "draft":
        query = query.filter(Article.status == "draft")

    query = query.order_by(Article.updated_at.desc())

    total = query.count()
    articles = query.offset((page - 1) * size).limit(size).all()

    return {
        "items": [a.to_dict(include_content=False) for a in articles],
        "total": total,
        "page": page,
        "size": size
    }


@router.get("/admin/articles/{article_id}")
def get_article(
    article_id: int,
    db: Session = Depends(get_db),
    current_admin=Depends(get_current_admin),
):
    """获取内容详情"""
    article = db.query(Article).options(joinedload(Article.column)).filter(Article.id == article_id).first()
    if not article:
        raise HTTPException(status_code=404, detail="内容不存在")
    return article.to_dict(include_content=True)


@router.post("/admin/articles")
def create_article(
    data: ArticleCreate,
    db: Session = Depends(get_db),
    current_admin=Depends(get_current_admin),
):
    """创建内容"""
    # 校验栏目
    _validate_column_for_article(data.column_id, db)

    # 自动生成 slug
    slug = data.slug or generate_slug(data.title)
    if not slug:
        raise HTTPException(status_code=400, detail="URL标识生成失败，请手动填写")

    existing = db.query(Article).filter(Article.slug == slug).first()
    if existing:
        raise HTTPException(status_code=400, detail="内容标识已存在")

    # 自动生成摘要
    summary = data.summary
    if not summary:
        summary = extract_summary(data.content, max_length=100)

    # 迁移临时图片
    migrated_content, migrated_cover = migrate_temp_images(data.content, data.cover_image, db)

    article = Article(
        title=data.title,
        slug=slug,
        content=migrated_content,
        content_type=data.content_type,
        summary=summary,
        cover_image=migrated_cover,
        column_id=data.column_id,
        author=data.author,
        status=data.status,
        sort_order=data.sort_order,
    )
    db.add(article)
    db.commit()
    db.refresh(article)
    return article.to_dict(include_content=True)


@router.put("/admin/articles/{article_id}")
def update_article(
    article_id: int,
    data: ArticleUpdate,
    db: Session = Depends(get_db),
    current_admin=Depends(get_current_admin),
):
    """更新内容"""
    article = db.query(Article).filter(Article.id == article_id).first()
    if not article:
        raise HTTPException(status_code=404, detail="内容不存在")

    # 检查 slug 冲突
    slug = data.slug
    if slug is not None:
        if not slug.strip():
            slug = generate_slug(data.title or article.title)
        if slug != article.slug:
            existing = db.query(Article).filter(Article.slug == slug).first()
            if existing:
                raise HTTPException(status_code=400, detail="内容标识已存在")

    # 校验栏目
    if data.column_id is not None:
        _validate_column_for_article(data.column_id, db, exclude_article_id=article_id)

    update_data = data.model_dump(exclude_unset=True)
    if slug is not None:
        update_data["slug"] = slug

    # 摘要被清空时自动提取
    if "summary" in update_data and not update_data.get("summary", "").strip():
        content_to_extract = update_data.get("content") or article.content
        if content_to_extract:
            update_data["summary"] = extract_summary(content_to_extract, max_length=100)

    # 迁移临时图片（如果内容/封面包含临时路径）
    if update_data.get("content"):
        migrated_content, migrated_cover = migrate_temp_images(
            update_data["content"],
            update_data.get("cover_image") or article.cover_image,
            db,
        )
        update_data["content"] = migrated_content
        update_data["cover_image"] = migrated_cover

    for key, value in update_data.items():
        setattr(article, key, value)

    db.commit()
    db.refresh(article)
    return article.to_dict(include_content=True)


@router.delete("/admin/articles/{article_id}")
def delete_article(
    article_id: int,
    db: Session = Depends(get_db),
    current_admin=Depends(get_current_admin),
):
    """删除内容"""
    article = db.query(Article).filter(Article.id == article_id).first()
    if not article:
        raise HTTPException(status_code=404, detail="内容不存在")

    if article.cover_image:
        cleanup_file_by_path(article.cover_image)

    db.delete(article)
    db.commit()
    return {"message": "删除成功"}


@router.post("/admin/articles/batch-delete")
def batch_delete_articles(
    data: BatchDelete,
    db: Session = Depends(get_db),
    current_admin=Depends(get_current_admin),
):
    """批量删除内容"""
    articles = db.query(Article).filter(Article.id.in_(data.ids)).all()
    for article in articles:
        if article.cover_image:
            cleanup_file_by_path(article.cover_image)
        db.delete(article)
    db.commit()
    return {"message": f"成功删除 {len(articles)} 条内容"}


@router.post("/admin/articles/batch-move")
def batch_move_articles(
    data: BatchMove,
    db: Session = Depends(get_db),
    current_admin=Depends(get_current_admin),
):
    """批量转移栏目"""
    # 校验目标栏目
    _validate_column_for_article(data.column_id, db)

    articles = db.query(Article).filter(Article.id.in_(data.ids)).all()
    for article in articles:
        article.column_id = data.column_id
    db.commit()
    return {"message": f"成功转移 {len(articles)} 条内容"}


@router.post("/admin/articles/{article_id}/publish")
def publish_article(
    article_id: int,
    data: ArticlePublish,
    db: Session = Depends(get_db),
    current_admin=Depends(get_current_admin),
):
    """发布/取消发布内容"""
    article = db.query(Article).filter(Article.id == article_id).first()
    if not article:
        raise HTTPException(status_code=404, detail="内容不存在")

    article.status = "published" if data.is_published else "draft"
    db.commit()
    db.refresh(article)
    return article.to_dict()


# ========== 改写发布 ==========

VENV_PYTHON = "/mnt/datadisk0/www/new-media-platform/website-new/backend/.venv/bin/python3"
PIPELINE_PATH = "/mnt/datadisk0/www/new-media-platform/website-new/rewrite/pipeline.py"
LOG_FILE = "/mnt/datadisk0/www/new-media-platform/website-new/rewrite/logs/pipeline.log"


@router.post("/admin/articles/{article_id}/rewrite-publish")
def rewrite_publish_article(
    article_id: int,
    db: Session = Depends(get_db),
    current_admin=Depends(get_current_admin),
):
    """一键改写+发布到公众号（异步后台任务）"""
    article = db.query(Article).filter(Article.id == article_id).first()
    if not article:
        raise HTTPException(status_code=404, detail="内容不存在")

    if article.status != "draft":
        raise HTTPException(status_code=400, detail="只有草稿状态的内容可以改写发布")

    # 并发控制：检查是否有正在改写中的文章
    rewriting_count = db.query(Article).filter(
        Article.status == "rewriting"
    ).count()
    if rewriting_count > 0:
        raise HTTPException(status_code=429, detail="已有文章正在改写中，请稍后再试")

    # 设置为改写中
    article.status = "rewriting"
    db.commit()
    db.refresh(article)

    # 启动后台子进程，stderr 写入日志文件便于排查
    stderr_log = open(LOG_FILE, "a")
    subprocess.Popen(
        [VENV_PYTHON, PIPELINE_PATH, str(article_id)],
        stdout=stderr_log,
        stderr=stderr_log,
    )

    return {
        "message": "改写任务已启动",
        "article_id": article_id,
        "status": "rewriting",
    }


# ========== 访客端 Public API ==========

@router.get("/public/articles")
def list_public_articles(
    page: int = Query(default=1, ge=1),
    size: int = Query(default=10, ge=1, le=100),
    column_slug: Optional[str] = Query(default=None),
    db: Session = Depends(get_db),
):
    """访客端：获取已发布的内容列表"""
    query = db.query(Article).options(joinedload(Article.column)).filter(
        Article.status == "published"
    )

    # 如果指定了栏目 slug，筛选该栏目及其子栏目的内容
    if column_slug:
        column = db.query(ColumnModel).filter(
            ColumnModel.slug == column_slug,
            ColumnModel.is_enabled == True
        ).first()
        if column:
            # 获取该栏目及所有子栏目的 ID
            column_ids = [column.id]
            children = db.query(ColumnModel).filter(
                ColumnModel.parent_id == column.id
            ).all()
            column_ids.extend([c.id for c in children])
            query = query.filter(Article.column_id.in_(column_ids))

    query = query.order_by(Article.sort_order.asc(), Article.updated_at.desc())

    total = query.count()
    articles = query.offset((page - 1) * size).limit(size).all()

    return {
        "items": [a.to_dict(include_content=False) for a in articles],
        "total": total,
        "page": page,
        "size": size
    }


@router.get("/public/articles/{slug}")
def get_public_article(
    slug: str,
    db: Session = Depends(get_db),
):
    """访客端：通过 slug 获取内容详情"""
    article = db.query(Article).options(joinedload(Article.column)).filter(
        Article.slug == slug,
        Article.status == "published"
    ).first()

    if not article:
        raise HTTPException(status_code=404, detail="内容不存在")

    # 增加浏览次数
    article.view_count += 1
    db.commit()

    return article.to_dict(include_content=True)