from fastapi import APIRouter, HTTPException, Query
from typing import Optional
from app.services.article_service import ArticleService
from app.services.comment_service import CommentService
from app.services.outlet_service import OutletService
from app.models.article import ArticleList, Article, ArticleSummary
from app.models.comment import Comment, CommentCreate, CommentList
from app.models.outlet import Outlet
from typing import List

router = APIRouter()

@router.get("/{language}/articles", response_model=ArticleList)
async def get_articles(
    language: str,
    page: int = Query(1, ge=1, description="Page number"),
    page_size: int = Query(20, ge=1, le=100, description="Items per page"),
    category: Optional[str] = Query(None, description="Filter by category")
):
    """기사 목록 조회"""
    if not ArticleService.validate_language(language):
        raise HTTPException(status_code=400, detail=f"Unsupported language: {language}")

    return await ArticleService.get_articles(language, page, page_size, category)

@router.get("/{language}/articles/latest", response_model=List[ArticleSummary])
async def get_latest_articles(
    language: str,
    limit: int = Query(10, ge=1, le=50, description="Number of articles")
):
    """최신 기사 조회"""
    if not ArticleService.validate_language(language):
        raise HTTPException(status_code=400, detail=f"Unsupported language: {language}")

    return await ArticleService.get_latest_articles(language, limit)

@router.get("/{language}/articles/search", response_model=ArticleList)
async def search_articles(
    language: str,
    q: str = Query(..., min_length=1, description="Search keyword"),
    page: int = Query(1, ge=1, description="Page number"),
    page_size: int = Query(20, ge=1, le=100, description="Items per page")
):
    """기사 검색"""
    if not ArticleService.validate_language(language):
        raise HTTPException(status_code=400, detail=f"Unsupported language: {language}")

    return await ArticleService.search_articles(language, q, page, page_size)

@router.get("/{language}/articles/{article_id}", response_model=Article)
async def get_article_by_id(
    language: str,
    article_id: str
):
    """ID로 기사 조회"""
    if not ArticleService.validate_language(language):
        raise HTTPException(status_code=400, detail=f"Unsupported language: {language}")

    article = await ArticleService.get_article_by_id(language, article_id)
    if not article:
        raise HTTPException(status_code=404, detail="Article not found")

    return article

@router.get("/{language}/categories", response_model=List[str])
async def get_categories(language: str):
    """카테고리 목록 조회"""
    if not ArticleService.validate_language(language):
        raise HTTPException(status_code=400, detail=f"Unsupported language: {language}")

    return await ArticleService.get_categories(language)

@router.get("/outlets")
async def get_outlets(category: Optional[str] = Query(None, description="Filter by category: people, topics, companies")):
    """Get outlets list - people, topics, companies"""
    if category:
        # Get outlets for specific category
        outlets = await OutletService.get_all_outlets(category=category)
        return {category: outlets}

    # Get all outlets grouped by category
    result = {}
    for cat in ['people', 'topics', 'companies']:
        outlets = await OutletService.get_all_outlets(category=cat)
        result[cat] = outlets

    return result

@router.get("/outlets/{outlet_id}")
async def get_outlet_by_id(outlet_id: str):
    """Get specific outlet by ID (_id)"""
    outlet = await OutletService.get_outlet_by_id(outlet_id)
    return outlet

@router.get("/{language}/outlets/{outlet_id}/articles")
async def get_outlet_articles(
    language: str,
    outlet_id: str,
    page: int = Query(1, ge=1, description="Page number"),
    page_size: int = Query(20, ge=1, le=100, description="Items per page")
):
    """Get articles for a specific outlet using source_keyword"""
    if not ArticleService.validate_language(language):
        raise HTTPException(status_code=400, detail=f"Unsupported language: {language}")

    # Get outlet to retrieve source_keyword
    outlet = await OutletService.get_outlet_by_id(outlet_id)

    # Query articles by source_keyword dynamically
    articles_result = await ArticleService.get_articles_by_source_keyword(
        language,
        outlet['source_keyword'],
        page,
        page_size
    )

    return articles_result

# Comment endpoints
@router.get("/comments", response_model=CommentList)
async def get_comments(article_id: str = Query(..., alias="articleId")):
    """Get comments for an article"""
    return await CommentService.get_comments_by_article(article_id)

@router.post("/comments", response_model=Comment)
async def create_comment(comment: CommentCreate):
    """Create a new comment"""
    return await CommentService.create_comment(comment)

@router.get("/articles/{article_id}/comment-count")
async def get_comment_count(article_id: str):
    """Get comment count for an article"""
    count = await CommentService.get_comment_count(article_id)
    return {"count": count}