Beginner

# => This function handles THREE distinct responsibilities at once:
# => 1. Data access (reading from a dict)
# => 2. Business logic (computing discount)
# => 3. Presentation (formatting a string for display)
def get_user_discount_message(user_id: int) -> str:
    # => user_db simulates a database lookup — data access concern
    user_db = {1: {"name": "Alice", "purchases": 12}}
    user = user_db.get(user_id)          # => user is {"name": "Alice", "purchases": 12}
    # => Business rule embedded directly here — hard to change independently
    if user and user["purchases"] > 10:
        discount = 0.15                  # => discount is 0.15 (15%)
    else:
        discount = 0.05                  # => discount is 0.05 (5%)
    # => Presentation formatted inline — impossible to reuse discount logic elsewhere
    return f"Hello {user['name']}, your discount is {discount * 100:.0f}%"
    # => Output: "Hello Alice, your discount is 15%"

# => DATA ACCESS — only knows how to retrieve users
def find_user(user_id: int) -> dict | None:
    user_db = {1: {"name": "Alice", "purchases": 12}}
    return user_db.get(user_id)          # => returns dict or None

# => BUSINESS LOGIC — only knows discount rules, not storage or display
def calculate_discount(purchases: int) -> float:
    if purchases > 10:
        return 0.15                      # => 15% for loyal customers (>10 purchases)
    return 0.05                          # => 5% default discount

# => PRESENTATION — only knows how to format, not how to compute or fetch
def format_discount_message(name: str, discount: float) -> str:
    return f"Hello {name}, your discount is {discount * 100:.0f}%"
    # => Output: "Hello Alice, your discount is 15%"

# => ORCHESTRATION — thin coordinator that wires the three layers together
def get_user_discount_message(user_id: int) -> str:
    user = find_user(user_id)            # => delegates data access
    discount = calculate_discount(user["purchases"])  # => delegates business rule
    return format_discount_message(user["name"], discount)  # => delegates formatting

// => UserManager handles user data AND email sending AND password logic
// => This class has THREE reasons to change: user schema, email templates, auth rules
class UserManager {
  private users: Map<number, { name: string; email: string }> = new Map();
  // => users stores id → { name, email }

  addUser(id: number, name: string, email: string): void {
    this.users.set(id, { name, email }); // => stores user under id key
  }

  // => EMAIL CONCERN embedded in user class — mixing responsibilities
  sendWelcomeEmail(userId: number): void {
    const user = this.users.get(userId); // => retrieves user or undefined
    if (user) {
      console.log(`Sending email to ${user.email}: Welcome, ${user.name}!`);
      // => Output: Sending email to alice@example.com: Welcome, Alice!
    }
  }

  // => PASSWORD CONCERN also embedded — a third responsibility
  resetPassword(userId: number): string {
    const newPassword = Math.random().toString(36).slice(2, 10);
    // => newPassword is a random 8-char string like "k3m9p2ax"
    console.log(`Password reset for user ${userId}: ${newPassword}`);
    return newPassword; // => returns the new password string
  }
}

// => RESPONSIBILITY 1: User data management only
class UserRepository {
  private users: Map<number, { name: string; email: string }> = new Map();

  add(id: number, name: string, email: string): void {
    this.users.set(id, { name, email }); // => stores user record
  }

  get(id: number): { name: string; email: string } | undefined {
    return this.users.get(id); // => returns user or undefined
  }
}

// => RESPONSIBILITY 2: Email notifications only
class EmailService {
  sendWelcome(name: string, email: string): void {
    console.log(`Sending email to ${email}: Welcome, ${name}!`);
    // => Output: Sending email to alice@example.com: Welcome, Alice!
  }
}

// => RESPONSIBILITY 3: Password management only
class PasswordService {
  reset(userId: number): string {
    const newPassword = Math.random().toString(36).slice(2, 10);
    // => newPassword is a random 8-char string
    console.log(`Password reset for user ${userId}: ${newPassword}`);
    return newPassword; // => returns the generated password
  }
}

# ============================================================
# DATA ACCESS LAYER — only knows about storage
# ============================================================
class ProductRepository:
    def __init__(self) -> None:
        # => in-memory store simulating a database table
        self._products = {
            1: {"id": 1, "name": "Laptop", "price": 1200.0, "stock": 5},
            2: {"id": 2, "name": "Mouse",  "price": 25.0,  "stock": 0},
        }

    def find_by_id(self, product_id: int) -> dict | None:
        return self._products.get(product_id)
        # => returns product dict or None if not found

# ============================================================
# BUSINESS LOGIC LAYER — only knows about rules
# ============================================================
class ProductService:
    def __init__(self, repo: "ProductRepository") -> None:
        self._repo = repo                # => stores repository reference (dependency injection)

    def get_available_product(self, product_id: int) -> dict:
        product = self._repo.find_by_id(product_id)
        # => delegates data retrieval to the repository
        if product is None:
            raise ValueError(f"Product {product_id} not found")
            # => raises ValueError — presentation layer will catch this
        if product["stock"] == 0:
            raise ValueError(f"Product '{product['name']}' is out of stock")
            # => business rule: zero stock means unavailable
        return product                   # => returns valid product dict

