from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy.future import select
from sqlalchemy import update, delete
from typing import List, Optional

from database import get_db
from models import KbArticle, User
from schemas import KbArticleCreate, KbArticleUpdate, KbArticleResponse
from auth import get_current_user, require_roles

router = APIRouter(prefix="/api/v1/kb", tags=["Knowledge Base"])

@router.get("/", response_model=List[KbArticleResponse])
async def get_articles(db: AsyncSession = Depends(get_db), current_user: User = Depends(get_current_user)):
    stmt = select(KbArticle).where(KbArticle.company_id == current_user.company_id).where(KbArticle.is_published == True).order_by(KbArticle.category)
    res = await db.execute(stmt)
    return res.scalars().all()

@router.get("/all", response_model=List[KbArticleResponse])
async def get_all_articles(db: AsyncSession = Depends(get_db), current_user: User = Depends(require_roles(["Administrador"]))):
    stmt = select(KbArticle).where(KbArticle.company_id == current_user.company_id).order_by(KbArticle.category)
    res = await db.execute(stmt)
    return res.scalars().all()

@router.post("/", response_model=KbArticleResponse)
async def create_article(article: KbArticleCreate, db: AsyncSession = Depends(get_db), current_user: User = Depends(require_roles(["Administrador"]))):
    new_art = KbArticle(
        title=article.title,
        content=article.content,
        category=article.category,
        is_published=article.is_published,
        author_id=current_user.id
    )
    db.add(new_art)
    await db.commit()
    await db.refresh(new_art)
    return new_art

@router.put("/{article_id}", response_model=KbArticleResponse)
async def update_article(article_id: int, article: KbArticleUpdate, db: AsyncSession = Depends(get_db), current_user: User = Depends(require_roles(["Administrador"]))):
    stmt = select(KbArticle).where(KbArticle.company_id == current_user.company_id).where(KbArticle.id == article_id)
    res = await db.execute(stmt)
    art = res.scalar_one_or_none()
    if not art:
        raise HTTPException(status_code=404, detail="Article not found")
        
    if article.title is not None: art.title = article.title
    if article.content is not None: art.content = article.content
    if article.category is not None: art.category = article.category
    if article.is_published is not None: art.is_published = article.is_published
    
    await db.commit()
    await db.refresh(art)
    return art

@router.delete("/{article_id}")
async def delete_article(article_id: int, db: AsyncSession = Depends(get_db), current_user: User = Depends(require_roles(["Administrador"]))):
    stmt = delete(KbArticle).where(KbArticle.id == article_id)
    await db.execute(stmt)
    await db.commit()
    return {"message": "Article deleted"}