Facade Pattern

Provide a unified, simplified interface to a set of interfaces in a subsystem. Facade defines a higher-level interface that makes the subsystem easier to use.

---

Problem

You have a complex subsystem with many classes that clients need to interact with. This complexity makes the subsystem hard to use and maintain.

Solution

The Facade pattern provides a single unified interface to a set of classes/components.

---

Implementation

# ============ COMPLEX SUBSYSTEM: Movie Theater ============

class AudioSystem:
    def __init__(self):
        self.volume = 5

    def set_volume(self, level: int):
        self.volume = level
        print(f"🔊 Audio volume set to {level}")

    def turn_on(self):
        print("🔊 Audio system ON")

    def turn_off(self):
        print("🔊 Audio system OFF")

class Projector:
    def __init__(self):
        self.is_on = False

    def turn_on(self):
        self.is_on = True
        print("🎬 Projector ON")

    def turn_off(self):
        self.is_on = False
        print("🎬 Projector OFF")

    def set_resolution(self, width: int, height: int):
        if self.is_on:
            print(f"🎬 Projector resolution: {width}x{height}")

class Screen:
    def __init__(self):
        self.position = "up"

    def down(self):
        self.position = "down"
        print("🎥 Screen DOWN")

    def up(self):
        self.position = "up"
        print("🎥 Screen UP")

class DVDPlayer:
    def __init__(self):
        self.is_playing = False

    def turn_on(self):
        print("📀 DVD Player ON")

    def turn_off(self):
        print("📀 DVD Player OFF")

    def play(self, movie: str):
        self.is_playing = True
        print(f"📀 Playing: {movie}")

    def stop(self):
        self.is_playing = False
        print("📀 DVD stopped")

class Lights:
    def __init__(self):
        self.brightness = 100

    def dim(self, level: int):
        self.brightness = level
        print(f"💡 Lights dimmed to {level}%")

    def turn_on(self):
        self.brightness = 100
        print("💡 Lights ON")

# ============ FACADE: Simplifies subsystem ============

class HomeTheaterFacade:
    """Facade - provides simple interface to complex subsystem"""

    def __init__(self):
        self.audio = AudioSystem()
        self.projector = Projector()
        self.screen = Screen()
        self.dvd_player = DVDPlayer()
        self.lights = Lights()

    def watch_movie(self, movie: str):
        """Simple interface to watch a movie"""
        print(f"\n🎭 Starting movie night: {movie}")
        self.lights.dim(10)
        self.screen.down()
        self.projector.turn_on()
        self.projector.set_resolution(1920, 1080)
        self.audio.turn_on()
        self.audio.set_volume(8)
        self.dvd_player.turn_on()
        self.dvd_player.play(movie)

    def end_movie(self):
        """Simple interface to end movie"""
        print("\n🎭 Ending movie night")
        self.dvd_player.stop()
        self.dvd_player.turn_off()
        self.projector.turn_off()
        self.screen.up()
        self.audio.turn_off()
        self.lights.turn_on()

# ============ ANOTHER EXAMPLE: Restaurant Ordering System ============

class Menu:
    def get_items(self):
        return ["Pizza", "Pasta", "Salad", "Burger"]

class Kitchen:
    def prepare_pizza(self):
        print("🍕 Preparing pizza...")
        return "Pizza"

    def prepare_pasta(self):
        print("🍝 Preparing pasta...")
        return "Pasta"

    def prepare_salad(self):
        print("🥗 Preparing salad...")
        return "Salad"

class Waiter:
    def take_order(self, order: str):
        print(f"✍️ Waiter taking order: {order}")

    def serve_order(self, item: str):
        print(f"🚶 Waiter serving: {item}")

class Cashier:
    def calculate_bill(self, items: list) -> float:
        prices = {"Pizza": 10, "Pasta": 8, "Salad": 6, "Burger": 7}
        total = sum(prices.get(item, 0) for item in items)
        print(f"💰 Total bill: ${total}")
        return total

    def process_payment(self, amount: float):
        print(f"💳 Payment of ${amount} processed")

class RestaurantFacade:
    """Facade - simplifies restaurant operations"""

    def __init__(self):
        self.menu = Menu()
        self.kitchen = Kitchen()
        self.waiter = Waiter()
        self.cashier = Cashier()

    def order_meal(self, items: list):
        print(f"\n🍽️ Ordering meal: {items}")

        # Show menu
        available = self.menu.get_items()
        print(f"Available: {available}")

        # Take order
        for item in items:
            self.waiter.take_order(item)

        # Prepare food
        for item in items:
            if item == "Pizza":
                self.kitchen.prepare_pizza()
            elif item == "Pasta":
                self.kitchen.prepare_pasta()
            elif item == "Salad":
                self.kitchen.prepare_salad()

        # Serve food
        for item in items:
            self.waiter.serve_order(item)

        # Calculate and pay bill
        total = self.cashier.calculate_bill(items)
        self.cashier.process_payment(total)

# ============ LIBRARY SYSTEM FACADE ============

