"""经验知识库路由"""
import json
from typing import List, Optional
from fastapi import APIRouter, Depends, HTTPException, Query
from sqlalchemy.orm import Session
from sqlalchemy import or_

from database import get_db
from models.user import User
from models.post import Post
from models.comment import Comment
from models.like import Like, Collect
from models.follow import Follow
from models.notification import Notification
from models.attachment import Attachment
from schemas.post import (
    PostCreate, PostUpdate, PostResponse, PostListResponse,
    CommentCreate, CommentResponse,
)
from routers.auth import get_current_user

router = APIRouter()


import re


def _extract_cover_image(content: str) -> str:
    """从Markdown内容中提取第一张图片作为封面"""
    if not content:
        return ""
    match = re.search(r'!\[.*?\]\((.*?)\)', content)
    if match:
        return match.group(1)
    img_match = re.search(r'<img[^>]+src=["\']([^"\']+)["\']', content)
    if img_match:
        return img_match.group(1)
    return ""


def _enrich_post_with_author(post: Post, db: Session) -> dict:
    """为帖子附加作者信息（用于信息流）"""
    author = db.query(User).filter(User.id == post.user_id).first()
    return {
        "id": post.id, "title": post.title, "content": post.content[:200],
        "category": post.category, "tags": post.tags,
        "cover_image": _extract_cover_image(post.content),
        "view_count": post.view_count, "like_count": post.like_count,
        "comment_count": post.comment_count, "collect_count": post.collect_count,
        "created_at": post.created_at, "updated_at": post.updated_at,
        "author": {
            "id": post.user_id,
            "username": author.username if author else "未知",
            "avatar": author.avatar if author else "",
        },
    }


