"""
Админ-панель - упрощенная версия через API эндпоинты
В будущем можно интегрировать полноценную админ-панель
"""
from fastapi import APIRouter, HTTPException, Request
from typing import List, Annotated
from uuid import UUID
from dishka.integrations.fastapi import FromDishka, inject
from src.domain.repositories.user_repository import IUserRepository
from src.presentation.middleware.auth_middleware import get_current_user
from src.presentation.schemas.user_schemas import UserResponse
from src.presentation.schemas.collection_schemas import CollectionResponse
from src.presentation.schemas.document_schemas import DocumentResponse
from src.presentation.schemas.conversation_schemas import ConversationResponse
from src.presentation.schemas.message_schemas import MessageResponse
from src.domain.entities.user import User, UserRole
from src.application.use_cases.user_use_cases import UserUseCases
from src.application.use_cases.collection_use_cases import CollectionUseCases

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


@router.get("/users", response_model=List[UserResponse])
@inject
async def admin_list_users(
    request: Request,
    user_repo: Annotated[IUserRepository, FromDishka()],
    use_cases: Annotated[UserUseCases, FromDishka()],
    skip: int = 0,
    limit: int = 100
):
    """Получить список всех пользователей (только для админов)"""
    current_user = await get_current_user(request, user_repo)
    if not current_user.is_admin():
        raise HTTPException(status_code=403, detail="Требуются права администратора")
    users = await use_cases.list_users(skip=skip, limit=limit)
    return [UserResponse.from_entity(user) for user in users]


@router.get("/collections", response_model=List[CollectionResponse])
@inject
async def admin_list_collections(
    request: Request,
    user_repo: Annotated[IUserRepository, FromDishka()],
    use_cases: Annotated[CollectionUseCases, FromDishka()],
    skip: int = 0,
    limit: int = 100
):
    """Получить список всех коллекций (только для админов)"""
    current_user = await get_current_user(request, user_repo)
    from src.infrastructure.database.base import AsyncSessionLocal
    from src.infrastructure.repositories.postgresql.collection_repository import PostgreSQLCollectionRepository
    from sqlalchemy import select
    from src.infrastructure.database.models import CollectionModel
    
    async with AsyncSessionLocal() as session:
        repo = PostgreSQLCollectionRepository(session)
        result = await session.execute(
            select(CollectionModel).offset(skip).limit(limit)
        )
        db_collections = result.scalars().all()
        collections = [repo._to_entity(c) for c in db_collections if c]
        return [CollectionResponse.from_entity(c) for c in collections if c]