# ============================================================
# PRESENTATION LAYER — only knows about formatting responses
# ============================================================
def handle_get_product(product_id: int) -> str:
    repo = ProductRepository()           # => creates data layer
    service = ProductService(repo)       # => creates business layer, injects repo
    try:
        product = service.get_available_product(product_id)
        # => delegates all business logic to service
        return f"Available: {product['name']} at ${product['price']:.2f}"
        # => Output (id=1): "Available: Laptop at $1200.00"
    except ValueError as e:
        return f"Error: {e}"
        # => Output (id=2): "Error: Product 'Mouse' is out of stock"

print(handle_get_product(1))  # => Available: Laptop at $1200.00
print(handle_get_product(2))  # => Error: Product 'Mouse' is out of stock

// => DATA LAYER — retrieves raw records
const orderDb: Record<number, { id: number; total: number; status: string }> = {
  101: { id: 101, total: 299.99, status: "shipped" },
  102: { id: 102, total: 49.0, status: "pending" },
};

function findOrder(id: number): { id: number; total: number; status: string } | null {
  return orderDb[id] ?? null; // => returns order record or null
}

// => BUSINESS LAYER — applies domain rules
function isOrderEligibleForCancellation(order: { total: number; status: string }): boolean {
  return order.status === "pending" && order.total < 500;
  // => true only when pending AND total below cancellation threshold
}

// => PRESENTATION LAYER — translates, never decides
function handleCancelRequest(orderId: number): string {
  const order = findOrder(orderId); // => fetches from data layer
  if (!order) {
    return `Order ${orderId} not found`; // => presentation transforms null to message
  }
  const eligible = isOrderEligibleForCancellation(order);
  // => business logic evaluated in business layer, result consumed here
  if (eligible) {
    return `Order ${orderId} cancelled successfully`;
    // => Output (id=102): "Order 102 cancelled successfully"
  }
  return `Order ${orderId} cannot be cancelled (status: ${order.status})`;
  // => Output (id=101): "Order 101 cannot be cancelled (status: shipped)"
}

console.log(handleCancelRequest(101)); // => Order 101 cannot be cancelled (status: shipped)
console.log(handleCancelRequest(102)); // => Order 102 cancelled successfully
console.log(handleCancelRequest(999)); // => Order 999 not found

# ============================================================
# MODEL — data container + business validation
# ============================================================
class TodoModel:
    def __init__(self) -> None:
        self._items: list[dict] = []     # => internal list of todo dicts
        self._next_id = 1                # => auto-incrementing id counter

    def add(self, title: str) -> dict:
        item = {"id": self._next_id, "title": title, "done": False}
        # => item is {"id": 1, "title": "Buy milk", "done": False}
        self._items.append(item)         # => appended to internal list
        self._next_id += 1               # => next_id is now 2
        return item                      # => returns the created item

    def get_all(self) -> list[dict]:
        return list(self._items)         # => returns shallow copy to prevent mutation

    def complete(self, item_id: int) -> bool:
        for item in self._items:
            if item["id"] == item_id:
                item["done"] = True      # => marks item as completed
                return True              # => returns True = success
        return False                     # => returns False = item not found

# ============================================================
# VIEW — formats data for display, no logic
# ============================================================
class TodoView:
    def render_list(self, items: list[dict]) -> str:
        if not items:
            return "No todos yet."       # => Output when empty list
        lines = []
        for item in items:
            status = "✓" if item["done"] else "○"
            # => status is "✓" for done items, "○" for pending
            lines.append(f"[{status}] {item['id']}. {item['title']}")
        return "\n".join(lines)          # => joined with newlines

    def render_created(self, item: dict) -> str:
        return f"Created todo #{item['id']}: {item['title']}"
        # => Output: "Created todo #1: Buy milk"

# ============================================================
# CONTROLLER — coordinates model and view
# ============================================================
class TodoController:
    def __init__(self, model: TodoModel, view: TodoView) -> None:
        self._model = model              # => stores model reference
        self._view = view                # => stores view reference

    def create(self, title: str) -> str:
        item = self._model.add(title)    # => delegates creation to model
        return self._view.render_created(item)  # => delegates formatting to view

    def list_all(self) -> str:
        items = self._model.get_all()    # => fetches all items from model
        return self._view.render_list(items)    # => delegates rendering to view

    def done(self, item_id: int) -> str:
        success = self._model.complete(item_id)  # => delegates completion to model
        if success:
            return f"Todo #{item_id} marked as done"
        return f"Todo #{item_id} not found"

# => Wire the MVC triad together
model = TodoModel()
view = TodoView()
controller = TodoController(model, view)

