# hotel/operations/interface.py
from typing import Protocol, List, Any

DataObject = dict[str, Any]

class DataInterface(Protocol):
    """
    Protocol defining the contract for data access.
    
    Any class implementing these methods can be used interchangeably,
    enabling dependency injection and test doubles.
    """
    
    def read_by_id(self, id: int) -> DataObject: ...
    def read_all(self) -> List[DataObject]: ...
    def create(self, data: DataObject) -> DataObject: ...
    def update(self, id: int, data: DataObject) -> DataObject: ...
    def delete(self, id: int) -> DataObject: ...

# hotel/db/db_interface.py
from typing import Any, List, Optional
from sqlalchemy.orm import Session
from hotel.db.models import Base, to_dict

DataObject = dict[str, Any]

class DBInterface:
    """
    Repository pattern implementation for database operations.
    
    KEY FEATURES:
    - Generic: Works with any SQLAlchemy model
    - Session injection: Supports test sessions
    - Encapsulation: All SQL hidden from business logic
    """
    
    def __init__(self, db_class: type[Base], session: Optional[Session] = None):
        """
        Args:
            db_class: SQLAlchemy model (DBCustomer, DBRoom, DBBooking)
            session: Optional session for testing (None = production)
        """
        self.db_class = db_class
        self._session = session

    def _get_session(self) -> Session:
        """Get test session or production session."""
        return self._session if self._session else engine.DBSession()

    def read_all(self) -> List[DataObject]:
        session = self._get_session()
        results = session.query(self.db_class).all()
        return [to_dict(result) for result in results]

    def create(self, data: DataObject) -> DataObject:
        session = self._get_session()
        result = self.db_class(**data)
        session.add(result)
        session.commit()
        return to_dict(result)
    
    # ... update, delete, read_by_id

# hotel/operations/bookings.py
from hotel.operations.interface import DataInterface, DataObject

def create_booking(
    data: BookingCreateData,
    booking_interface: DataInterface,  # ← Injected
    room_interface: DataInterface,     # ← Injected
) -> DataObject:
    """
    Business logic for booking creation.
    
    INJECTION PATTERN:
    - Interfaces passed as parameters
    - No direct database coupling
    - Can inject real DB or test stubs
    """
    # Get room details to calculate price
    room = room_interface.read_by_id(data.room_id)
    
    # Business logic: calculate price
    days = (data.to_date - data.from_date).days
    if days <= 0:
        raise InvalidDateError("Invalid booking dates")
    
    # Prepare booking with calculated price
    booking_dict = data.model_dump()
    booking_dict["price"] = room["price"] * days
    
    return booking_interface.create(booking_dict)

# hotel/routers/bookings.py (Production)
@router.post("/booking")
def api_create_booking(booking: BookingCreateData):
    # Inject REAL database interfaces
    booking_interface = DBInterface(DBBooking)
    room_interface = DBInterface(DBRoom)
    
    return create_booking(booking, booking_interface, room_interface)

# hotel/tests/unit/test_bookings.py (Testing)
from hotel.tests.utils import booking_sample

def test_read_booking_by_id():
    # Inject TEST STUBS instead
    booking_stub = BookingStub()
    
    result = read_booking_by_id(1, booking_stub)
    expected = booking_sample()
    
    for field, value in expected.items():
        assert result[field] == value

# hotel/tests/unit/test_bookings.py
"""
Unit Tests for Booking Operations

TESTING APPROACH:
- Tests business logic in isolation using stub interfaces
- No database or external dependencies
- Fast execution, focused on operation layer logic

ARCHITECTURE:
Operations (business logic) → Stub Interface (fake data)
"""

from hotel.tests.utils import assert_booking_valid, booking_sample

@pytest.mark.unit
class TestBookingOperations:

    def test_read_booking_by_id(self, booking_stub):
        """Validate booking lookup returns canonical sample."""

        result = read_booking_by_id(1, booking_stub)

        assert_booking_valid(result)
        expected = booking_sample()
        for field, value in expected.items():
            assert result[field] == value

    def test_create_booking_calculates_price(
        self,
        booking_stub,
        room_stub,
        sample_booking_data
    ):
        """Verify create_booking calculates price using injected room."""

        result = create_booking(sample_booking_data, booking_stub, room_stub)

        assert_booking_valid(result)
        assert result["price"] == 300  # 3 nights × 100

# hotel/tests/stubs/booking_stub.py
from hotel.db.db_interface import DataObject
from hotel.tests.stubs.stub_interface import DataStubInterface

