SOLID Principles & Object-Oriented Decomposition

+-------------------------------------------------------------------------+
|                    COUPLING vs. COHESION SPECTRUM                       |
+-------------------------------------------------------------------------+
| Dimension | High / Desirable State           | Low / Pathological State |
+-----------+----------------------------------+--------------------------+
| Cohesion  | FUNCTIONAL COHESION              | COINCIDENTAL COHESION    |
| (Internal | All module elements contribute to| Random, unrelated tasks  |
|  focus)   | a single well-defined purpose.   | grouped into one file.   |
+-----------+----------------------------------+--------------------------+
| Coupling  | DATA / MESSAGE COUPLING          | CONTENT COUPLING         |
| (External | Modules interact strictly through| One module directly reads|
|  depend.) | minimal, explicit parameters.    | or mutates another's data|
+-----------+----------------------------------+--------------------------+

+-------------------------------------------------------------------------+
|                  CHIDAMBER & KEMERER (C&K) METRIC SUITE                 |
+-------------------------------------------------------------------------+
| Metric | Full Name                    | Target Value | Architectural Risk|
+--------+------------------------------+--------------+-------------------+
| WMC    | Weighted Methods per Class   | Low (< 20)   | High complexity   |
| DIT    | Depth of Inheritance Tree    | Low (<= 4)   | Fragile base class|
| NOC    | Number of Children           | Moderate     | High impact of mod|
| CBO    | Coupling Between Objects     | Low (< 10)   | Low reusability   |
| RFC    | Response for a Class         | Low (< 50)   | Hard to test/debug|
| LCOM*  | Lack of Cohesion in Methods  | Near 0.0     | Violates SRP      |
+--------+------------------------------+--------------+-------------------+

+-------------------------------------------------------------------------+
|                  THE SOLID ARCHITECTURAL AXIOMS                         |
+-------------------------------------------------------------------------+
| Letter | Principle Name                 | Core Architectural Directive  |
+--------+--------------------------------+-------------------------------+
| S      | Single Responsibility (SRP)    | One reason to change / 1 actor|
| O      | Open / Closed (OCP)            | Open to extend, closed to edit|
| L      | Liskov Substitution (LSP)      | Subtypes preserve contracts   |
| I      | Interface Segregation (ISP)    | Client-tailored role interfaces|
| D      | Dependency Inversion (DIP)     | Depend on abstractions, not IO|
+--------+--------------------------------+-------------------------------+

# CATASTROPHIC ANTI-PATTERN: Violates Single Responsibility Principle
class Employee:
    def __init__(self, name: str, hours: float, pay_rate: float):
        self.name = name
        self.hours = hours
        self.pay_rate = pay_rate

    # Reason to Change 1: Financial Accounting (CFO Actor)
    def calculate_pay(self) -> float:
        regular_hours = self._get_regular_hours()
        return regular_hours * self.pay_rate

    # Reason to Change 2: Operations & Shift Management (COO Actor)
    def report_hours(self) -> str:
        regular_hours = self._get_regular_hours()
        return f"Report: {self.name} worked {regular_hours} regular hours."

    # Shared private utility method!
    def _get_regular_hours(self) -> float:
        return min(self.hours, 40.0)

    # Reason to Change 3: Database Administration & Persistence (CTO Actor)
    def save_to_database(self):
        sql = f"INSERT INTO employees VALUES ('{self.name}', {self.hours}, {self.pay_rate})"
        db.execute(sql)

# CLEAN SRP REFACTORING

# 1. Pure Domain Data Structure
class EmployeeData:
    def __init__(self, emp_id: int, name: str, hours: float, pay_rate: float):
        self.emp_id = emp_id
        self.name = name
        self.hours = hours
        self.pay_rate = pay_rate


# 2. Responsible exclusively to CFO Actor
class PayCalculator:
    def calculate_pay(self, employee: EmployeeData) -> float:
        regular_hours = min(employee.hours, 40.0)
        overtime_hours = max(0.0, employee.hours - 40.0)
        return (regular_hours * employee.pay_rate) + (overtime_hours * employee.pay_rate * 1.5)


# 3. Responsible exclusively to COO Actor
class HourReporter:
    def generate_shift_report(self, employee: EmployeeData) -> str:
        regular_hours = min(employee.hours, 40.0)
        return f"Shift Report: {employee.name} logged {regular_hours} baseline hours."