print(controller.create("Buy milk"))    # => Created todo #1: Buy milk
print(controller.create("Write tests")) # => Created todo #2: Write tests
print(controller.done(1))               # => Todo #1 marked as done
print(controller.list_all())
# => [✓] 1. Buy milk
# => [○] 2. Write tests

// => MODEL with self-contained validation — the model is the single source of truth
class BankAccount {
  private balance: number; // => private: external code cannot bypass validation
  private readonly minimumBalance = 0; // => business rule: no overdrafts

  constructor(initialBalance: number) {
    if (initialBalance < 0) {
      throw new Error("Initial balance cannot be negative");
      // => enforced at construction time, not by the caller
    }
    this.balance = initialBalance; // => balance is initialBalance (e.g., 100)
  }

  deposit(amount: number): void {
    if (amount <= 0) {
      throw new Error("Deposit amount must be positive");
      // => model rejects invalid inputs without controller involvement
    }
    this.balance += amount; // => balance increases by amount
  }

  withdraw(amount: number): void {
    if (amount <= 0) {
      throw new Error("Withdrawal amount must be positive");
    }
    if (this.balance - amount < this.minimumBalance) {
      throw new Error(`Insufficient funds: balance is ${this.balance}`);
      // => business rule enforced in model, not leaked to controller
    }
    this.balance -= amount; // => balance decreases by amount
  }

  getBalance(): number {
    return this.balance; // => read-only access to private state
  }
}

// => CONTROLLER — delegates entirely to model, no duplicate validation
function handleWithdraw(account: BankAccount, amount: number): string {
  try {
    account.withdraw(amount); // => model enforces all rules
    return `Withdrawal successful. Balance: $${account.getBalance()}`;
    // => Output: "Withdrawal successful. Balance: $50"
  } catch (e) {
    return `Withdrawal failed: ${(e as Error).message}`;
    // => Output: "Withdrawal failed: Insufficient funds: balance is 50"
  }
}

const account = new BankAccount(100); // => account.balance is 100
console.log(handleWithdraw(account, 50)); // => Withdrawal successful. Balance: $50
console.log(handleWithdraw(account, 200)); // => Withdrawal failed: Insufficient funds: balance is 50

# => UserService creates its own database connection — cannot be tested without real DB
class HardcodedUserService:
    def __init__(self) -> None:
        # => hardcoded dependency: impossible to substitute a fake in tests
        self._db = {"data": {1: "Alice", 2: "Bob"}}

    def get_name(self, user_id: int) -> str | None:
        return self._db["data"].get(user_id)  # => returns name or None

# => PROTOCOL defines what UserService needs from storage
from typing import Protocol

class UserStore(Protocol):
    def fetch(self, user_id: int) -> str | None: ...
    # => any object with fetch(int) -> str | None satisfies this protocol

# => REAL implementation for production
class DictUserStore:
    def __init__(self) -> None:
        self._data = {1: "Alice", 2: "Bob"}  # => simulates a real DB

    def fetch(self, user_id: int) -> str | None:
        return self._data.get(user_id)       # => returns name or None

# => FAKE implementation for tests — no DB required
class FakeUserStore:
    def fetch(self, user_id: int) -> str | None:
        return "TestUser"                    # => always returns a fixed value for testing

# => SERVICE accepts any UserStore — decoupled from specific implementation
class UserService:
    def __init__(self, store: UserStore) -> None:
        self._store = store                  # => stores injected dependency

    def greet(self, user_id: int) -> str:
        name = self._store.fetch(user_id)    # => delegates to whatever store was injected
        if name is None:
            return f"User {user_id} not found"
        return f"Hello, {name}!"             # => Output: "Hello, Alice!"

# => PRODUCTION: inject real store
service = UserService(DictUserStore())
print(service.greet(1))   # => Hello, Alice!
print(service.greet(99))  # => User 99 not found

# => TEST: inject fake store — no database needed
test_service = UserService(FakeUserStore())
print(test_service.greet(1))   # => Hello, TestUser!

// => CONSTRUCTOR INJECTION — dependency lives for the object's lifetime
// => Use when: dependency is always required and does not change per call
class OrderProcessor {
  private paymentGateway: { charge: (amount: number) => boolean };
  // => paymentGateway is stored for the lifetime of OrderProcessor

  constructor(paymentGateway: { charge: (amount: number) => boolean }) {
    this.paymentGateway = paymentGateway; // => injected at construction time
  }

  processOrder(orderId: number, amount: number): string {
    const success = this.paymentGateway.charge(amount);
    // => uses the injected gateway — no knowledge of which gateway is used
    return success ? `Order ${orderId} paid ($${amount})` : `Order ${orderId} payment failed`;
  }
}

// => METHOD INJECTION — dependency passed per call
// => Use when: dependency varies per request (e.g., per-user logger, per-request context)
class AuditLogger {
  log(
    message: string,
    output: { write: (msg: string) => void }, // => injected per call
  ): void {
    output.write(`[AUDIT] ${message}`);
    // => output can be console, file, database — determined by caller
  }
}