class BookingStub(DataStubInterface):
    """
    Test double providing configurable booking data.
    
    PATTERN: Stub (not mock!)
    - Returns predictable data
    - Allows per-test overrides via constructor
    - Keeps implementation intentionally simple
    """

    def __init__(self, bookings: list[DataObject] | None = None) -> None:
        self._bookings = bookings or [
            {
                "id": 1,
                "from_date": "2025-12-20",
                "to_date": "2025-12-22",
                "price": 200,
                "customer_id": 1,
                "room_id": 1,
            },
            {
                "id": 2,
                "from_date": "2025-12-23",
                "to_date": "2025-12-25",
                "price": 300,
                "customer_id": 2,
                "room_id": 2,
            },
        ]

    def read_by_id(self, id: int) -> DataObject:
        booking = next((b for b in self._bookings if b["id"] == id), dict(self._bookings[0]))
        booking["id"] = id  # Preserve requested id for clarity
        return booking

    def read_all(self) -> list[DataObject]:
        return [dict(b) for b in self._bookings]

    def create(self, data: DataObject) -> DataObject:
        booking = dict(data)
        booking["id"] = 999  # Stub ID
        return booking

# hotel/tests/utils.py
from typing import Any

def booking_sample(overrides: dict[str, Any] | None = None) -> dict[str, Any]:
    sample = {
        "id": 1,
        "from_date": "2025-12-20",
        "to_date": "2025-12-22",
        "price": 200,
        "customer_id": 1,
        "room_id": 1,
    }
    if overrides:
        sample.update(overrides)
    return sample

# hotel/tests/integration/test_booking_db.py
"""
Integration tests for booking database operations.

TESTING APPROACH:
- Tests interact with REAL database (in-memory SQLite)
- No mocks or stubs - testing actual DB layer
- Verifies database constraints, relationships, and CRUD operations

ARCHITECTURE:
DBInterface → SQLAlchemy → In-Memory SQLite
"""

@pytest.mark.integration
@pytest.mark.database
class TestBookingDatabaseOperations:
    
    def test_create_booking_persists_to_database(
        self,
        booking_db_interface,  # ← Real DBInterface
        customer_factory,
        room_factory,
        test_db_session       # ← Real SQLAlchemy session
    ):
        """Test that creating a booking persists data to database."""
        # Arrange - Create dependencies in DB
        customer = customer_factory(first_name="Alice")
        room = room_factory(number="101", price=100)
        
        booking_data = {
            "customer_id": customer.id,
            "room_id": room.id,
            "from_date": date(2025, 12, 25),
            "to_date": date(2025, 12, 28),
            "price": 300
        }
        
        # Act - Use real DBInterface
        result = booking_db_interface.create(booking_data)
        
        # Assert - Verify persistence
        saved = test_db_session.query(DBBooking).filter_by(id=result["id"]).first()
        assert saved is not None
        assert saved.price == 300

# hotel/tests/integration/conftest.py
@pytest.fixture(scope="function")
def test_db_engine():
    """
    Provide isolated in-memory SQLite database engine.
    
    CRITICAL: StaticPool ensures all connections share the same
    in-memory database. Without this, each connection gets a
    different database instance.
    """
    engine = create_engine(
        "sqlite:///:memory:",
        connect_args={"check_same_thread": False},
        poolclass=StaticPool  # ← Essential for in-memory testing!
    )
    
    Base.metadata.create_all(bind=engine)
    yield engine
    
    Base.metadata.drop_all(bind=engine)
    engine.dispose()

@pytest.fixture
def customer_factory(test_db_session):
    """Factory fixture for creating test customers."""
    def _create_customer(**kwargs):
        defaults = {
            "first_name": "John",
            "last_name": "Doe",
            "email_address": "john@example.com"
        }
        defaults.update(kwargs)
        
        customer = DBCustomer(**defaults)
        test_db_session.add(customer)
        test_db_session.commit()
        return customer
    
    return _create_customer

# hotel/tests/api/test_booking_api.py
"""
API Integration Tests for Booking Endpoints

TESTING APPROACH:
- Tests complete booking workflow through HTTP API
- Validates integration of customer, room, and booking entities
- Tests business logic through API layer (price calculation)

ARCHITECTURE:
HTTP → Router → Operations (business logic) → DBInterface → Test DB

This is the HIGHEST level of integration testing.
"""

@pytest.mark.api
@pytest.mark.integration
class TestBookingAPIEndpoints:
    
    def test_create_booking_calculates_price_correctly(
        self,
        api_client,      # ← FastAPI TestClient
        api_customer,    # ← Factory creating via API
        api_room
    ):
        """Test that booking price is calculated correctly through API."""
        # Arrange - Create dependencies via API
        customer = api_customer(first_name="Alice")
        room = api_room(number="101", price=100)
        
        # Act - POST request to create booking
        response = api_client.post("/booking", json={
            "customer_id": customer["id"],
            "room_id": room["id"],
            "from_date": "2025-12-25",
            "to_date": "2025-12-28"  # 3 days
        })
        
        # Assert - HTTP and business logic
        assert response.status_code == 200
        assert response.json()["price"] == 300  # 3 days × $100

