from dataclasses import dataclass


@dataclass
class Product:
    """Only holds product data, nothing else."""
    name: str
    sku: str
    base_price: float


class PricingService:
    """Only calculates prices and taxes."""

    def with_discount(self, product: Product, discount_pct: float) -> float:
        return product.base_price * (1 - discount_pct / 100)

    def with_tax(self, price: float, tax_rate: float) -> float:
        return price * (1 + tax_rate)


class ProductRepository:
    """Only handles database operations for products."""

    def save(self, product: Product):
        db.execute(
            "INSERT INTO products (name, sku, price) VALUES (%s, %s, %s)",
            (product.name, product.sku, product.base_price)
        )

    def find_by_sku(self, sku: str) -> Product:
        row = db.query("SELECT * FROM products WHERE sku = %s", (sku,))
        return Product(name=row["name"], sku=row["sku"], base_price=row["price"])


class InventoryTracker:
    """Only manages stock levels."""

    def __init__(self):
        self._stock: dict[str, int] = {}

    def in_stock(self, sku: str) -> bool:
        return self._stock.get(sku, 0) > 0

    def reduce(self, sku: str, qty: int):
        current = self._stock.get(sku, 0)
        if current < qty:
            raise ValueError(f"Not enough stock for {sku}")
        self._stock[sku] = current - qty

    def get_level(self, sku: str) -> int:
        return self._stock.get(sku, 0)


class RestockAlertService:
    """Only sends low-stock notifications."""

    def check_and_alert(self, sku: str, current_stock: int, threshold: int = 10):
        if current_stock < threshold:
            email.send(
                to="warehouse@shop.com",
                subject=f"Low stock alert: {sku}",
                body=f"Only {current_stock} units remaining!"
            )

Now each class changes for exactly ONE reason:

• Tax rules change → only PricingService changes
• Switch to MongoDB → only ProductRepository changes
• Need Slack alerts → only RestockAlertService changes

from typing import Protocol
from dataclasses import dataclass


@dataclass
class ShippingRequest:
    order_total: float
    weight_kg: float
    destination: str


class ShippingStrategy(Protocol):
    """Contract: every shipping method must implement calculate()"""
    def calculate(self, request: ShippingRequest) -> float: ...
    def estimated_days(self) -> str: ...


class StandardShipping:
    def calculate(self, request: ShippingRequest) -> float:
        base = 5.99
        return base if request.weight_kg <= 5 else base + (request.weight_kg - 5) * 1.50

    def estimated_days(self) -> str:
        return "5-7 business days"


class ExpressShipping:
    def calculate(self, request: ShippingRequest) -> float:
        return 12.99 + request.weight_kg * 0.75

    def estimated_days(self) -> str:
        return "2-3 business days"


class OvernightShipping:
    def calculate(self, request: ShippingRequest) -> float:
        return 24.99 + request.weight_kg * 2.00

    def estimated_days(self) -> str:
        return "Next business day"


# ✅ New requirement: free shipping for orders over $50!
# Just add a class. ZERO changes to existing code!
class FreeShippingPromo:
    def calculate(self, request: ShippingRequest) -> float:
        return 0.0 if request.order_total >= 50 else 5.99

    def estimated_days(self) -> str:
        return "5-7 business days"


# The checkout service doesn't care WHICH strategy is used
def calculate_shipping(strategy: ShippingStrategy, request: ShippingRequest) -> dict:
    cost = strategy.calculate(request)
    return {
        "cost": cost,
        "delivery": strategy.estimated_days(),
        "total_with_shipping": request.order_total + cost,
    }


# Usage: swap strategies at runtime
req = ShippingRequest(order_total=75.00, weight_kg=2.5, destination="US")

print(calculate_shipping(StandardShipping(), req))
# {'cost': 5.99, 'delivery': '5-7 business days', 'total_with_shipping': 80.99}

print(calculate_shipping(FreeShippingPromo(), req))
# {'cost': 0.0, 'delivery': '5-7 business days', 'total_with_shipping': 75.0}

from abc import ABC, abstractmethod
from dataclasses import dataclass


@dataclass
class ChargeResult:
    success: bool
    amount_charged: float
    message: str


class PaymentMethod(ABC):
    @abstractmethod
    def can_cover(self, amount: float) -> bool:
        """Check if this method can handle the amount."""
        ...

    @abstractmethod
    def charge(self, amount: float) -> ChargeResult:
        """Charge the amount. Always returns a result, never crashes."""
        ...