// => USAGE: wire concrete implementations at the composition root
const fakeGateway = { charge: (amount: number) => amount < 1000 };
// => fakeGateway returns true for amounts < 1000 (simulates approval limit)

const processor = new OrderProcessor(fakeGateway);
console.log(processor.processOrder(1, 500)); // => Order 1 paid ($500)
console.log(processor.processOrder(2, 1500)); // => Order 2 payment failed

const logger = new AuditLogger();
logger.log("User login", { write: (msg) => console.log(msg) });
// => Output: [AUDIT] User login
logger.log("File export", { write: (msg) => console.log(`>> ${msg}`) });
// => Output: >> [AUDIT] File export

// => FAT interface: all implementors must provide ALL four methods
interface EmployeeOperations {
  calculateSalary(): number; // => relevant for paid employees
  clockIn(): void; // => relevant for hourly workers
  generateReport(): string; // => relevant for managers
  requestLeave(days: number): void; // => relevant for all employees
}

// => CONTRACTOR only needs salary calculation, yet must implement everything
class Contractor implements EmployeeOperations {
  calculateSalary(): number {
    return 500;
  } // => useful
  clockIn(): void {
    /* not applicable */
  } // => forced but meaningless
  generateReport(): string {
    return "";
  } // => forced but meaningless
  requestLeave(days: number): void {} // => forced but meaningless
}

// => FOCUSED interfaces: each covers one capability
interface Payable {
  calculateSalary(): number; // => pay calculation
}

interface Trackable {
  clockIn(): void; // => time tracking
}

interface Reportable {
  generateReport(): string; // => reporting
}

interface LeaveEligible {
  requestLeave(days: number): void; // => leave management
}

// => CONTRACTOR: only salary matters, no forced empty methods
class SegregatedContractor implements Payable {
  calculateSalary(): number {
    return 500; // => flat daily rate
  }
}

// => FULL_TIME EMPLOYEE: salary + time tracking + leave
class FullTimeEmployee implements Payable, Trackable, LeaveEligible {
  private hoursWorked = 0; // => tracks hours for this period

  calculateSalary(): number {
    return this.hoursWorked * 25; // => $25/hour
  }

  clockIn(): void {
    this.hoursWorked += 8; // => adds one full work day
  }

  requestLeave(days: number): void {
    console.log(`Leave requested: ${days} day(s)`);
    // => Output: Leave requested: 5 day(s)
  }
}

// => MANAGER: salary + reporting
class Manager implements Payable, Reportable {
  calculateSalary(): number {
    return 8000;
  } // => fixed monthly salary

  generateReport(): string {
    return "Team performance: on track"; // => manager-specific report
  }
}

const contractor = new SegregatedContractor();
console.log(contractor.calculateSalary()); // => 500

const emp = new FullTimeEmployee();
emp.clockIn();
console.log(emp.calculateSalary()); // => 200 (8 hours * $25)

# => VIOLATION: adding a new discount type requires editing this function
def calculate_discount(price: float, discount_type: str) -> float:
    if discount_type == "regular":
        return price * 0.10              # => 10% off
    elif discount_type == "loyalty":
        return price * 0.20              # => 20% off for loyal customers
    # => Every new discount type requires adding another elif here
    # => This is the "open for modification" anti-pattern
    return 0.0

from abc import ABC, abstractmethod

# => ABSTRACT BASE — defines the contract, never changes
class DiscountStrategy(ABC):
    @abstractmethod
    def calculate(self, price: float) -> float: ...
    # => all strategies must implement calculate(price) -> float

# => CONCRETE STRATEGIES — add new ones without touching existing code
class RegularDiscount(DiscountStrategy):
    def calculate(self, price: float) -> float:
        return price * 0.10              # => 10% discount

class LoyaltyDiscount(DiscountStrategy):
    def calculate(self, price: float) -> float:
        return price * 0.20              # => 20% discount for loyal customers

# => EXTENSION: new discount type — existing code is UNTOUCHED
class SeasonalDiscount(DiscountStrategy):
    def calculate(self, price: float) -> float:
        return price * 0.30              # => 30% seasonal sale discount

# => CLIENT: depends on the abstract base, not concrete classes
class PriceCalculator:
    def __init__(self, strategy: DiscountStrategy) -> None:
        self._strategy = strategy        # => stores injected strategy

    def final_price(self, price: float) -> float:
        discount = self._strategy.calculate(price)
        # => delegates discount computation to injected strategy
        return price - discount          # => price minus discount amount

calc = PriceCalculator(RegularDiscount())
print(calc.final_price(100.0))   # => 90.0 (100 - 10)

calc2 = PriceCalculator(SeasonalDiscount())
print(calc2.final_price(100.0))  # => 70.0 (100 - 30)

// => BASE CLASS: Rectangle assumes independent width and height
class Rectangle {
  protected width: number;
  protected height: number;