# 4. Responsible exclusively to CTO / Data Tier Actor
class EmployeeRepository:
    def __init__(self, db_connection):
        self.db = db_connection

    def save(self, employee: EmployeeData):
        query = "INSERT INTO employees (id, name, hours, rate) VALUES (%s, %s, %s, %s)"
        self.db.execute(query, (employee.emp_id, employee.name, employee.hours, employee.pay_rate))

# CATASTROPHIC ANTI-PATTERN: Violates Open/Closed Principle
class PaymentProcessor:
    def process_payment(self, payment_type: str, amount: float):
        if payment_type == "CREDIT_CARD":
            print(f"Charging {amount} via Visa/MasterCard API")
        elif payment_type == "PAYPAL":
            print(f"Charging {amount} via PayPal OAuth Redirect")
        elif payment_type == "BITCOIN":
            print(f"Broadcasting {amount} on Bitcoin Blockchain")
        # Every time a new payment method (ApplePay, Stripe, Klarna) is added,
        # we must EDIT this existing class, re-test existing payment methods,
        # and re-deploy the entire module!

from abc import ABC, abstractmethod


# Abstract Specification (Closed for modification)
class PaymentStrategy(ABC):
    @abstractmethod
    def pay(self, amount: float) -> bool:
        pass


# Extension 1
class CreditCardPayment(PaymentStrategy):
    def pay(self, amount: float) -> bool:
        print(f"Charging {amount} via Visa/Mastercard gateway")
        return True


# Extension 2
class PayPalPayment(PaymentStrategy):
    def pay(self, amount: float) -> bool:
        print(f"Charging {amount} via PayPal REST API")
        return True


# Extension 3 (Added without touching existing code!)
class ApplePayPayment(PaymentStrategy):
    def pay(self, amount: float) -> bool:
        print(f"Charging {amount} via Apple Secure Enclave token")
        return True


# Core Payment Processor (Never modified when new payment types are introduced)
class PaymentProcessor:
    def execute_transaction(self, strategy: PaymentStrategy, amount: float) -> bool:
        if amount <= 0:
            raise ValueError("Amount must be positive.")
        return strategy.pay(amount)

# CATASTROPHIC ANTI-PATTERN: Violates Liskov Substitution Principle
class Rectangle:
    def __init__(self, width: float, height: float):
        self._width = width
        self._height = height

    def set_width(self, width: float):
        self._width = width

    def set_height(self, height: float):
        self._height = height

    def get_area(self) -> float:
        return self._width * self._height


class Square(Rectangle):
    def __init__(self, size: float):
        super().__init__(size, size)

    # To maintain square invariant, setting width also sets height!
    def set_width(self, width: float):
        self._width = width
        self._height = width

    def set_height(self, height: float):
        self._width = height
        self._height = height


# Client function asserting Base Type invariants
def client_verify_area(rect: Rectangle):
    rect.set_width(5.0)
    rect.set_height(4.0)
    # INVARIANT: For any valid Rectangle, setting width=5 and height=4 yields area=20!
    assert rect.get_area() == 20.0, f"Expected 20, got {rect.get_area()}"

class Shape(ABC):
    @abstractmethod
    def get_area(self) -> float:
        pass


class Rectangle(Shape):
    def __init__(self, width: float, height: float):
        self.width = width
        self.height = height

    def get_area(self) -> float:
        return self.width * self.height


class Square(Shape):
    def __init__(self, side: float):
        self.side = side

    def get_area(self) -> float:
        return self.side * self.side

