import pytest
import os
import tempfile
import logging
from sqlmodel import Session, SQLModel, create_engine
from fastapi.testclient import TestClient
from typing import Generator

# Configure logging for tests
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Test database configuration
_test_db_fd, test_db_file = tempfile.mkstemp(suffix=".db")
os.close(_test_db_fd)
test_engine = create_engine(
    f"sqlite:///{test_db_file}", 
    connect_args={"check_same_thread": False},
    echo=False  # Set to True for SQL debugging
)

def get_test_session() -> Generator[Session, None, None]:
    """Generate test database session"""
    with Session(test_engine) as session:
        try:
            yield session
        except Exception as e:
            session.rollback()
            logger.exception("Database session error")
            raise
        finally:
            session.close()

@pytest.fixture(scope="session", autouse=True)
def setup_test_db():
    """Set up test database for the entire test session"""
    logger.info("Setting up test database")
    
    # Override database dependency before importing app
    import db
    db.engine = test_engine
    from app.core.config import settings
    settings.TESTING = True
    from db import get_session
    from main import app
    from app.core.middleware import JWTAuthenticationMiddleware
    from fastapi import Request
    from starlette.types import Scope, Receive, Send
    from starlette.datastructures import Headers
    
    class TestJWTAuthenticationMiddleware(JWTAuthenticationMiddleware):
        async def __call__(self, scope: Scope, receive: Receive, send: Send):
            if scope["type"] not in ("http", "websocket"):
                await self.app(scope, receive, send)
                return

            headers = Headers(scope=scope)
            auth_header = headers.get("Authorization")
            if auth_header and auth_header.startswith("Bearer "):
                await super().__call__(scope, receive, send)
                return

            if "state" not in scope:
                scope["state"] = {}
            scope["state"]["user_id"] = 999999
            scope["state"]["role"] = "admin"
            scope["state"]["email"] = "admin@example.com"

            from app.core.security import current_user_var
            token_token = current_user_var.set({
                "user_id": 999999,
                "role": "admin",
                "email": "admin@example.com"
            })
            try:
                await self.app(scope, receive, send)
            finally:
                current_user_var.reset(token_token)
            
    app.user_middleware = [m for m in app.user_middleware if m.cls != JWTAuthenticationMiddleware]
    app.middleware_stack = None
    app.add_middleware(TestJWTAuthenticationMiddleware)
    
    app.dependency_overrides[get_session] = get_test_session
    
    # Create all tables
    SQLModel.metadata.create_all(test_engine)
    logger.info("Test database tables created")
    
    yield
    
    # Cleanup
    logger.info("Cleaning up test database")
    try:
        SQLModel.metadata.drop_all(test_engine)
        test_engine.dispose()
        if os.path.exists(test_db_file):
            os.remove(test_db_file)
        logger.info("Test database cleanup completed")
    except Exception as e:
        logger.warning(f"Test database cleanup failed: {e}")

@pytest.fixture(scope="function")
def client() -> TestClient:
    """Create a test client for each test function"""
    from main import app
    from db import get_session
    app.dependency_overrides[get_session] = get_test_session
    return TestClient(app)

@pytest.fixture(scope="function")
def db_session() -> Generator[Session, None, None]:
    """Create a database session for each test function"""
    with Session(test_engine) as session:
        try:
            yield session
        except Exception:
            session.rollback()
            raise
        finally:
            session.close()

@pytest.fixture(autouse=True)
def cleanup_test_data(db_session: Session):
    """Clean up test data after each test"""
    yield
    # Clean up any test data that might interfere with other tests
    try:
        # This will be called after each test
        db_session.commit()
    except Exception as e:
        logger.warning(f"Test cleanup warning: {e}")
        db_session.rollback()

# Performance monitoring fixture
@pytest.fixture
def performance_monitor():
    """Monitor test performance"""
    import time
    start_time = time.time()
    yield
    end_time = time.time()
    duration = end_time - start_time
    if duration > 5.0:  # Log slow tests
        logger.warning(f"Slow test detected: {duration:.2f} seconds")