  constructor(width: number, height: number) {
    this.width = width; // => width is set independently
    this.height = height; // => height is set independently
  }

  setWidth(w: number): void {
    this.width = w;
  } // => changes only width
  setHeight(h: number): void {
    this.height = h;
  } // => changes only height
  area(): number {
    return this.width * this.height;
  }
}

// => SQUARE forces both dimensions equal — violates LSP
class Square extends Rectangle {
  setWidth(w: number): void {
    this.width = w; // => changes width
    this.height = w; // => ALSO changes height — breaks Rectangle's contract
  }
  setHeight(h: number): void {
    this.height = h; // => changes height
    this.width = h; // => ALSO changes width — breaks Rectangle's contract
  }
}

// => CALLER written for Rectangle — breaks silently when given Square
function testRectangle(r: Rectangle): void {
  r.setWidth(5);
  r.setHeight(3);
  // => For a Rectangle: area should be 5 * 3 = 15
  // => For a Square:    area is 3 * 3 = 9 — unexpected behavior!
  console.log(`Area: ${r.area()}`);
}

testRectangle(new Rectangle(1, 1)); // => Area: 15 (correct)
testRectangle(new Square(1, 1)); // => Area: 9  (violates LSP)

// => SHAPE interface: defines area() contract without assuming dimension independence
interface Shape {
  area(): number;
}

// => RECTANGLE: independent width and height
class ProperRectangle implements Shape {
  constructor(
    private width: number,
    private height: number,
  ) {}
  area(): number {
    return this.width * this.height;
  } // => width * height
}

// => SQUARE: single side length, no inherited width/height confusion
class ProperSquare implements Shape {
  constructor(private side: number) {}
  area(): number {
    return this.side * this.side;
  } // => side * side
}

// => CALLER: works for any Shape — LSP satisfied
function printArea(shape: Shape): void {
  console.log(`Area: ${shape.area()}`);
}

printArea(new ProperRectangle(5, 3)); // => Area: 15
printArea(new ProperSquare(4)); // => Area: 16

# => VIOLATION: the "active user" rule is duplicated in every function
# => If the rule changes (e.g., add email_verified check), all three must be updated

def send_notification(user: dict) -> None:
    if user["active"] and user["age"] >= 18:    # => rule duplicated here
        print(f"Notifying {user['name']}")

def generate_report(user: dict) -> None:
    if user["active"] and user["age"] >= 18:    # => same rule repeated
        print(f"Report for {user['name']}")

def allow_purchase(user: dict) -> bool:
    if user["active"] and user["age"] >= 18:    # => rule duplicated a third time
        return True
    return False

# => SINGLE SOURCE OF TRUTH: rule defined once
def is_eligible_user(user: dict) -> bool:
    return user["active"] and user["age"] >= 18
    # => returns True only if active AND adult
    # => changing this rule updates all three callers automatically

def send_notification(user: dict) -> None:
    if is_eligible_user(user):           # => delegates to single rule
        print(f"Notifying {user['name']}")
        # => Output: Notifying Alice

def generate_report(user: dict) -> None:
    if is_eligible_user(user):           # => same single rule
        print(f"Report for {user['name']}")

def allow_purchase(user: dict) -> bool:
    return is_eligible_user(user)        # => single rule, no duplication

user = {"name": "Alice", "active": True, "age": 25}
send_notification(user)   # => Notifying Alice
print(allow_purchase(user))  # => True

// => OVER-ENGINEERED: factory + strategy + builder for a simple greeting
interface GreetingStrategy {
  greet(name: string): string;
}

class FormalGreetingStrategy implements GreetingStrategy {
  greet(name: string): string {
    return `Good day, ${name}.`;
  }
}

class GreetingFactory {
  static create(type: string): GreetingStrategy {
    if (type === "formal") return new FormalGreetingStrategy();
    throw new Error(`Unknown greeting type: ${type}`);
  }
}

class GreetingBuilder {
  private type = "formal";
  withType(type: string): this {
    this.type = type;
    return this;
  }
  build(): GreetingStrategy {
    return GreetingFactory.create(this.type);
  }
}

// => Usage: 5 classes to print "Good day, Alice."
const greeting = new GreetingBuilder().withType("formal").build().greet("Alice");
console.log(greeting); // => Good day, Alice.

// => SIMPLE: one function, zero ceremony, achieves the same result
function greet(name: string): string {
  return `Good day, ${name}.`;
  // => Output: Good day, Alice.
}

console.log(greet("Alice")); // => Good day, Alice.
// => If greeting types are needed later, add them then (YAGNI)

# => YAGNI VIOLATION: speculative features not required by any current use case

