from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import schema as sa_schema
from app.database.models import Inquilino  # Modelos `Inquilino`
from app.database.session import sessionmanager
from tenant import get_tenant_specific_metadata
from app.rbac.auth import get_user_db, get_user_manager
from app.rbac.schemas import UserCreate
from fastapi_users.exceptions import UserAlreadyExists
from sqlalchemy import select
from app.database.models import RbacUser
import contextlib


# Funções auxiliares para criação de usuários
get_async_session_context = contextlib.asynccontextmanager(sessionmanager.session)
get_user_db_context = contextlib.asynccontextmanager(get_user_db)
get_user_manager_context = contextlib.asynccontextmanager(get_user_manager)


async def create_user(email: str, password: str, is_superuser: bool = False, pessoa_uuid: str = None):
    """
    Cria um usuário no sistema utilizando o gerenciador de usuários do FastAPI Users.
    """
    async with get_async_session_context() as session:
        async with get_user_db_context(session) as user_db:
            async with get_user_manager_context(user_db) as user_manager:
                try:
                    user = await user_manager.create(
                        UserCreate(
                            email=email,
                            password=password,
                            is_superuser=is_superuser,
                            is_active=True,
                            fk_pessoa_uuid=pessoa_uuid,
                        )
                    )
                    return user.id
                except UserAlreadyExists:
                    print(f"Usuário {email} já existe")
                    result_user = await session.execute(select(RbacUser).filter_by(email=email))
                    existing_user = result_user.scalars().first()
                    return existing_user.id


async def tenant_create(nome: str, host: str, email: str, password: str) -> None:
    """
    Cria um novo tenant (inquilino) no sistema, configura o schema específico
    e registra um usuário inicial relacionado ao inquilino.
    """
    async with sessionmanager.session() as db:  # Obtendo uma sessão do gerenciador
        # Criar o inquilino na tabela `inquilinos`
        tenant = Inquilino(nome=nome)
        db.add(tenant)
        await db.commit()  # Commit necessário para o UUID ser gerado pelo banco

        # Obter o UUID gerado
        await db.refresh(tenant)
        schema_name = str(tenant.uuid)

        # Criar o schema do inquilino
        await db.execute(sa_schema.CreateSchema(schema_name))

        # Criar as tabelas específicas do tenant no novo schema
        tenant_metadata = get_tenant_specific_metadata()
        await db.run_sync(tenant_metadata.create_all)

        # Criar o usuário inicial para o tenant
        user_id = await create_user(
            email=email,
            password=password,
            is_superuser=True,
            pessoa_uuid=None,  # Ajustar caso seja necessário vincular com uma pessoa
        )
        print(f"Usuário inicial {email} criado com ID {user_id}")

        print(f"Tenant '{nome}' criado com sucesso no schema '{schema_name}'!")