class CreditCard(PaymentMethod):
    def __init__(self, number: str, limit: float = 10_000):
        self.number = number
        self.limit = limit

    def can_cover(self, amount: float) -> bool:
        return amount <= self.limit

    def charge(self, amount: float) -> ChargeResult:
        if not self.can_cover(amount):
            return ChargeResult(False, 0, f"Exceeds card limit ${self.limit:.2f}")
        self.limit -= amount
        return ChargeResult(True, amount, f"💳 Charged to card ending {self.number[-4:]}")


class GiftCard(PaymentMethod):
    def __init__(self, code: str, balance: float):
        self.code = code
        self.balance = balance

    def can_cover(self, amount: float) -> bool:
        return amount <= self.balance

    def charge(self, amount: float) -> ChargeResult:
        if not self.can_cover(amount):
            return ChargeResult(
                False, 0, f"Gift card {self.code} has only ${self.balance:.2f}"
            )
        self.balance -= amount
        return ChargeResult(True, amount, f"🎁 Charged to gift card {self.code}")


class PayPalWallet(PaymentMethod):
    def __init__(self, email: str, balance: float):
        self.email = email
        self.balance = balance

    def can_cover(self, amount: float) -> bool:
        return amount <= self.balance

    def charge(self, amount: float) -> ChargeResult:
        if not self.can_cover(amount):
            return ChargeResult(False, 0, "Insufficient PayPal balance")
        self.balance -= amount
        return ChargeResult(True, amount, f"🅿️ Charged via PayPal ({self.email})")


# ✅ Works with ANY payment method. No crashes, no surprises
def process_checkout(payment: PaymentMethod, total: float):
    if not payment.can_cover(total):
        print(f"❌ This payment method can't cover ${total:.2f}")
        return

    result = payment.charge(total)
    if result.success:
        print(f"✅ {result.message} | ${result.amount_charged:.2f}")
    else:
        print(f"❌ Payment failed: {result.message}")


process_checkout(CreditCard("4111111111111111"), 99.99)
# ✅ 💳 Charged to card ending 1111 | $99.99

process_checkout(GiftCard("GIFT-50", 50.00), 99.99)
# ❌ This payment method can't cover $99.99

process_checkout(PayPalWallet("user@email.com", 200.00), 99.99)
# ✅ 🅿️ Charged via PayPal (user@email.com) | $99.99

from abc import ABC, abstractmethod


class Purchasable(ABC):
    """Anything that can be bought."""
    @abstractmethod
    def get_price(self) -> float: ...

    @abstractmethod
    def get_display_name(self) -> str: ...


class Shippable(ABC):
    """Anything that needs physical delivery."""
    @abstractmethod
    def get_weight_kg(self) -> float: ...

    @abstractmethod
    def get_dimensions(self) -> tuple[float, float, float]: ...


class Downloadable(ABC):
    """Anything delivered digitally."""
    @abstractmethod
    def get_download_url(self) -> str: ...

    @abstractmethod
    def get_file_size_mb(self) -> float: ...


# Physical products: purchasable + shippable
class PhysicalProduct(Purchasable, Shippable):
    def __init__(self, name: str, price: float, weight: float):
        self.name = name
        self.price = price
        self.weight = weight

    def get_price(self) -> float:       return self.price
    def get_display_name(self) -> str:  return self.name
    def get_weight_kg(self) -> float:   return self.weight
    def get_dimensions(self) -> tuple:  return (30.0, 20.0, 15.0)


# Digital products: purchasable + downloadable
class DigitalProduct(Purchasable, Downloadable):
    def __init__(self, name: str, price: float, url: str, size_mb: float):
        self.name = name
        self.price = price
        self.url = url
        self.size_mb = size_mb

    def get_price(self) -> float:        return self.price
    def get_display_name(self) -> str:   return self.name
    def get_download_url(self) -> str:   return self.url
    def get_file_size_mb(self) -> float: return self.size_mb


# Course bundle: purchasable + downloadable (no shipping!)
class OnlineCourse(Purchasable, Downloadable):
    def __init__(self, title: str, price: float, platform_url: str):
        self.title = title
        self.price = price
        self.platform_url = platform_url

    def get_price(self) -> float:        return self.price
    def get_display_name(self) -> str:   return f"📚 {self.title}"
    def get_download_url(self) -> str:   return self.platform_url
    def get_file_size_mb(self) -> float: return 0  # Streamed, not downloaded