class UserProfile:
    def __init__(self, name: str, email: str) -> None:
        self.name = name                 # => required
        self.email = email               # => required

        # => SPECULATIVE: no current feature requires these fields
        self.theme = "light"             # => "might need dark mode someday"
        self.preferred_language = "en"   # => "maybe we'll go international"
        self.newsletter_frequency = "weekly"  # => "for a newsletter we haven't built"
        self.ai_recommendations = True   # => "for an AI feature in the roadmap"

    # => SPECULATIVE: no current caller uses this
    def export_to_xml(self) -> str:
        return f"<user><name>{self.name}</name></user>"

    # => SPECULATIVE: no current caller needs analytics integration
    def track_engagement(self, event: str) -> None:
        print(f"[Analytics] {self.name}: {event}")


# => YAGNI COMPLIANT: only what the application actually needs right now
class SimpleUserProfile:
    def __init__(self, name: str, email: str) -> None:
        self.name = name                 # => required today
        self.email = email               # => required today
        # => No speculative fields — add when a feature actually needs them

    def display_name(self) -> str:
        return self.name                 # => required today for display
        # => Output: "Alice"

user = SimpleUserProfile("Alice", "alice@example.com")
print(user.display_name())  # => Alice
# => Add export_to_xml() when an export feature is actually built
# => Add theme when a dark mode feature is actually shipped

# => HIGH COUPLING: OrderService reaches into the internals of Customer and Inventory

class Customer:
    def __init__(self, name: str, credit_limit: float) -> None:
        self.name = name
        self.credit_limit = credit_limit  # => internal field exposed directly
        self.outstanding_balance = 0.0    # => another internal field exposed

class Inventory:
    def __init__(self) -> None:
        self.items: dict[str, int] = {"Laptop": 5}  # => internal dict exposed

# => OrderService KNOWS about Customer's internals AND Inventory's internals
class TightlyCoupledOrderService:
    def place_order(
        self, customer: Customer, inventory: Inventory, item: str, price: float
    ) -> str:
        # => directly accesses customer's internal fields — tight coupling
        if customer.outstanding_balance + price > customer.credit_limit:
            return "Credit limit exceeded"

        # => directly accesses inventory's internal dict — tight coupling
        if inventory.items.get(item, 0) <= 0:
            return f"{item} is out of stock"

        # => mutates customer's internal state directly
        customer.outstanding_balance += price
        # => mutates inventory's internal dict directly
        inventory.items[item] -= 1
        return f"Order placed: {item} for {customer.name}"
        # => Output: "Order placed: Laptop for Alice"

customer = Customer("Alice", 2000.0)
inventory = Inventory()
service = TightlyCoupledOrderService()
print(service.place_order(customer, inventory, "Laptop", 1200.0))
# => Order placed: Laptop for Alice
# => If Customer renames credit_limit to available_credit, OrderService breaks
# => If Inventory changes items to a database call, OrderService breaks

# => ENCAPSULATED Customer — hides internals behind stable methods
class EncapsulatedCustomer:
    def __init__(self, name: str, credit_limit: float) -> None:
        self._name = name
        self._credit_limit = credit_limit
        self._balance = 0.0              # => private: external code cannot touch directly

    @property
    def name(self) -> str:
        return self._name                # => read-only access to name

    def can_accept_charge(self, amount: float) -> bool:
        return self._balance + amount <= self._credit_limit
        # => hides the credit logic — callers don't know the formula

    def record_charge(self, amount: float) -> None:
        self._balance += amount          # => only method that mutates balance
        # => internal representation could change (e.g., add interest) without affecting callers

# => ENCAPSULATED Inventory — hides the backing data structure
class EncapsulatedInventory:
    def __init__(self) -> None:
        self._stock: dict[str, int] = {"Laptop": 5}  # => private backing dict

    def is_available(self, item: str) -> bool:
        return self._stock.get(item, 0) > 0
        # => hides how stock is stored — could be a database call

    def decrement(self, item: str) -> None:
        if self._stock.get(item, 0) > 0:
            self._stock[item] -= 1       # => only method that mutates stock

# => LOOSELY COUPLED OrderService — talks to interfaces only
class LooselyCoupldeOrderService:
    def place_order(
        self,
        customer: EncapsulatedCustomer,
        inventory: EncapsulatedInventory,
        item: str,
        price: float,
    ) -> str:
        if not customer.can_accept_charge(price):
            return "Credit limit exceeded"  # => no internal field access
        if not inventory.is_available(item):
            return f"{item} is out of stock"
        customer.record_charge(price)    # => delegates mutation to owner
        inventory.decrement(item)        # => delegates mutation to owner
        return f"Order placed: {item} for {customer.name}"
        # => Output: "Order placed: Laptop for Alice"

customer = EncapsulatedCustomer("Alice", 2000.0)
inventory = EncapsulatedInventory()
service = LooselyCoupldeOrderService()
print(service.place_order(customer, inventory, "Laptop", 1200.0))
# => Order placed: Laptop for Alice
# => Renaming _credit_limit to _available_credit has ZERO impact on OrderService

// => LOW COHESION: MixedUtilities handles three completely unrelated domains
class MixedUtilities {
  // => string manipulation
  formatTitle(title: string): string {
    return title.toUpperCase(); // => "hello" → "HELLO"
  }