+-------------------------------------------------------------------------+
|                  FAT INTERFACE vs. SEGREGATED ROLE INTERFACES           |
+-------------------------------------------------------------------------+
|                                                                         |
|  FAT INTERFACE (Anti-Pattern):                                          |
|  +-------------------------------------------------------------------+  |
|  | IMachine: print(), scan(), fax(), staple(), duplex(), photocopy() |  |
|  +-------------------------------------------------------------------+  |
|         ^                                            ^                  |
|         |                                            |                  |
|  BasicPrinter (Doesn't have scanner!)      OldFaxMachine (No printer!)   |
|  Throws NotImplementedException!           Throws NotImplementedException!
|                                                                         |
|  SEGREGATED ROLE INTERFACES (ISP Compliant):                            |
|  +-------------+     +-------------+     +-------------+                |
|  |  IPrinter   |     |   IScanner  |     |    IFax     |                |
|  | - print()   |     | - scan()    |     | - fax()     |                |
|  +-------------+     +-------------+     +-------------+                |
|         ^                   ^                   ^                       |
|         |                   |                   |                       |
|  BasicPrinter:          OfficeMultiFunctionDevice:                      |
|  implements IPrinter    implements IPrinter, IScanner, IFax             |
+-------------------------------------------------------------------------+

Traditional Procedural Dependency:
[ High-Level Business Logic ] ----------> [ Low-Level SQL Database Access ]
(Rigid, Impossible to unit-test without real database)

Inverted Object-Oriented Dependency (DIP):
[ High-Level Business Logic ] ----------> [ IUserRepository Interface ]
                                                    ^
                                                    | (Implements)
[ PostgresUserRepository Implementation ] ----------+

import inspect
from abc import ABC, abstractmethod
from typing import Dict, List, Set, Type, Any, Optional


# =========================================================================
# PART 1: FORMAL OBJECT-ORIENTED CODE METRIC ANALYZER
# =========================================================================

class ClassMetricsCalculator:
    '''
    Calculates formal software engineering metrics:
    - Henderson-Sellers LCOM* (Lack of Cohesion in Methods)
    - CBO (Coupling Between Objects)
    '''

    @staticmethod
    def calculate_lcom_star(target_class: type) -> float:
        '''
        Computes Henderson-Sellers LCOM*:
        LCOM* = (m - (1/a) * sum(mu(A_j))) / (m - 1)
        Returns: float in range [0.0, 1.0]
        '''
        # Extract user-defined methods (excluding dunder methods)
        methods = [
            name for name, func in inspect.getmembers(target_class, predicate=inspect.isfunction)
            if not name.startswith("__")
        ]
        m = len(methods)
        if m <= 1:
            return 0.0  # Classes with 0 or 1 method have perfect cohesion by definition

        # Inspect source code to detect instance attribute accesses (self.attr)
        attributes_accessed: Dict[str, Set[str]] = {}  # method_name -> set of attrs
        all_attributes: Set[str] = set()

        for method_name in methods:
            func = getattr(target_class, method_name)
            try:
                source = inspect.getsource(func)
            except (OSError, IOError):
                continue
            
            # Simple lexical extraction of 'self.<var>'
            accessed = set()
            tokens = source.split()
            for token in tokens:
                if token.startswith("self."):
                    clean = token[5:].split(".")[0].split("(")[0].strip(";,:")
                    if clean and not clean.startswith("_") and not callable(getattr(target_class, clean, None)):
                        accessed.add(clean)
            attributes_accessed[method_name] = accessed
            all_attributes.update(accessed)

        a = len(all_attributes)
        if a == 0:
            return 0.0

        # Sum of mu(A_j)
        sum_mu = sum(
            sum(1 for method_name in methods if attr in attributes_accessed.get(method_name, set()))
            for attr in all_attributes
        )

        mean_access = sum_mu / a
        lcom_star = (m - mean_access) / (m - 1)
        return max(0.0, min(1.0, lcom_star))


# =========================================================================
# PART 2: SOLID REFACTORED NOTIFICATION & ORDER PIPELINE
# =========================================================================

# --- DOMAIN ABSTRACTIONS (DIP & ISP) ---

class INotificationService(ABC):
    '''Segregated role interface strictly for sending notifications.'''
    @abstractmethod
    def send(self, recipient: str, message: str) -> bool:
        pass


class IOrderRepository(ABC):
    '''Segregated role interface strictly for persisting order data.'''
    @abstractmethod
    def save(self, order_id: str, amount: float, customer: str):
        pass


class ITaxCalculator(ABC):
    '''Open for extension (OCP) strategy interface for regional taxes.'''
    @abstractmethod
    def calculate_tax(self, amount: float) -> float:
        pass


# --- CONCRETE STRATEGY IMPLEMENTATIONS (OCP) ---

class USTaxCalculator(ITaxCalculator):
    def calculate_tax(self, amount: float) -> float:
        return amount * 0.0825  # 8.25% sales tax


class EUTaxCalculator(ITaxCalculator):
    def calculate_tax(self, amount: float) -> float:
        return amount * 0.20    # 20.0% VAT


# --- INFRASTRUCTURE ADAPTERS (DIP) ---

class EmailNotificationService(INotificationService):
    def send(self, recipient: str, message: str) -> bool:
        print(f"[SMTP Email -> {recipient}]: {message}")
        return True


class InMemoryOrderRepository(IOrderRepository):
    def __init__(self):
        self.storage: Dict[str, Dict[str, Any]] = {}

    def save(self, order_id: str, amount: float, customer: str):
        self.storage[order_id] = {"amount": amount, "customer": customer}
        print(f"[Database]: Saved Order #{order_id} successfully.")


# --- HIGH-LEVEL APPLICATION DOMAIN SERVICE (SRP & DIP) ---

class OrderProcessor:
    '''
    Single Responsibility: Orchestrating order fulfillment.
    Depends exclusively on abstractions (DIP).
    '''
    def __init__(self, repository: IOrderRepository,
                 notifier: INotificationService,
                 tax_calculator: ITaxCalculator):
        self.repository = repository
        self.notifier = notifier
        self.tax_calculator = tax_calculator

    def process_order(self, order_id: str, customer_email: str, subtotal: float) -> float:
        tax = self.tax_calculator.calculate_tax(subtotal)
        total = subtotal + tax

        # Persist via abstraction
        self.repository.save(order_id, total, customer_email)

        # Notify via abstraction
        msg = f"Order #{order_id} confirmed. Total charged: {total:.2f} (Tax: {tax:.2f})"
        self.notifier.send(customer_email, msg)

        return total


# --- SIMPLE INVERSION OF CONTROL (IoC) CONTAINER ---

class Container:
    def __init__(self):
        self._services: Dict[Type, Any] = {}

    def register(self, interface: Type, implementation: Any):
        self._services[interface] = implementation

    def resolve(self, interface: Type) -> Any:
        if interface not in self._services:
            raise KeyError(f"Service {interface} not registered in container.")
        return self._services[interface]


# Demonstration and Verification Harness
if __name__ == "__main__":
    print("=== 1. Testing Formal Object-Oriented Metrics ===")

    class HighCohesionClass:
        def __init__(self):
            self.x = 0
            self.y = 0
        def op1(self):
            return self.x + self.y
        def op2(self):
            return self.x * self.y

    class LowCohesionGodObject:
        def __init__(self):
            self.a = 1
            self.b = 2
            self.c = 3
            self.d = 4
        def m1(self):
            return self.a
        def m2(self):
            return self.b
        def m3(self):
            return self.c
        def m4(self):
            return self.d

    lcom_high = ClassMetricsCalculator.calculate_lcom_star(HighCohesionClass)
    lcom_low = ClassMetricsCalculator.calculate_lcom_star(LowCohesionGodObject)
    print(f"LCOM* of HighCohesionClass:  {lcom_high:.4f} (Ideal: near 0.0)")
    print(f"LCOM* of LowCohesionGodObject: {lcom_low:.4f} (High lack of cohesion: near 1.0)\n")

    print("=== 2. Testing SOLID Order Processing Pipeline ===")
    container = Container()
    container.register(IOrderRepository, InMemoryOrderRepository())
    container.register(INotificationService, EmailNotificationService())
    container.register(ITaxCalculator, USTaxCalculator())

    processor = OrderProcessor(
        repository=container.resolve(IOrderRepository),
        notifier=container.resolve(INotificationService),
        tax_calculator=container.resolve(ITaxCalculator)
    )

    total = processor.process_order(
        order_id="ORD-9901",
        customer_email="alice@techcorp.com",
        subtotal=100.00
    )
    print(f"Transaction completed cleanly. Billed: {total:.2f}")

// ANTI-PATTERN: Speculative Generality (Violates YAGNI)
public interface IUserService { ... }
public class UserServiceImpl implements IUserService { ... }

# ANTI-PATTERN: Primitive Obsession
def create_user(email: str, phone: str, zip_code: str):
    pass

+-------------------------------------------------------------------------+
|                  CHECKPOINT PROBLEMS OVERVIEW                           |
+-------------------------------------------------------------------------+
| Problem 1 | Henderson-Sellers LCOM* Metric Mathematical Calculation    |
| Problem 2 | Formal Liskov Substitution Principle Contract Verification  |
| Problem 3 | Dependency Inversion Refactoring & Architecture Dependency  |
| Problem 4 | Coupling Between Objects (CBO) & Cyclomatic Complexity      |
+-------------------------------------------------------------------------+

Method                 balance  interest_rate  transaction_history  owner_tax_id
--------------------   -------  -------------  -------------------  ------------
deposit()                 1           0                 1                0
withdraw()                1           0                 1                0
calculate_interest()      1           1                 0                0
print_statement()         1           0                 1                1
audit_log()               0           0                 1                1

class BankAccount:
    def __init__(self, balance: float):
        self.balance = balance

    def withdraw(self, amount: float) -> float:
        # Precondition: amount > 0 and amount <= self.balance
        # Postcondition: self.balance is reduced by amount; returns amount
        if amount <= 0 or amount > self.balance:
            raise ValueError("Invalid withdrawal amount.")
        self.balance -= amount
        return amount

class PremiumAccount(BankAccount):
    def withdraw(self, amount: float) -> float:
        # Allows overdraft up to 1 USD,000 with a 10 USD penalty fee
        if amount <= 0 or amount > (self.balance + 1000.0):
            raise ValueError("Exceeds overdraft limit.")
        if amount > self.balance:
            self.balance -= 10.0  # Overdraft fee
        self.balance -= amount
        return amount

class FixedDepositAccount(BankAccount):
    def withdraw(self, amount: float) -> float:
        # Cannot withdraw if account has not reached maturity date (lockup period)
        if not self.is_mature():
            raise PermissionError("Funds locked until maturity date.")
        if amount <= 0 or amount > self.balance:
            raise ValueError("Invalid withdrawal amount.")
        self.balance -= amount
        return amount

class MySQLDatabase:
    def query(self, sql: str) -> list:
        return [{"id": 1, "email": "alice@corp.com"}]

class SendGridMailer:
    def send_email(self, to: str, subject: str, body: str):
        print(f"Sending email via SendGrid API to {to}")

class MarketingService:
    def __init__(self):
        # DIRECT DEPENDENCY ON CONCRETE IMPLEMENTATIONS!
        self.db = MySQLDatabase()
        self.mailer = SendGridMailer()

    def send_campaign(self, campaign_text: str):
        users = self.db.query("SELECT id, email FROM users WHERE subscribed = 1")
        for user in users:
            self.mailer.send_email(user["email"], "Special Promotion", campaign_text)

from abc import ABC, abstractmethod
from typing import List, Dict

# Abstractions (Domain Layer)
class ISubscriberRepository(ABC):
    @abstractmethod
    def get_subscribed_emails(self) -> List[str]:
        pass

class IEmailGateway(ABC):
    @abstractmethod
    def send(self, to: str, subject: str, body: str) -> bool:
        pass

# High-Level Business Module (DIP Compliant)
class MarketingService:
    def __init__(self, subscriber_repo: ISubscriberRepository, email_gateway: IEmailGateway):
        self.repo = subscriber_repo
        self.gateway = email_gateway

    def send_campaign(self, campaign_text: str) -> int:
        emails = self.repo.get_subscribed_emails()
        count = 0
        for email in emails:
            if self.gateway.send(email, "Special Promotion", campaign_text):
                count += 1
        return count

class MockSubscriberRepository(ISubscriberRepository):
    def get_subscribed_emails(self) -> List[str]:
        return ["test1@test.com", "test2@test.com"]

class MockEmailGateway(IEmailGateway):
    def __init__(self):
        self.sent = []
    def send(self, to: str, subject: str, body: str) -> bool:
        self.sent.append(to)
        return True

def test_marketing_service():
    mock_repo = MockSubscriberRepository()
    mock_mailer = MockEmailGateway()
    service = MarketingService(mock_repo, mock_mailer)
    
    sent_count = service.send_campaign("Spring Discount!")
    assert sent_count == 2
    assert mock_mailer.sent == ["test1@test.com", "test2@test.com"]
    print("Unit Test PASSED in 0.001 seconds with ZERO external dependencies.")

class TransactionValidator:
    def validate(self, txn: Transaction, user: User, fraud_detector: FraudEngine,
                 compliance: AMLService, ledger: GeneralLedger, notifier: AlertService) -> bool:
        if not user.is_active():
            notifier.alert("Inactive user")
            return False
        if txn.amount > 10000.0:
            if not compliance.verify_kyc(user.tax_id):
                notifier.alert("KYC required")
                return False
        if fraud_detector.score(txn) > 0.85:
            notifier.alert("Fraud suspected")
            return False
        ledger.record_pending(txn)
        return True