import os

# Set dummy environment variables for testing
os.environ["DATABASE_HOSTNAME"] = "localhost"
os.environ["DATABASE_CREDENTIAL_USER"] = "test"
os.environ["DATABASE_CREDENTIAL_PASSWORD"] = "test"
os.environ["COLLECTOR_CREDENTIAL_USER"] = "test"
os.environ["COLLECTOR_CREDENTIAL_PASSWORD"] = "test"
os.environ["DEV_USERNAME"] = "test"
os.environ["DEV_PASSWORD"] = "test"

# import asyncio
# from typing import AsyncGenerator, Generator
# import pytest
# import pytest_asyncio
# from httpx import AsyncClient, ASGITransport
# from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
# from sqlalchemy.orm import sessionmaker
# from sqlalchemy.pool import StaticPool
# from fastapi import Request

# from src.main import app
# from src.database.core import Base, get_db, get_collector_db
# from src.auth.service import JWTBearer
# from src.auth.model import UserBase

# # Import all models to register them with Base
# import src.acquisition_cost.model
# import src.equipment.model
# import src.equipment_master.model
# import src.manpower_cost.model
# import src.manpower_master.model
# import src.masterdata.model
# import src.masterdata_simulations.model
# import src.plant_fs_transaction_data.model
# import src.plant_masterdata.model
# import src.plant_transaction_data.model
# import src.plant_transaction_data_simulations.model
# import src.simulations.model
# import src.uploaded_file.model
# import src.yeardata.model

# # Test database URL
# TEST_DATABASE_URL = "sqlite+aiosqlite:///:memory:"

# engine = create_async_engine(
#     TEST_DATABASE_URL,
#     connect_args={"check_same_thread": False},
#     poolclass=StaticPool,
# )

# TestingSessionLocal = sessionmaker(
#     engine,
#     class_=AsyncSession,
#     expire_on_commit=False,
#     autocommit=False,
#     autoflush=False,
# )

# def pytest_sessionfinish(session, exitstatus):
#     """
#     Called after whole test run finished, right before returning the exit status to the system.
#     Used here to dispose of all SQLAlchemy engines to prevent hanging.
#     """
#     from src.database.core import engine as db_engine, collector_engine
    
#     async def dispose_all():
#         # Dispose of both test engine and production engines
#         await engine.dispose()
#         await db_engine.dispose()
#         await collector_engine.dispose()

#     try:
#         loop = asyncio.get_event_loop()
#         if loop.is_running():
#             # If the loop is already running, we create a task
#             loop.create_task(dispose_all())
#         else:
#             loop.run_until_complete(dispose_all())
#     except Exception:
#         # Fallback for environment where no loop is available or loop is closed
#         try:
#             asyncio.run(dispose_all())
#         except Exception:
#             pass

# # Removed custom event_loop fixture

# @pytest_asyncio.fixture(autouse=True)
# async def setup_db():
#     async with engine.begin() as conn:
#         await conn.run_sync(Base.metadata.create_all)
#     yield
#     async with engine.begin() as conn:
#         await conn.run_sync(Base.metadata.drop_all)

# async def override_get_db(request: Request = None):
#     async with TestingSessionLocal() as session:
#         yield session

# app.dependency_overrides[get_db] = override_get_db
# app.dependency_overrides[get_collector_db] = override_get_db

# @pytest.fixture(autouse=True)
# def mock_auth(monkeypatch):
#     async def mock_call(self, request: Request):
#         user = UserBase(user_id="test-id", name="test-user", role="admin")
#         request.state.user = user
#         return user
#     monkeypatch.setattr(JWTBearer, "__call__", mock_call)

# @pytest_asyncio.fixture
# async def client() -> AsyncGenerator[AsyncClient, None]:
#     async with AsyncClient(transport=ASGITransport(app=app), base_url="http://test") as client:
#         yield client