  // => financial calculation — unrelated to strings
  calculateTax(price: number, rate: number): number {
    return price * rate; // => 100 * 0.1 = 10
  }

  // => date manipulation — unrelated to both of the above
  getDayOfWeek(date: Date): string {
    return date.toLocaleDateString("en-US", { weekday: "long" });
    // => "Monday", "Tuesday", etc.
  }
}

// => HIGH COHESION: each class groups only related behavior
// => REASON: when formatTitle changes, it does not affect tax or date logic

class StringFormatter {
  // => All methods relate to text formatting
  formatTitle(title: string): string {
    return title.toUpperCase(); // => "hello" → "HELLO"
  }

  truncate(text: string, maxLength: number): string {
    return text.length > maxLength ? text.slice(0, maxLength) + "…" : text;
    // => "Hello World" with maxLength=5 → "Hello…"
  }
}

class TaxCalculator {
  // => All methods relate to tax computation
  calculate(price: number, rate: number): number {
    return price * rate; // => 100 * 0.1 = 10.0
  }

  calculateWithCap(price: number, rate: number, cap: number): number {
    const tax = price * rate; // => 100 * 0.15 = 15
    return Math.min(tax, cap); // => min(15, 10) = 10 — capped
  }
}

class DateHelper {
  // => All methods relate to date operations
  getDayOfWeek(date: Date): string {
    return date.toLocaleDateString("en-US", { weekday: "long" });
    // => "Monday" or "Tuesday" etc.
  }

  isWeekend(date: Date): boolean {
    const day = date.getDay(); // => 0=Sunday, 6=Saturday
    return day === 0 || day === 6; // => true on weekends
  }
}

const fmt = new StringFormatter();
console.log(fmt.formatTitle("hello world")); // => HELLO WORLD

const tax = new TaxCalculator();
console.log(tax.calculate(200, 0.1)); // => 20

# => POOR ENCAPSULATION: mutable public fields invite inconsistent state
class PoorTemperature:
    def __init__(self, celsius: float) -> None:
        self.celsius = celsius           # => public: anyone can set this to -999
        self.fahrenheit = celsius * 9/5 + 32  # => computed at init only
        # => Problem: if caller sets celsius = 50 later, fahrenheit stays stale

poor = PoorTemperature(100)
print(poor.celsius)    # => 100
print(poor.fahrenheit) # => 212.0
poor.celsius = 50      # => direct mutation — fahrenheit is now stale!
print(poor.fahrenheit) # => 212.0 (wrong! should be 122.0)

class Temperature:
    def __init__(self, celsius: float) -> None:
        self._validate(celsius)          # => validates at construction time
        self._celsius = celsius          # => private: external code cannot set directly

    @staticmethod
    def _validate(celsius: float) -> None:
        if celsius < -273.15:
            raise ValueError(f"Temperature below absolute zero: {celsius}")
            # => physics constraint enforced by the class

    @property
    def celsius(self) -> float:
        return self._celsius             # => read-only property

    @property
    def fahrenheit(self) -> float:
        return self._celsius * 9 / 5 + 32
        # => always computed from _celsius — never stale
        # => celsius=100 → fahrenheit=212.0

    @property
    def kelvin(self) -> float:
        return self._celsius + 273.15    # => always derived from single source of truth

    def to_celsius(self, value: float) -> "Temperature":
        return Temperature(value)        # => returns NEW instance — immutable pattern

t = Temperature(100)
print(t.celsius)    # => 100
print(t.fahrenheit) # => 212.0
print(t.kelvin)     # => 373.15
# => t._celsius = 50  ← would raise AttributeError — cannot bypass encapsulation

# => INHERITANCE: rigid "is-a" hierarchy that breaks when adding Penguin
class Bird:
    def fly(self) -> str:
        return "Flying"                  # => default fly behavior

class Duck(Bird):
    def quack(self) -> str:
        return "Quack"

class Penguin(Bird):
    def fly(self) -> str:
        raise NotImplementedError("Penguins cannot fly")
        # => Penguin is-a Bird, but must break the Bird contract
        # => This is an LSP violation — any code using Bird.fly() breaks for Penguin

# => BEHAVIOR PROTOCOLS — define what behaviors exist
from typing import Protocol

class FlyBehavior(Protocol):
    def fly(self) -> str: ...

class SwimBehavior(Protocol):
    def swim(self) -> str: ...

# => CONCRETE BEHAVIORS — small, focused, reusable
class CanFly:
    def fly(self) -> str:
        return "Flapping wings"          # => standard flying behavior

class CannotFly:
    def fly(self) -> str:
        return "Cannot fly"              # => used by non-flying birds

class CanSwim:
    def swim(self) -> str:
        return "Swimming"                # => used by aquatic birds