# Functions only depend on the interface they need
def calculate_shipping(item: Shippable) -> float:
    """Only needs Shippable. Doesn't care about price or downloads."""
    return item.get_weight_kg() * 2.50

def send_download_link(item: Downloadable, customer_email: str):
    """Only needs Downloadable. Doesn't care about weight."""
    print(f"📧 Sending download link to {customer_email}: {item.get_download_url()}")

def add_to_cart(item: Purchasable):
    """Only needs Purchasable. Works with any product type."""
    print(f"🛒 Added {item.get_display_name()} | ${item.get_price():.2f}")


# Usage
laptop = PhysicalProduct("MacBook Pro", 2499.99, 2.1)
ebook = DigitalProduct("Python Mastery", 29.99, "https://store.com/download/python", 15.0)
course = OnlineCourse("SOLID Principles Bootcamp", 49.99, "https://learn.com/solid")

add_to_cart(laptop)   # 🛒 Added MacBook Pro | $2499.99
add_to_cart(ebook)    # 🛒 Added Python Mastery | $29.99
add_to_cart(course)   # 🛒 Added 📚 SOLID Principles Bootcamp | $49.99

calculate_shipping(laptop)        # ✅ Works, laptop is Shippable
send_download_link(ebook, "u@mail.com")  # ✅ Works, ebook is Downloadable
# calculate_shipping(ebook)       # ❌ Type error! ebook isn't Shippable. Caught early!

from typing import Protocol
from dataclasses import dataclass, field
from datetime import datetime


@dataclass
class Order:
    order_id: str
    customer_email: str
    items: list[str]
    total: float
    created_at: datetime = field(default_factory=datetime.now)


# ═══════════ ABSTRACTIONS (the contracts) ═══════════

class OrderRepository(Protocol):
    """How orders are stored. We don't care where."""
    def save(self, order: Order) -> None: ...
    def find_by_id(self, order_id: str) -> Order | None: ...


class PaymentGateway(Protocol):
    """How payments are processed. We don't care how."""
    def charge(self, amount: float, customer_email: str) -> bool: ...


class NotificationChannel(Protocol):
    """How customers are notified. We don't care which channel."""
    def send(self, to: str, subject: str, body: str) -> None: ...


# ═══════════ IMPLEMENTATIONS (swap these freely) ═══════════

class PostgresOrderRepo:
    def save(self, order: Order) -> None:
        print(f"  🐘 Saved order {order.order_id} to PostgreSQL")

    def find_by_id(self, order_id: str) -> Order | None:
        print(f"  🐘 Looking up order {order_id} in PostgreSQL")
        return None


class DynamoDBOrderRepo:
    def save(self, order: Order) -> None:
        print(f"  ☁️ Saved order {order.order_id} to DynamoDB")

    def find_by_id(self, order_id: str) -> Order | None:
        print(f"  ☁️ Looking up order {order_id} in DynamoDB")
        return None


class StripeGateway:
    def charge(self, amount: float, customer_email: str) -> bool:
        print(f"  💳 Stripe: charged ${amount:.2f} for {customer_email}")
        return True


class RazorpayGateway:
    def charge(self, amount: float, customer_email: str) -> bool:
        print(f"  🇮🇳 Razorpay: charged ₹{amount * 83:.2f} for {customer_email}")
        return True


class EmailNotification:
    def send(self, to: str, subject: str, body: str) -> None:
        print(f"  📧 Email to {to}: {subject}")


class SMSNotification:
    def send(self, to: str, subject: str, body: str) -> None:
        print(f"  📱 SMS to {to}: {body[:50]}...")


class SlackNotification:
    def send(self, to: str, subject: str, body: str) -> None:
        print(f"  💬 Slack #{to}: {subject}")


# ═══════════ CORE SERVICE (doesn't know any provider) ═══════════

class OrderService:
    """High-level business logic. Depends only on abstractions."""

    def __init__(
        self,
        repo: OrderRepository,
        payment: PaymentGateway,
        notifier: NotificationChannel,
    ):
        self.repo = repo
        self.payment = payment
        self.notifier = notifier

    def place_order(self, order: Order) -> bool:
        print(f"\n🛒 Processing order {order.order_id}...")

        # 1. Charge payment
        if not self.payment.charge(order.total, order.customer_email):
            print("  ❌ Payment failed!")
            return False

        # 2. Save order
        self.repo.save(order)

        # 3. Notify customer
        self.notifier.send(
            to=order.customer_email,
            subject=f"Order {order.order_id} confirmed!",
            body=f"Thanks for your purchase of ${order.total:.2f}!"
        )

        print(f"  ✅ Order {order.order_id} completed!")
        return True


