"""
Админ-панель - упрощенная версия через API эндпоинты
В будущем можно интегрировать полноценную админ-панель
"""
from __future__ import annotations

from fastapi import APIRouter, HTTPException
from typing import List
from uuid import UUID
from dishka.integrations.fastapi import FromDishka
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])
async def admin_list_users(
    skip: int = 0,
    limit: int = 100,
    current_user: User = FromDishka(),
    use_cases: UserUseCases = FromDishka()
):
    """Получить список всех пользователей (только для админов)"""
    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])
async def admin_list_collections(
    skip: int = 0,
    limit: int = 100,
    current_user: User = FromDishka(),
    use_cases: CollectionUseCases = FromDishka()
):
    """Получить список всех коллекций (только для админов)"""
    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]