class BookDatabase:
    def search_by_title(self, title: str):
        print(f"📚 Searching for: {title}")
        return ["Book 1", "Book 2"]

class InventorySystem:
    def check_availability(self, book_id: str):
        print(f"✅ Checking inventory for {book_id}")
        return True

class CheckoutSystem:
    def checkout_book(self, book_id: str, member_id: str):
        print(f"📋 Checkout: {book_id} to member {member_id}")

class NotificationSystem:
    def send_confirmation(self, member_id: str, book: str):
        print(f"📧 Confirmation email sent to member {member_id}")

class LibraryFacade:
    """Facade - simplifies library operations"""

    def __init__(self):
        self.database = BookDatabase()
        self.inventory = InventorySystem()
        self.checkout = CheckoutSystem()
        self.notifications = NotificationSystem()

    def borrow_book(self, title: str, member_id: str):
        print(f"\n📖 Borrowing book: {title}")

        # Search
        results = self.database.search_by_title(title)
        if not results:
            print("Book not found")
            return

        # Check availability
        book_id = results[0]
        if not self.inventory.check_availability(book_id):
            print("Book not available")
            return

        # Checkout
        self.checkout.checkout_book(book_id, member_id)

        # Send confirmation
        self.notifications.send_confirmation(member_id, title)

# Demo
if __name__ == "__main__":
    print("=" * 50)
    print("=== HOME THEATER FACADE ===")
    print("=" * 50)
    theater = HomeTheaterFacade()

    # Without facade, clients would need to do all this manually
    theater.watch_movie("The Matrix")
    theater.end_movie()

    print("\n" + "=" * 50)
    print("=== RESTAURANT FACADE ===")
    print("=" * 50)
    restaurant = RestaurantFacade()
    restaurant.order_meal(["Pizza", "Pasta", "Salad"])

    print("\n" + "=" * 50)
    print("=== LIBRARY FACADE ===")
    print("=" * 50)
    library = LibraryFacade()
    library.borrow_book("Clean Code", "M001")

---

Key Concepts

• Facade: Single unified interface to complex subsystem
• Subsystem: Complex set of classes/components
• Simplification: Clients don't see complexity
• Decoupling: Clients depend only on facade, not subsystem
• Convenience: Common operations wrapped in simple methods

---

When to Use

✅ Complex subsystem needs simplified interface
✅ Reduce coupling between clients and subsystem
✅ Provide entry point to layered subsystem
✅ Simplify client code and dependencies

---

Interview Q&A

Q1: What's the difference between Facade and Adapter?

A: - Facade: Simplifies complex subsystem. Multiple classes. - Adapter: Makes incompatible interfaces work. Usually wraps one class.

# Facade: Simplifies many classes
class HomeTheaterFacade:
    def watch_movie(self):
        self.projector.turn_on()
        self.audio.turn_on()
        self.screen.down()  # Multiple components

# Adapter: Converts one interface
class PaymentAdapter:
    def pay(self, amount):
        return legacy_payment.process(amount)  # One component

---

Q2: Can a facade itself be decorated or wrapped?

A: Yes, facades can be composed:

class AdvancedTheaterFacade(HomeTheaterFacade):
    def watch_4k_movie(self, movie):
        # Uses parent facade + adds new functionality
        self.watch_movie(movie)
        self.projector.set_resolution(4096, 2160)

---

Q3: How would you handle exceptions in a facade?

A:

class RobustTheaterFacade:
    def watch_movie(self, movie: str):
        try:
            self.lights.dim(10)
            self.projector.turn_on()
            self.dvd_player.play(movie)
        except Exception as e:
            print(f"Error: {e}")
            self.cleanup()

    def cleanup(self):
        # Ensure system is in safe state
        self.lights.turn_on()
        self.projector.turn_off()

---

Q4: How would you make a facade for multiple providers?

A:

class FlexibleRestaurantFacade:
    def __init__(self, provider: str):
        if provider == "italian":
            self.kitchen = ItalianKitchen()
        elif provider == "chinese":
            self.kitchen = ChineseKitchen()
        else:
            self.kitchen = StandardKitchen()

    def order_meal(self, items):
        for item in items:
            self.kitchen.prepare(item)

---

Q5: How would you test code using a facade?

A:

from unittest.mock import Mock

class MockHomeTheaterFacade:
    def __init__(self):
        self.projector = Mock()
        self.audio = Mock()
        self.lights = Mock()

    def watch_movie(self, movie):
        self.lights.dim(10)
        self.projector.turn_on()

# Test
facade = MockHomeTheaterFacade()
facade.watch_movie("The Matrix")
facade.lights.dim.assert_called_with(10)

---

Trade-offs

✅ Pros: Simplifies complex subsystems, loose coupling, easier to use
❌ Cons: Facade becomes too large, hides subsystem details, may be overkill for simple systems

---

Real-World Examples

• Framework APIs (Django, React provide facades)
• Database ORMs (hide SQL complexity)
• Logging frameworks (hide configuration complexity)
• Cloud SDKs (AWS SDK facades, Azure SDK)
• Java I/O (various stream classes with simplified facades)