"""Examples integration test fixtures."""

from collections.abc import Generator

from minio import Minio
import pytest
import redis

from python_repositories.config import MinioConfig, PostgresConfig, RedisConfig
from tests.integration.minio._containers import (
    minio_config_from_env,
    minio_env,
    raw_minio_client_from_env,
)
from tests.integration.redis._containers import (
    raw_redis_client_from_container,
    redis_config_from_container,
    redis_uri,
)
from tests.integration.postgres._containers import (
    postgres_config_from_container,
    postgres_uri,
    raw_postgres_client_from_container,
)


@pytest.fixture(scope="session")
def redis_container() -> Generator[str, None, None]:
    """Set up a Redis container for testing and yield the Redis URI."""
    yield from redis_uri()


@pytest.fixture(scope="session")
def redis_config(redis_container: str) -> RedisConfig:
    """Provide RedisConfig built from the test container."""
    return redis_config_from_container(redis_container)


@pytest.fixture(scope="session")
def raw_redis_client(redis_container: str) -> Generator[redis.Redis, None, None]:
    """Provide a raw Redis client connected to the test Redis container."""
    yield from raw_redis_client_from_container(redis_container)


@pytest.fixture(scope="session")
def minio_container() -> Generator[dict[str, str], None, None]:
    """Set up a Minio container for testing and yield connection settings."""
    yield from minio_env()


@pytest.fixture(scope="session")
def minio_config(minio_container: dict[str, str]) -> MinioConfig:
    """Provide MinioConfig built from the test container."""
    return minio_config_from_env(minio_container)


@pytest.fixture(scope="session")
def raw_minio_client(minio_container: dict[str, str]) -> Generator[Minio, None, None]:
    """Provide a raw Minio client connected to the test Minio container."""
    yield from raw_minio_client_from_env(minio_container)


@pytest.fixture(scope="session")
def postgres_container() -> Generator[str, None, None]:
    """Set up a Postgres container for testing and yield the Postgres URI."""
    yield from postgres_uri()


@pytest.fixture(scope="session")
def postgres_config(postgres_container: str) -> PostgresConfig:
    """Provide PostgresConfig built from the test container."""
    return postgres_config_from_container(postgres_container)


@pytest.fixture(scope="session")
def raw_postgres_client(
    postgres_container: str,
) -> Generator[object, None, None]:
    """Provide a raw Postgres client connected to the test Postgres container."""
    yield from raw_postgres_client_from_container(postgres_container)