@router.get("/feed")
def get_feed(
    page: int = 1, page_size: int = 20,
    category: Optional[str] = None,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """关注的人的帖子流"""
    following_ids = [f.following_id for f in db.query(Follow.following_id).filter(Follow.follower_id == current_user.id).all()]
    if not following_ids:
        return {"items": [], "total": 0, "page": page, "page_size": page_size}
    query = db.query(Post).filter(Post.user_id.in_(following_ids), Post.is_public == True, Post.is_draft == False)
    if category:
        query = query.filter(Post.category == category)
    total = query.count()
    posts = (
        query.order_by(Post.created_at.desc())
        .offset((page - 1) * page_size).limit(page_size).all()
    )
    return {"items": [_enrich_post_with_author(p, db) for p in posts], "total": total, "page": page, "page_size": page_size}


@router.get("/hot")
def get_hot_posts(
    page: int = 1, page_size: int = 20,
    category: Optional[str] = None,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """热门帖子（按热度排序）"""
    query = db.query(Post).filter(Post.is_public == True, Post.is_draft == False)
    if category:
        query = query.filter(Post.category == category)
    total = query.count()
    posts = (
        query.order_by((Post.like_count * 3 + Post.comment_count * 2 + Post.view_count).desc())
        .offset((page - 1) * page_size).limit(page_size).all()
    )
    return {"items": [_enrich_post_with_author(p, db) for p in posts], "total": total, "page": page, "page_size": page_size}


@router.get("/latest")
def get_latest_posts(
    page: int = 1, page_size: int = 20,
    category: Optional[str] = None,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """最新帖子"""
    query = db.query(Post).filter(Post.is_public == True, Post.is_draft == False)
    if category:
        query = query.filter(Post.category == category)
    total = query.count()
    posts = (
        query.order_by(Post.created_at.desc())
        .offset((page - 1) * page_size).limit(page_size).all()
    )
    return {"items": [_enrich_post_with_author(p, db) for p in posts], "total": total, "page": page, "page_size": page_size}


@router.get("/drafts")
def get_drafts(
    page: int = 1, page_size: int = 20,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """获取当前用户的草稿列表"""
    query = db.query(Post).filter(Post.user_id == current_user.id, Post.is_draft == True)
    total = query.count()
    posts = query.order_by(Post.updated_at.desc()).offset((page - 1) * page_size).limit(page_size).all()
    return {
        "items": [_enrich_post(p, db, current_user.id) for p in posts],
        "total": total, "page": page, "page_size": page_size,
    }


def _enrich_post(post: Post, db: Session, current_user_id: int = None) -> PostResponse:
    """填充帖子额外字段"""
    author = db.query(User).filter(User.id == post.user_id).first()
    result = PostResponse.model_validate(post)
    result.author_name = author.username if author else "未知用户"
    if current_user_id:
        result.is_liked = db.query(Like).filter(
            Like.post_id == post.id, Like.user_id == current_user_id
        ).first() is not None
        result.is_collected = db.query(Collect).filter(
            Collect.post_id == post.id, Collect.user_id == current_user_id
        ).first() is not None
    return result


@router.get("", response_model=PostListResponse)
def get_posts(
    page: int = Query(1, ge=1),
    page_size: int = Query(20, ge=1, le=100),
    category: Optional[str] = None,
    tag: Optional[str] = None,
    user_id: Optional[int] = None,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """获取帖子列表"""
    query = db.query(Post).filter(
        or_(Post.is_public == True, Post.user_id == current_user.id),
        Post.is_draft == False,
    )
    if category:
        query = query.filter(Post.category == category)
    if tag:
        query = query.filter(Post.tags.contains(tag))
    if user_id:
        query = query.filter(Post.user_id == user_id)

    total = query.count()
    posts = query.order_by(Post.created_at.desc()).offset((page - 1) * page_size).limit(page_size).all()

    return PostListResponse(
        items=[_enrich_post(p, db, current_user.id) for p in posts],
        total=total,
        page=page,
        page_size=page_size,
    )


@router.post("", response_model=PostResponse)
def create_post(
    data: PostCreate,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """发布经验帖"""
    post = Post(
        user_id=current_user.id,
        title=data.title,
        content=data.content,
        category=data.category,
        tags=json.dumps(data.tags, ensure_ascii=False),
        is_public=data.is_public,
        is_draft=data.is_draft,
    )
    db.add(post)
    db.commit()
    db.refresh(post)
    return _enrich_post(post, db, current_user.id)


@router.get("/{post_id}", response_model=PostResponse)
def get_post(
    post_id: int,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """获取帖子详情"""
    post = db.query(Post).filter(Post.id == post_id).first()
    if not post:
        raise HTTPException(status_code=404, detail="帖子不存在")
    if not post.is_public and post.user_id != current_user.id:
        raise HTTPException(status_code=403, detail="无权访问")

    # 增加浏览量
    post.view_count += 1
    db.commit()
    db.refresh(post)

    return _enrich_post(post, db, current_user.id)


@router.put("/{post_id}", response_model=PostResponse)
def update_post(
    post_id: int,
    data: PostUpdate,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """编辑帖子"""
    # 管理员可以编辑任意帖子，普通用户只能编辑自己的
    if current_user.is_admin:
        post = db.query(Post).filter(Post.id == post_id).first()
    else:
        post = db.query(Post).filter(Post.id == post_id, Post.user_id == current_user.id).first()
    if not post:
        raise HTTPException(status_code=404, detail="帖子不存在或无权编辑")

    if data.title is not None:
        post.title = data.title
    if data.content is not None:
        post.content = data.content
    if data.category is not None:
        post.category = data.category
    if data.tags is not None:
        post.tags = json.dumps(data.tags, ensure_ascii=False)
    if data.is_public is not None:
        post.is_public = data.is_public
    if data.is_draft is not None:
        post.is_draft = data.is_draft

    db.commit()
    db.refresh(post)
    return _enrich_post(post, db, current_user.id)


@router.delete("/{post_id}")
def delete_post(
    post_id: int,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """删除帖子"""
    post = db.query(Post).filter(Post.id == post_id, Post.user_id == current_user.id).first()
    if not post:
        raise HTTPException(status_code=404, detail="帖子不存在或无权删除")

    db.query(Comment).filter(Comment.post_id == post_id).delete()
    db.query(Like).filter(Like.post_id == post_id).delete()
    db.query(Collect).filter(Collect.post_id == post_id).delete()
    db.query(Attachment).filter(Attachment.post_id == post_id).delete()
    db.delete(post)
    db.commit()
    return {"message": "删除成功"}


@router.post("/{post_id}/like")
def toggle_like(
    post_id: int,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """点赞/取消点赞"""
    post = db.query(Post).filter(Post.id == post_id).first()
    if not post:
        raise HTTPException(status_code=404, detail="帖子不存在")

    existing = db.query(Like).filter(
        Like.post_id == post_id, Like.user_id == current_user.id
    ).first()

    if existing:
        db.delete(existing)
        post.like_count = max(0, post.like_count - 1)
        db.commit()
        return {"liked": False, "like_count": post.like_count}
    else:
        db.add(Like(post_id=post_id, user_id=current_user.id))
        post.like_count += 1
        # 通知帖子作者
        if post.user_id != current_user.id:
            db.add(Notification(
                user_id=post.user_id, type="like",
                content=f"{current_user.username} 赞了你的文章「{post.title[:30]}」",
                from_user_id=current_user.id, related_id=post_id,
            ))
        db.commit()
        return {"liked": True, "like_count": post.like_count}


@router.post("/{post_id}/collect")
def toggle_collect(
    post_id: int,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """收藏/取消收藏"""
    post = db.query(Post).filter(Post.id == post_id).first()
    if not post:
        raise HTTPException(status_code=404, detail="帖子不存在")

    existing = db.query(Collect).filter(
        Collect.post_id == post_id, Collect.user_id == current_user.id
    ).first()

    if existing:
        db.delete(existing)
        post.collect_count = max(0, post.collect_count - 1)
        db.commit()
        return {"collected": False, "collect_count": post.collect_count}
    else:
        db.add(Collect(post_id=post_id, user_id=current_user.id))
        post.collect_count += 1
        db.commit()
        return {"collected": True, "collect_count": post.collect_count}


@router.get("/{post_id}/comments", response_model=List[CommentResponse])
def get_comments(
    post_id: int,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """获取评论列表"""
    comments = (
        db.query(Comment)
        .filter(Comment.post_id == post_id)
        .order_by(Comment.created_at.asc())
        .all()
    )
    results = []
    for c in comments:
        author = db.query(User).filter(User.id == c.user_id).first()
        r = CommentResponse.model_validate(c)
        r.author_name = author.username if author else "未知用户"
        results.append(r)
    return results


@router.post("/{post_id}/comments", response_model=CommentResponse)
def create_comment(
    post_id: int,
    data: CommentCreate,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """发表评论"""
    post = db.query(Post).filter(Post.id == post_id).first()
    if not post:
        raise HTTPException(status_code=404, detail="帖子不存在")

    comment = Comment(
        post_id=post_id,
        user_id=current_user.id,
        content=data.content,
    )
    db.add(comment)
    post.comment_count += 1
    # 通知帖子作者
    if post.user_id != current_user.id:
        db.add(Notification(
            user_id=post.user_id, type="comment",
            content=f"{current_user.username} 评论了你的文章「{post.title[:30]}」",
            from_user_id=current_user.id, related_id=post_id,
        ))
    db.commit()
    db.refresh(comment)

    result = CommentResponse.model_validate(comment)
    result.author_name = current_user.username
    return result


@router.get("/{post_id}/attachments")
def get_attachments(
    post_id: int,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """获取帖子的附件列表"""
    attachments = (
        db.query(Attachment)
        .filter(Attachment.post_id == post_id)
        .order_by(Attachment.created_at.asc())
        .all()
    )
    return [
        {
            "id": a.id,
            "filename": a.filename,
            "url": a.url,
            "file_size": a.file_size,
            "file_type": a.file_type,
            "created_at": a.created_at,
        }
        for a in attachments
    ]


@router.delete("/{post_id}/attachments/{attachment_id}")
def delete_attachment(
    post_id: int,
    attachment_id: int,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """删除附件（仅作者）"""
    attachment = db.query(Attachment).filter(
        Attachment.id == attachment_id,
        Attachment.post_id == post_id,
        Attachment.user_id == current_user.id,
    ).first()
    if not attachment:
        raise HTTPException(status_code=404, detail="附件不存在或无权删除")
    db.delete(attachment)
    db.commit()
    return {"message": "删除成功"}