# ═══════════ USAGE: wire up different configurations ═══════════

order = Order(
    order_id="ORD-2026-001",
    customer_email="customer@example.com",
    items=["Python Course", "SOLID eBook"],
    total=79.98
)

# Config 1: US store (Stripe + PostgreSQL + Email)
us_store = OrderService(
    repo=PostgresOrderRepo(),
    payment=StripeGateway(),
    notifier=EmailNotification(),
)
us_store.place_order(order)

# Config 2: India store (Razorpay + DynamoDB + SMS)
india_store = OrderService(
    repo=DynamoDBOrderRepo(),
    payment=RazorpayGateway(),
    notifier=SMSNotification(),
)
india_store.place_order(order)

Output:

🛒 Processing order ORD-2026-001...
  💳 Stripe: charged $79.98 for customer@example.com
  🐘 Saved order ORD-2026-001 to PostgreSQL
  📧 Email to customer@example.com: Order ORD-2026-001 confirmed!
  ✅ Order ORD-2026-001 completed!

🛒 Processing order ORD-2026-001...
  🇮🇳 Razorpay: charged ₹6638.34 for customer@example.com
  ☁️ Saved order ORD-2026-001 to DynamoDB
  📱 SMS to customer@example.com: Thanks for your purchase of $79.98!...
  ✅ Order ORD-2026-001 completed!

from typing import Protocol
from dataclasses import dataclass, field
from datetime import datetime


# ════════════════════════════════════════════
# 📦 DOMAIN MODELS (SRP: only hold data)
# ════════════════════════════════════════════
@dataclass
class CartItem:
    product_name: str
    sku: str
    quantity: int
    unit_price: float

    @property
    def subtotal(self) -> float:
        return self.quantity * self.unit_price


@dataclass
class Cart:
    items: list[CartItem]
    customer_email: str

    @property
    def total(self) -> float:
        return sum(item.subtotal for item in self.items)

    @property
    def item_count(self) -> int:
        return sum(item.quantity for item in self.items)


@dataclass
class CheckoutResult:
    success: bool
    order_id: str
    message: str
    total_charged: float = 0.0


# ════════════════════════════════════════════
# 📋 PROTOCOLS: one method each (ISP)
# ════════════════════════════════════════════
class CartValidator(Protocol):
    def validate(self, cart: Cart) -> tuple[bool, str]: ...

class PaymentGateway(Protocol):
    def charge(self, amount: float, email: str) -> bool: ...

class ShippingCalculator(Protocol):
    def calculate(self, cart: Cart) -> float: ...

class Notifier(Protocol):
    def send(self, to: str, subject: str, body: str) -> None: ...

class OrderStore(Protocol):
    def save(self, order_id: str, cart: Cart, total: float) -> None: ...


# ════════════════════════════════════════════
# 🔌 IMPLEMENTATIONS (OCP: add new, don't edit)
# ════════════════════════════════════════════
class StockValidator:
    """Checks that all items are in stock."""
    def validate(self, cart: Cart) -> tuple[bool, str]:
        # In real code: check inventory database
        if cart.item_count == 0:
            return False, "Cart is empty"
        return True, "All items in stock"

class FraudValidator:
    """Checks for suspicious orders."""
    def validate(self, cart: Cart) -> tuple[bool, str]:
        if cart.total > 10_000:
            return False, "Order exceeds fraud threshold, needs manual review"
        return True, "Order looks legitimate"


class StripePayment:
    def charge(self, amount: float, email: str) -> bool:
        print(f"    💳 Stripe: ${amount:.2f} charged to {email}")
        return True

class PayPalPayment:
    def charge(self, amount: float, email: str) -> bool:
        print(f"    🅿️  PayPal: ${amount:.2f} charged to {email}")
        return True


class FlatRateShipping:
    def calculate(self, cart: Cart) -> float:
        return 5.99

class FreeOver50Shipping:
    def calculate(self, cart: Cart) -> float:
        return 0.0 if cart.total >= 50 else 5.99


class EmailNotifier:
    def send(self, to: str, subject: str, body: str) -> None:
        print(f"    📧 Email → {to}: {subject}")

class SlackNotifier:
    def send(self, to: str, subject: str, body: str) -> None:
        print(f"    💬 Slack → #orders: {subject}")