# => COMPOSED BIRDS — each bird assembles the behaviors it actually has
class Eagle:
    def __init__(self) -> None:
        self._fly = CanFly()             # => eagles can fly

    def fly(self) -> str:
        return self._fly.fly()           # => delegates to behavior object
        # => Output: "Flapping wings"

class Duck:
    def __init__(self) -> None:
        self._fly = CanFly()             # => ducks can fly
        self._swim = CanSwim()           # => and swim

    def fly(self) -> str:
        return self._fly.fly()           # => Output: "Flapping wings"

    def swim(self) -> str:
        return self._swim.swim()         # => Output: "Swimming"

class Penguin:
    def __init__(self) -> None:
        self._fly = CannotFly()          # => penguins use the "cannot fly" behavior
        self._swim = CanSwim()           # => but they can swim

    def fly(self) -> str:
        return self._fly.fly()           # => Output: "Cannot fly"

    def swim(self) -> str:
        return self._swim.swim()         # => Output: "Swimming"

duck = Duck()
print(duck.fly())   # => Flapping wings
print(duck.swim())  # => Swimming

penguin = Penguin()
print(penguin.fly())  # => Cannot fly (no exception thrown)

# => MIXIN: adds serialization capability to any class that includes it
class JsonSerializableMixin:
    def to_json(self) -> str:
        import json
        # => converts __dict__ to JSON string
        return json.dumps(self.__dict__)
        # => Output for User: '{"name": "Alice", "email": "alice@example.com"}'

class TimestampMixin:
    def __init__(self) -> None:
        import time
        self.created_at = time.time()    # => records creation timestamp (Unix epoch)

# => COMPOSITION: Product uses both mixins, gains both capabilities
class Product(JsonSerializableMixin, TimestampMixin):
    def __init__(self, name: str, price: float) -> None:
        super().__init__()               # => calls TimestampMixin.__init__ via MRO
        self.name = name
        self.price = price

product = Product("Laptop", 1200.0)
print(product.to_json())
# => {"name": "Laptop", "price": 1200.0, "created_at": 1711234567.89}
# => to_json and created_at come from mixins — Product class has zero duplication

import json, time

# => EXPLICIT COMPOSITION: behaviors are injected, not inherited
class Serializer:
    def serialize(self, data: dict) -> str:
        return json.dumps(data)          # => converts dict to JSON string

class Clock:
    def now(self) -> float:
        return time.time()               # => returns current Unix timestamp

class Order:
    def __init__(self, order_id: int, amount: float,
                 serializer: Serializer, clock: Clock) -> None:
        self._id = order_id
        self._amount = amount
        self._serializer = serializer    # => injected behavior
        self._clock = clock              # => injected behavior
        self._created_at = clock.now()   # => records creation time via injected clock

    def to_json(self) -> str:
        return self._serializer.serialize({
            "id": self._id,
            "amount": self._amount,
            "created_at": self._created_at,
        })
        # => Output: '{"id": 1, "amount": 99.9, "created_at": 1711234567.89}'

order = Order(1, 99.9, Serializer(), Clock())
print(order.to_json())  # => '{"id": 1, "amount": 99.9, "created_at": ...}'
# => In tests: inject FakeClock that returns a fixed timestamp — fully deterministic

from abc import ABC, abstractmethod

# => REPOSITORY INTERFACE — defines the contract; no storage details
class ProductRepository(ABC):
    @abstractmethod
    def find_by_id(self, product_id: int) -> dict | None: ...

    @abstractmethod
    def save(self, product: dict) -> None: ...

    @abstractmethod
    def find_all(self) -> list[dict]: ...

# => IN-MEMORY IMPLEMENTATION — for tests and fast prototyping
class InMemoryProductRepository(ProductRepository):
    def __init__(self) -> None:
        self._store: dict[int, dict] = {}  # => in-memory dict as backing store

    def find_by_id(self, product_id: int) -> dict | None:
        return self._store.get(product_id)   # => returns dict or None

    def save(self, product: dict) -> None:
        self._store[product["id"]] = product  # => upsert by id key

    def find_all(self) -> list[dict]:
        return list(self._store.values())     # => returns all products

# => SERVICE — uses only the repository interface, not any concrete implementation
class ProductService:
    def __init__(self, repo: ProductRepository) -> None:
        self._repo = repo                     # => injected repository

    def add_product(self, product_id: int, name: str, price: float) -> dict:
        product = {"id": product_id, "name": name, "price": price}
        self._repo.save(product)              # => delegates persistence to repository
        return product

    def get_product(self, product_id: int) -> dict | None:
        return self._repo.find_by_id(product_id)
        # => delegates retrieval to repository; business layer never knows about storage

# => USAGE: inject the in-memory repo for this demo
repo = InMemoryProductRepository()
service = ProductService(repo)

p = service.add_product(1, "Laptop", 1200.0)
print(p)                             # => {"id": 1, "name": "Laptop", "price": 1200.0}
print(service.get_product(1))        # => {"id": 1, "name": "Laptop", "price": 1200.0}
print(service.get_product(99))       # => None