# hotel/tests/api/conftest.py
@pytest.fixture(scope="function")
def api_client(test_api_engine, test_api_session):
    """
    Provide FastAPI TestClient with test database.
    
    PATTERN: Override production dependencies
    - Same FastAPI app as production
    - Different database (in-memory test DB)
    """
    app = FastAPI()
    
    # Include routers (same as production)
    app.include_router(bookings.router)
    app.include_router(customers.router)
    app.include_router(rooms.router)
    
    # Override global engine for testing
    engine_module.DBSession = sessionmaker(bind=test_api_engine)
    
    client = TestClient(app)
    yield client
    
    # Cleanup
    test_api_session.rollback()

# Run only unit tests (fastest)
pytest -m unit

# Run only database integration tests
pytest -m "integration and database"

# Run only API tests
pytest -m api

# Run critical path tests
pytest -m critical

# Run all booking-related tests
pytest -m booking

# ✅ Protocol - Structural typing (duck typing with type checking)
class DataInterface(Protocol):
    def read_all(self) -> List[DataObject]: ...

# Stub doesn't need inheritance
class BookingStub:  # ← No inheritance!
    def read_all(self) -> List[DataObject]:
        return [{"id": 1}]

# Type checker validates compatibility
def get_bookings(interface: DataInterface):
    return interface.read_all()

get_bookings(BookingStub())  # ✅ Valid

# ❌ ABC - Nominal typing (requires explicit inheritance)
class DataInterface(ABC):
    @abstractmethod
    def read_all(self) -> List[DataObject]: ...

# Stub MUST inherit
class BookingStub(DataInterface):  # ← Forced inheritance
    def read_all(self) -> List[DataObject]:
        return [{"id": 1}]

# ✅ Stub - Simple, explicit
class RoomStub(DataStubInterface):
    def read_by_id(self, id: int) -> DataObject:
        return {"id": id, "price": 100}

# Test is readable
result = create_booking(data, booking_stub, room_stub)
assert result["price"] == 200

# ❌ Mock - Complex, implicit
room_mock = Mock(spec=DataInterface)
room_mock.read_by_id.return_value = {"id": 1, "price": 100}

# Test has setup overhead
result = create_booking(data, booking_mock, room_mock)
room_mock.read_by_id.assert_called_once_with(1)
assert result["price"] == 200

class DBInterface:
    def __init__(self, db_class: type[Base], session: Optional[Session] = None):
        self._session = session

    def _get_session(self) -> Session:
        # Test session if provided, else production
        return self._session if self._session else engine.DBSession()

# Routers create interface without session
booking_interface = DBInterface(DBBooking)  # ← Uses production DB

# Tests inject test session
booking_interface = DBInterface(DBBooking, session=test_db_session)

# ❌ Without StaticPool - Different databases!
engine = create_engine("sqlite:///:memory:")
conn1 = engine.connect()  # Database A
conn2 = engine.connect()  # Database B (empty!)

# ✅ With StaticPool - Shared database!
from sqlalchemy.pool import StaticPool

engine = create_engine(
    "sqlite:///:memory:",
    poolclass=StaticPool  # ← All connections use same DB
)
conn1 = engine.connect()  # Database A
conn2 = engine.connect()  # Database A (same!)

def create_booking(data):
    session = engine.DBSession()  # ← Hard dependency
    booking = DBBooking(**data)
    session.add(booking)
    session.commit()

def create_booking(data, booking_interface: DataInterface):
    return booking_interface.create(data)  # ← Injected dependency

# ✅ Good - Simple stub
class RoomStub:
    def read_by_id(self, id: int):
        return {"id": id, "price": 100}

# ❌ Bad - Overcomplicated mock
room_mock = MagicMock()
room_mock.read_by_id.return_value = {"id": 1, "price": 100}
room_mock.read_by_id.side_effect = lambda x: {"id": x, "price": 100}

def test_example():
    # Arrange - Set up test data
    customer = customer_factory(first_name="Alice")
    
    # Act - Execute the operation
    result = read_customer_by_id(customer.id, interface)
    
    # Assert - Verify expectations
    assert result["first_name"] == "Alice"

# Pattern: test_<method>_<scenario>_<expected>
test_create_booking_with_valid_data_returns_booking()
test_create_booking_with_invalid_dates_raises_error()
test_read_customer_by_id_not_exists_returns_none()