class PostgresStore:
    def save(self, order_id: str, cart: Cart, total: float) -> None:
        print(f"    🐘 Saved {order_id} (${total:.2f}) to PostgreSQL")

class InMemoryStore:
    """Great for testing. No database needed!"""
    def __init__(self):
        self.orders = {}

    def save(self, order_id: str, cart: Cart, total: float) -> None:
        self.orders[order_id] = {"cart": cart, "total": total}
        print(f"    🧪 Saved {order_id} (${total:.2f}) to memory (test mode)")


# ════════════════════════════════════════════
# 🎯 CHECKOUT SERVICE (SRP: only orchestrates)
# ════════════════════════════════════════════
class CheckoutService:
    """
    Pure orchestration. Knows what to do, not how to do it.

    SRP: only coordinates the checkout flow
    OCP: new payment? New class, zero edits here
    LSP: any Protocol implementation works
    ISP: each dependency has exactly 1 method
    DIP: depends on abstractions, not Stripe/Postgres/etc.
    """

    def __init__(
        self,
        validator: CartValidator,
        payment: PaymentGateway,
        shipping: ShippingCalculator,
        notifier: Notifier,
        store: OrderStore,
    ):
        self.validator = validator
        self.payment = payment
        self.shipping = shipping
        self.notifier = notifier
        self.store = store

    def checkout(self, cart: Cart) -> CheckoutResult:
        order_id = f"ORD-{datetime.now().strftime('%Y%m%d%H%M%S')}"
        print(f"\n🛒 Checkout started: {order_id}")
        print(f"   {cart.item_count} items, subtotal: ${cart.total:.2f}")

        # Step 1: Validate
        valid, reason = self.validator.validate(cart)
        if not valid:
            print(f"   ❌ {reason}")
            return CheckoutResult(False, order_id, reason)

        # Step 2: Calculate shipping
        shipping = self.shipping.calculate(cart)
        grand_total = cart.total + shipping
        print(f"   📦 Shipping: ${shipping:.2f} | Total: ${grand_total:.2f}")

        # Step 3: Charge payment
        if not self.payment.charge(grand_total, cart.customer_email):
            return CheckoutResult(False, order_id, "Payment declined")

        # Step 4: Save order
        self.store.save(order_id, cart, grand_total)

        # Step 5: Notify customer
        items_list = ", ".join(f"{i.product_name} x{i.quantity}" for i in cart.items)
        self.notifier.send(
            to=cart.customer_email,
            subject=f"Order {order_id} confirmed!",
            body=f"You ordered: {items_list}. Total: ${grand_total:.2f}"
        )

        print(f"   ✅ Order {order_id} completed!")
        return CheckoutResult(True, order_id, "Success", grand_total)


# ════════════════════════════════════════════
# 🚀 WIRE IT UP: different configs, same service
# ════════════════════════════════════════════

cart = Cart(
    items=[
        CartItem("Python SOLID Course", "COURSE-001", 1, 49.99),
        CartItem("Clean Code eBook", "EBOOK-002", 2, 19.99),
    ],
    customer_email="developer@example.com"
)

# Production config: Stripe + PostgreSQL + Email
prod_checkout = CheckoutService(
    validator=StockValidator(),
    payment=StripePayment(),
    shipping=FreeOver50Shipping(),
    notifier=EmailNotifier(),
    store=PostgresStore(),
)
prod_checkout.checkout(cart)

# Test config: PayPal + InMemory + Slack
test_checkout = CheckoutService(
    validator=FraudValidator(),
    payment=PayPalPayment(),
    shipping=FlatRateShipping(),
    notifier=SlackNotifier(),
    store=InMemoryStore(),
)
test_checkout.checkout(cart)

Output:

🛒 Checkout started: ORD-20260228143022
   3 items, subtotal: $89.97
   📦 Shipping: $0.00 | Total: $89.97
    💳 Stripe: $89.97 charged to developer@example.com
    🐘 Saved ORD-20260228143022 ($89.97) to PostgreSQL
    📧 Email → developer@example.com: Order ORD-20260228143022 confirmed!
   ✅ Order ORD-20260228143022 completed!

🛒 Checkout started: ORD-20260228143022
   3 items, subtotal: $89.97
   📦 Shipping: $5.99 | Total: $95.96
    🅿️  PayPal: $95.96 charged to developer@example.com
    🧪 Saved ORD-20260228143022 ($95.96) to memory (test mode)
    💬 Slack → #orders: Order ORD-20260228143022 confirmed!
   ✅ Order ORD-20260228143022 completed!