# === 1. 内容結合（最悪）: 他モジュールの内部実装に依存 ===
class OrderProcessor:
    def process(self, cart):
        # Cart の private 実装を直接操作
        cart._items[0]._price = cart._items[0]._price * 0.9
        cart._total_cache = None  # キャッシュを手動リセット
        # → Cart の内部実装が変わると即座に壊れる
 
# === 2. 共通結合（悪い）: グローバル変数を共有 ===
GLOBAL_CONFIG = {}
 
class ServiceA:
    def do_work(self):
        GLOBAL_CONFIG['last_run'] = datetime.now()
        GLOBAL_CONFIG['status'] = 'running'
 
class ServiceB:
    def do_work(self):
        # ServiceA の副作用に依存
        if GLOBAL_CONFIG.get('last_run'):
            pass
        # → ServiceA の実装変更が ServiceB に影響
 
# === 3. 外部結合（注意）: 外部フォーマットを共有 ===
class CsvExporter:
    def export(self, data):
        # 共通CSVフォーマット: "id,name,price\n" に依存
        return ",".join([str(data['id']), data['name'], str(data['price'])])
 
class CsvImporter:
    def import_data(self, csv_line):
        # 同じCSVフォーマットに依存
        parts = csv_line.split(",")
        return {'id': int(parts[0]), 'name': parts[1], 'price': float(parts[2])}
    # → フォーマット変更時に両方修正が必要
 
# === 4. 制御結合（要注意）: フラグで動作を切り替え ===
class ReportGenerator:
    def generate(self, data, format_type: str):
        if format_type == 'pdf':
            return self._generate_pdf(data)
        elif format_type == 'csv':
            return self._generate_csv(data)
        elif format_type == 'excel':
            return self._generate_excel(data)
    # → 呼び出し側が内部の分岐ロジックを知っている
 
# === 5. スタンプ結合（許容）: データ構造を丸ごと渡す ===
class EmailSender:
    def send_welcome(self, user: User):
        # User オブジェクト全体を受け取るが name と email のみ使用
        send_email(to=user.email, subject=f"Welcome {user.name}")
    # → User の構造変更が影響する可能性
 
# === 6. データ結合（理想）: 必要なプリミティブ値のみ受け渡し ===
class TaxCalculator:
    def calculate(self, subtotal: float, tax_rate: float) -> float:
        return subtotal * tax_rate
    # → 引数はプリミティブ値のみ。他の型に依存しない
 
# === 7. メッセージ結合（最理想）: メッセージのみで通信 ===
class OrderService:
    def __init__(self, event_bus: EventBus):
        self.event_bus = event_bus
 
    def place_order(self, order):
        order.confirm()
        self.event_bus.publish('order_placed', {'order_id': order.id})
    # → 受信者の存在すら知らない

from typing import Callable, Any
from dataclasses import dataclass, field
from datetime import datetime
 
# === Before: 強結合 ===
# OrderService が直接 InventoryService、NotificationService、AnalyticsService を呼ぶ
 
class OrderServiceTightlyCoupled:
    def __init__(self):
        self.inventory = InventoryService()     # 具象クラスに直接依存
        self.notification = NotificationService() # 具象クラスに直接依存
        self.analytics = AnalyticsService()     # 具象クラスに直接依存
 
    def place_order(self, order):
        self.inventory.reduce_stock(order.items)
        self.notification.send_confirmation(order)
        self.analytics.track_purchase(order)
        # → 新しい処理を追加するたびにこのクラスを修正する必要がある（OCP違反）
        # → 各サービスのテスト時にすべての依存を用意する必要がある
 
 
# === After: イベント駆動で疎結合 ===
 
@dataclass
class DomainEvent:
    """ドメインイベントの基底クラス"""
    occurred_at: datetime = field(default_factory=datetime.now)
 
@dataclass
class OrderPlacedEvent(DomainEvent):
    """注文確定イベント"""
    order_id: str = ""
    customer_id: str = ""
    items: list = field(default_factory=list)
    total_amount: float = 0.0
 
class EventBus:
    """シンプルなインメモリイベントバス"""
    def __init__(self):
        self._handlers: dict[type, list[Callable]] = {}
 
    def subscribe(self, event_type: type, handler: Callable) -> None:
        self._handlers.setdefault(event_type, []).append(handler)
 
    def publish(self, event: DomainEvent) -> None:
        for handler in self._handlers.get(type(event), []):
            handler(event)
 
    def unsubscribe(self, event_type: type, handler: Callable) -> None:
        handlers = self._handlers.get(event_type, [])
        if handler in handlers:
            handlers.remove(handler)
 
class OrderService:
    """注文サービス - イベントの発行のみを責任に持つ"""
    def __init__(self, event_bus: EventBus):
        self.event_bus = event_bus
 
    def place_order(self, order) -> None:
        order.confirm()
        # 他のサービスの存在を知らない
        self.event_bus.publish(OrderPlacedEvent(
            order_id=order.id,
            customer_id=order.customer_id,
            items=order.items,
            total_amount=order.total_amount
        ))
 
# 各ハンドラは独立して登録・テスト可能
class InventoryHandler:
    def handle_order_placed(self, event: OrderPlacedEvent) -> None:
        for item in event.items:
            self.reduce_stock(item.product_id, item.quantity)
 
class NotificationHandler:
    def handle_order_placed(self, event: OrderPlacedEvent) -> None:
        self.send_confirmation_email(event.customer_id, event.order_id)
 
class AnalyticsHandler:
    def handle_order_placed(self, event: OrderPlacedEvent) -> None:
        self.track_purchase(event.order_id, event.total_amount)
 
# 組み立て（Composition Root）
event_bus = EventBus()
event_bus.subscribe(OrderPlacedEvent, InventoryHandler().handle_order_placed)
event_bus.subscribe(OrderPlacedEvent, NotificationHandler().handle_order_placed)
event_bus.subscribe(OrderPlacedEvent, AnalyticsHandler().handle_order_placed)
 
# 新しいハンドラを追加しても OrderService は変更不要（OCP準拠）
# event_bus.subscribe(OrderPlacedEvent, LoyaltyPointHandler().handle_order_placed)

from abc import ABC, abstractmethod
from typing import Protocol
 
# === インターフェース（抽象）を定義 ===
 
class PaymentGateway(Protocol):
    """決済ゲートウェイのインターフェース"""
    def charge(self, amount: float, currency: str) -> PaymentResult: ...
 
class NotificationService(Protocol):
    """通知サービスのインターフェース"""
    def send(self, recipient: str, message: str) -> None: ...
 
class OrderRepository(Protocol):
    """注文リポジトリのインターフェース"""
    def save(self, order: Order) -> None: ...
    def find_by_id(self, order_id: str) -> Order | None: ...
 
 
# === 具象クラスの実装 ===
 
class StripePaymentGateway:
    """Stripe による決済実装"""
    def __init__(self, api_key: str):
        self.api_key = api_key
 
    def charge(self, amount: float, currency: str) -> PaymentResult:
        # Stripe API を呼び出す
        response = stripe.Charge.create(amount=int(amount * 100), currency=currency)
        return PaymentResult(success=True, transaction_id=response.id)
 
class EmailNotificationService:
    """メールによる通知実装"""
    def __init__(self, smtp_config: SmtpConfig):
        self.smtp = smtp_config
 
    def send(self, recipient: str, message: str) -> None:
        # SMTP経由でメール送信
        send_email(to=recipient, body=message, config=self.smtp)
 
class PostgresOrderRepository:
    """PostgreSQL による注文永続化"""
    def __init__(self, connection_pool):
        self.pool = connection_pool
 
    def save(self, order: Order) -> None:
        with self.pool.connection() as conn:
            conn.execute("INSERT INTO orders ...", order.to_dict())
 
    def find_by_id(self, order_id: str) -> Order | None:
        with self.pool.connection() as conn:
            row = conn.execute("SELECT * FROM orders WHERE id = %s", [order_id])
            return Order.from_dict(row) if row else None
 
 
# === サービスは抽象にのみ依存 ===
 
class OrderService:
    """注文サービス - 具象クラスを一切知らない"""
    def __init__(
        self,
        repository: OrderRepository,
        payment: PaymentGateway,
        notification: NotificationService,
    ):
        self.repository = repository
        self.payment = payment
        self.notification = notification
 
    def place_order(self, order: Order) -> OrderResult:
        payment_result = self.payment.charge(order.total, order.currency)
        if not payment_result.success:
            return OrderResult.payment_failed(payment_result.error)
 
        self.repository.save(order)
        self.notification.send(
            order.customer_email,
            f"ご注文 {order.id} を承りました"
        )
        return OrderResult.success(order.id)
 
 
# === テスト時: モックを注入 ===
 
class MockPaymentGateway:
    def __init__(self, should_succeed: bool = True):
        self.should_succeed = should_succeed
        self.charges: list = []
 
    def charge(self, amount: float, currency: str) -> PaymentResult:
        self.charges.append((amount, currency))
        if self.should_succeed:
            return PaymentResult(success=True, transaction_id="mock-txn-001")
        return PaymentResult(success=False, error="Mock decline")
 
class MockNotificationService:
    def __init__(self):
        self.sent_messages: list = []
 
    def send(self, recipient: str, message: str) -> None:
        self.sent_messages.append((recipient, message))
 
# テスト
def test_place_order_success():
    mock_payment = MockPaymentGateway(should_succeed=True)
    mock_notification = MockNotificationService()
    mock_repository = InMemoryOrderRepository()
 
    service = OrderService(mock_repository, mock_payment, mock_notification)
    result = service.place_order(create_test_order())
 
    assert result.is_success
    assert len(mock_payment.charges) == 1
    assert len(mock_notification.sent_messages) == 1

# CBO（Coupling Between Objects）の計測例
# 以下のクラスのCBOを数える
 
class OrderService:                  # CBO = 5
    def __init__(
        self,
        repository: OrderRepository,    # 1. OrderRepository
        payment: PaymentGateway,         # 2. PaymentGateway
        notification: NotificationService, # 3. NotificationService
        logger: Logger,                  # 4. Logger
    ):
        pass
 
    def place_order(self, order: Order) -> OrderResult:  # 5. Order, 6. OrderResult
        pass
    # → CBO = 6（依存先クラス数）
    # → 10以下なので許容範囲
 
# CBOが高すぎるクラスの例
class GodService:                    # CBO = 15+
    def __init__(
        self,
        user_repo, order_repo, product_repo,     # 3
        payment, shipping, tax_calculator,        # 3
        email_service, sms_service, push_service, # 3
        cache, logger, metrics,                   # 3
        config, event_bus, scheduler              # 3
    ):
        pass
    # → CBO = 15: リファクタリング対象

// === 1. 偶発的凝集（最低）: 無関係な機能の寄せ集め ===
class Utilities {
    public static String formatDate(Date d) { /* 日付処理 */ }
    public static double calculateTax(double amount) { /* 税計算 */ }
    public static void sendEmail(String to, String body) { /* メール送信 */ }
    public static Image resizeImage(Image img, int w, int h) { /* 画像処理 */ }
    // → 日付、税、メール、画像に何の関係もない
}
 
// === 2. 論理的凝集（低い）: 似た種類を集めただけ ===
class InputHandler {
    public void handleMouseInput(MouseEvent e) { /* マウス処理 */ }
    public void handleKeyboardInput(KeyEvent e) { /* キーボード処理 */ }
    public void handleTouchInput(TouchEvent e) { /* タッチ処理 */ }
    public void handleGamepadInput(GamepadEvent e) { /* ゲームパッド処理 */ }
    // → 「入力」という論理的カテゴリで集めただけ。各処理は独立
}
 
// === 3. 時間的凝集（中程度）: 同じタイミングで実行するだけ ===
class AppInitializer {
    public void initialize() {
        loadConfig();       // 設定読み込み
        initDatabase();     // DB初期化
        startWebServer();   // Webサーバー起動
        registerShutdownHook(); // シャットダウンフック登録
    }
    // → 「アプリ起動時」というタイミングで集めただけ
}
 
// === 4. 手続き的凝集: 特定の順序で実行 ===
class FileProcessor {
    public void process(String path) {
        openFile(path);
        readHeader();
        parseBody();
        closeFile();
    }
    // → 順序は決まっているが、open/read/parse/closeは概念的に異なる
}
 
// === 5. 通信的凝集: 同じデータを操作 ===
class EmployeeReport {
    private List<Employee> employees;
 
    public double calculateAverageSalary() { /* employees を使う */ }
    public Employee findHighestPaid() { /* employees を使う */ }
    public List<Employee> filterByDepartment(String dept) { /* employees を使う */ }
    // → 全メソッドが employees フィールドを操作
}
 
// === 6. 逐次的凝集: パイプライン処理 ===
class DataPipeline {
    public Report generate(RawData raw) {
        CleanedData cleaned = clean(raw);       // 生データ → 洗浄データ
        AnalyzedData analyzed = analyze(cleaned); // 洗浄データ → 分析データ
        return format(analyzed);                  // 分析データ → レポート
    }
    // → 各ステップの出力が次のステップの入力
}
 
// === 7. 機能的凝集（最高）: 1つの明確な責任 ===
class PasswordHasher {
    private final int saltLength;
    private final int iterations;
 
    public PasswordHasher(int saltLength, int iterations) {
        this.saltLength = saltLength;
        this.iterations = iterations;
    }
 
    public String hash(String password) {
        byte[] salt = generateSalt();
        return pbkdf2(password, salt, iterations);
    }
 
    public boolean verify(String password, String hashedPassword) {
        byte[] salt = extractSalt(hashedPassword);
        String rehashed = pbkdf2(password, salt, iterations);
        return constantTimeEquals(rehashed, hashedPassword);
    }
 
    private byte[] generateSalt() { /* ソルト生成 */ }
    private byte[] extractSalt(String hash) { /* ソルト抽出 */ }
    private String pbkdf2(String password, byte[] salt, int iterations) { /* ハッシュ計算 */ }
    // → 「パスワードのハッシュ化」という1つの責任のみ
}

# LCOM の計算例
 
class HighCohesion:
    """LCOM = 低い（凝集度が高い）"""
    def __init__(self, x, y):
        self.x = x  # フィールド1
        self.y = y  # フィールド2
 
    def distance_from_origin(self):
        return (self.x**2 + self.y**2) ** 0.5  # x, y 両方使用
 
    def move(self, dx, dy):
        self.x += dx  # x 使用
        self.y += dy  # y 使用
 
    def __str__(self):
        return f"({self.x}, {self.y})"  # x, y 両方使用
 
    # m=3, f=2
    # x: 3メソッドがアクセス, y: 3メソッドがアクセス
    # LCOM* = (3 - (1/2) * (3+3)) / (3-1) = (3 - 3) / 2 = 0
    # → LCOM = 0: 完全に凝集
 
 
class LowCohesion:
    """LCOM = 高い（凝集度が低い）"""
    def __init__(self):
        self.user_name = ""     # フィールド1
        self.order_total = 0.0  # フィールド2
        self.log_level = "INFO" # フィールド3
 
    def get_user_name(self):
        return self.user_name       # user_name のみ使用
 
    def calculate_total(self):
        return self.order_total * 1.1  # order_total のみ使用
 
    def set_log_level(self, level):
        self.log_level = level      # log_level のみ使用
 
    # m=3, f=3
    # user_name: 1, order_total: 1, log_level: 1
    # LCOM* = (3 - (1/3) * (1+1+1)) / (3-1) = (3 - 1) / 2 = 1.0
    # → LCOM = 1.0: 完全に非凝集 → 3つの独立したクラスに分割すべき

// ============================================================
// Before: 高結合 - クライアントが複数のサブシステムに直接依存
// ============================================================
class OrderPage {
  placeOrder(cart: Cart) {
    const inventory = new InventorySystem();
    const payment = new PaymentGateway();
    const shipping = new ShippingCalculator();
    const notification = new EmailService();
    const loyalty = new LoyaltyPointService();
 
    // 5つのサブシステムに直接依存（CBO = 5）
    const available = inventory.check(cart.items);
    if (!available) throw new Error('在庫不足');
 
    const total = shipping.calculate(cart);
    const paymentResult = payment.charge(cart.customer, total);
    notification.sendConfirmation(cart.customer.email);
    loyalty.addPoints(cart.customer.id, Math.floor(total / 100));
  }
}
 
// ============================================================
// After: Facade で結合を集約
// ============================================================
 
// Facade は内部のサブシステムを隠蔽する
class OrderFacade {
  constructor(
    private inventory: InventorySystem,
    private payment: PaymentGateway,
    private shipping: ShippingCalculator,
    private notification: EmailService,
    private loyalty: LoyaltyPointService
  ) {}
 
  placeOrder(cart: Cart): OrderResult {
    // 内部の協調ロジックを Facade が管理
    if (!this.inventory.check(cart.items)) {
      return OrderResult.outOfStock();
    }
 
    const total = this.shipping.calculate(cart);
 
    const paymentResult = this.payment.charge(cart.customer, total);
    if (!paymentResult.success) {
      return OrderResult.paymentFailed(paymentResult.error);
    }
 
    // 非クリティカルな処理は失敗しても注文は成功とする
    this.trySendConfirmation(cart.customer.email);
    this.tryAddLoyaltyPoints(cart.customer.id, total);
 
    return OrderResult.success(paymentResult.transactionId);
  }
 
  private trySendConfirmation(email: string): void {
    try {
      this.notification.sendConfirmation(email);
    } catch (e) {
      console.warn('確認メール送信失敗', e);
    }
  }
 
  private tryAddLoyaltyPoints(customerId: string, total: number): void {
    try {
      this.loyalty.addPoints(customerId, Math.floor(total / 100));
    } catch (e) {
      console.warn('ポイント付与失敗', e);
    }
  }
}
 
// クライアントは Facade だけに依存（CBO = 1）
class OrderPage {
  constructor(private orderFacade: OrderFacade) {}
 
  placeOrder(cart: Cart) {
    return this.orderFacade.placeOrder(cart);
  }
}

from abc import ABC, abstractmethod
from typing import Any
 
# === インターフェース: アプリケーションが期待する契約 ===
 
class FileStorage(ABC):
    """ファイルストレージのインターフェース"""
    @abstractmethod
    def upload(self, key: str, data: bytes) -> str:
        """ファイルをアップロードし、URLを返す"""
        pass
 
    @abstractmethod
    def download(self, key: str) -> bytes:
        """ファイルをダウンロードする"""
        pass
 
    @abstractmethod
    def delete(self, key: str) -> None:
        """ファイルを削除する"""
        pass
 
    @abstractmethod
    def exists(self, key: str) -> bool:
        """ファイルが存在するか確認する"""
        pass
 
 
# === Adapter: AWS S3 の実装 ===
 
class S3FileStorage(FileStorage):
    """AWS S3 による実装"""
    def __init__(self, bucket_name: str, region: str):
        import boto3
        self.s3 = boto3.client('s3', region_name=region)
        self.bucket = bucket_name
 
    def upload(self, key: str, data: bytes) -> str:
        self.s3.put_object(Bucket=self.bucket, Key=key, Body=data)
        return f"https://{self.bucket}.s3.amazonaws.com/{key}"
 
    def download(self, key: str) -> bytes:
        response = self.s3.get_object(Bucket=self.bucket, Key=key)
        return response['Body'].read()
 
    def delete(self, key: str) -> None:
        self.s3.delete_object(Bucket=self.bucket, Key=key)
 
    def exists(self, key: str) -> bool:
        try:
            self.s3.head_object(Bucket=self.bucket, Key=key)
            return True
        except self.s3.exceptions.NoSuchKey:
            return False
 
 
# === Adapter: ローカルファイルシステムの実装（開発用） ===
 
class LocalFileStorage(FileStorage):
    """ローカルファイルシステムによる実装（開発・テスト用）"""
    def __init__(self, base_dir: str):
        self.base_dir = Path(base_dir)
        self.base_dir.mkdir(parents=True, exist_ok=True)
 
    def upload(self, key: str, data: bytes) -> str:
        file_path = self.base_dir / key
        file_path.parent.mkdir(parents=True, exist_ok=True)
        file_path.write_bytes(data)
        return f"file://{file_path}"
 
    def download(self, key: str) -> bytes:
        return (self.base_dir / key).read_bytes()
 
    def delete(self, key: str) -> None:
        (self.base_dir / key).unlink(missing_ok=True)
 
    def exists(self, key: str) -> bool:
        return (self.base_dir / key).exists()
 
 
# === サービス: ストレージの実装を知らない ===
 
class DocumentService:
    """ドキュメントサービス - FileStorage インターフェースにのみ依存"""
    def __init__(self, storage: FileStorage):
        self.storage = storage
 
    def save_document(self, name: str, content: bytes) -> str:
        key = f"documents/{name}"
        return self.storage.upload(key, content)
 
    def get_document(self, name: str) -> bytes:
        key = f"documents/{name}"
        return self.storage.download(key)
 
# 使用例
# 本番: DocumentService(S3FileStorage("my-bucket", "ap-northeast-1"))
# 開発: DocumentService(LocalFileStorage("/tmp/dev-storage"))
# テスト: DocumentService(InMemoryFileStorage())

# === モジュラーモノリス: 明確な境界を持つモジュール設計 ===
 
# --- モジュールの公開API（index.py / __init__.py） ---
 
# user_module/__init__.py
"""User モジュールの公開API"""
from .service import UserService
from .models import User, UserProfile
from .events import UserCreatedEvent, UserDeletedEvent
 
# 内部クラスはエクスポートしない
# UserRepository, UserValidator, UserMapper は内部実装
 
__all__ = ['UserService', 'User', 'UserProfile', 'UserCreatedEvent', 'UserDeletedEvent']
 
 
# --- モジュール間の通信: 公開APIのみ使用 ---
 
# order_module/service.py
class OrderService:
    def __init__(self, user_service: UserService):  # 公開APIのみに依存
        self.user_service = user_service
 
    def create_order(self, user_id: str, items: list) -> Order:
        # UserModule の公開APIのみ使用（内部実装にはアクセスしない）
        user = self.user_service.get_user(user_id)
        if not user:
            raise UserNotFoundError(user_id)
        return Order(user_id=user.id, items=items)
 
 
# --- モジュール間のルール ---
# 1. 他モジュールの内部クラスを直接 import しない
# 2. 他モジュールのDBテーブルに直接アクセスしない
# 3. モジュール間通信はイベントまたは公開APIのみ
# 4. 共有データは共有カーネル（shared kernel）に配置

# === Before: God Class（低凝集、高結合）===
 
class ApplicationManager:
    """すべての機能を持つ巨大クラス"""
    def __init__(self):
        self.db = Database()
        self.smtp = SmtpClient()
        self.cache = RedisCache()
 
    # 認証系
    def authenticate_user(self, username, password): ...
    def reset_password(self, email): ...
    def generate_token(self, user_id): ...
    def validate_token(self, token): ...
 
    # 注文系
    def create_order(self, user_id, items): ...
    def cancel_order(self, order_id): ...
    def calculate_shipping(self, order_id): ...
 
    # 通知系
    def send_email(self, to, subject, body): ...
    def send_sms(self, phone, message): ...
    def send_push_notification(self, device_id, message): ...
 
    # 在庫系
    def check_inventory(self, product_id): ...
    def update_stock(self, product_id, quantity): ...
    def reorder_if_low(self, product_id): ...
 
    # レポート系
    def generate_sales_report(self, period): ...
    def generate_inventory_report(self): ...
 
    # → LCOM は 1.0 に近い（各メソッドグループが異なるフィールドを使用）
    # → CBO は 20+ （大量の外部依存）
    # → 変更理由が 5+ （認証、注文、通知、在庫、レポート）
 
 
# === After: 責任ごとに分割（高凝集、低結合）===
 
class AuthService:
    """認証のみを担当（機能的凝集）"""
    def __init__(self, user_repo: UserRepository, token_provider: TokenProvider):
        self.user_repo = user_repo
        self.token_provider = token_provider
 
    def authenticate(self, username: str, password: str) -> AuthResult:
        user = self.user_repo.find_by_username(username)
        if user and user.verify_password(password):
            token = self.token_provider.generate(user.id)
            return AuthResult.success(token)
        return AuthResult.failure("認証失敗")
 
    def validate_token(self, token: str) -> TokenClaims | None:
        return self.token_provider.validate(token)
 
 
class OrderService:
    """注文処理のみを担当（機能的凝集）"""
    def __init__(
        self,
        order_repo: OrderRepository,
        inventory: InventoryService,
        event_bus: EventBus
    ):
        self.order_repo = order_repo
        self.inventory = inventory
        self.event_bus = event_bus
 
    def create_order(self, user_id: str, items: list[OrderItem]) -> Order:
        for item in items:
            if not self.inventory.is_available(item.product_id, item.quantity):
                raise InsufficientStockError(item.product_id)
 
        order = Order(user_id=user_id, items=items)
        self.order_repo.save(order)
        self.event_bus.publish(OrderCreatedEvent(order_id=order.id))
        return order
 
 
class NotificationService:
    """通知のみを担当（機能的凝集）"""
    def __init__(self, channels: list[NotificationChannel]):
        self.channels = channels
 
    def send(self, recipient: str, message: str, channel_type: str) -> None:
        channel = self._find_channel(channel_type)
        channel.send(recipient, message)
 
 
class InventoryService:
    """在庫管理のみを担当（機能的凝集）"""
    def __init__(self, inventory_repo: InventoryRepository, event_bus: EventBus):
        self.repo = inventory_repo
        self.event_bus = event_bus
 
    def is_available(self, product_id: str, quantity: int) -> bool:
        stock = self.repo.get_stock(product_id)
        return stock >= quantity
 
    def reduce_stock(self, product_id: str, quantity: int) -> None:
        self.repo.decrease(product_id, quantity)
        current = self.repo.get_stock(product_id)
        if current < self.repo.get_reorder_threshold(product_id):
            self.event_bus.publish(LowStockEvent(product_id=product_id))

# === 悪い: 同期的なサービス間呼び出しチェーン ===
 
class OrderApiHandler:
    """注文API - 同期的に3つのサービスを呼ぶ"""
    async def create_order(self, request):
        # 1. ユーザーサービスに問い合わせ（同期）
        user = await self.http_client.get(f"http://user-service/users/{request.user_id}")
        # → user-service がダウンすると注文不可
 
        # 2. 在庫サービスに問い合わせ（同期）
        stock = await self.http_client.get(
            f"http://inventory-service/stock/{request.product_id}"
        )
        # → inventory-service がダウンすると注文不可
 
        # 3. 決済サービスに問い合わせ（同期）
        payment = await self.http_client.post(
            "http://payment-service/charge",
            json={"amount": request.total}
        )
        # → payment-service がダウンすると注文不可
 
        # 3つのサービスすべてが利用可能でないと動かない（時間的結合）
 
 
# === 良い: 非同期イベントとサーキットブレーカー ===
 
class OrderApiHandler:
    """注文API - 非同期イベント駆動"""
    def __init__(
        self,
        order_repo: OrderRepository,
        message_queue: MessageQueue,
        circuit_breaker: CircuitBreaker,
        user_cache: UserCache,
    ):
        self.order_repo = order_repo
        self.mq = message_queue
        self.cb = circuit_breaker
        self.user_cache = user_cache
 
    async def create_order(self, request) -> OrderResult:
        # ユーザー情報はキャッシュから取得（user-service がダウンしても動く）
        user = self.user_cache.get(request.user_id)
        if not user:
            user = await self.cb.call(
                lambda: self.http_client.get(f"http://user-service/users/{request.user_id}")
            )
            self.user_cache.set(request.user_id, user)
 
        # 注文を「保留」状態で保存（ローカルDBのみ）
        order = Order(user_id=user.id, items=request.items, status='PENDING')
        self.order_repo.save(order)
 
        # 非同期イベントを発行（他のサービスが独立して処理）
        await self.mq.publish('order.created', {
            'order_id': order.id,
            'items': [item.to_dict() for item in request.items],
            'total': request.total,
        })
 
        return OrderResult.pending(order.id)
        # → 他のサービスがダウンしても注文の受付自体は可能

# NG: 1つのモジュールがシステム全体の機能を持つ
class ApplicationManager:
    def authenticate_user(self, ...): ...
    def process_payment(self, ...): ...
    def generate_invoice(self, ...): ...
    def send_notification(self, ...): ...
    def update_inventory(self, ...): ...
    def calculate_shipping(self, ...): ...
    def manage_cache(self, ...): ...
    # 全ドメインの知識がここに集中
    # LCOM ≈ 1.0（各メソッドグループが異なるフィールドを使用）
    # CBO ≥ 20（大量の外部依存）
 
# OK: ドメインごとにサービスを分割
class AuthService:
    """認証のみ"""
    def authenticate(self, username, password): ...
    def validate_token(self, token): ...
 
class PaymentService:
    """決済のみ"""
    def charge(self, amount, payment_method): ...
    def refund(self, transaction_id): ...
 
class NotificationService:
    """通知のみ"""
    def send_email(self, to, template, data): ...
    def send_push(self, device_id, message): ...

# NG: 1つの変更が多数のファイルに波及する
# 「消費税率を8%→10%に変更」で修正が必要なファイル:
#
# - cart.py (税計算)
# - invoice.py (請求書の税額)
# - receipt.py (領収書の税額)
# - report.py (レポートの税表示)
# - api.py (APIレスポンスの税額)
# - frontend/cart.js (フロントの税表示)
# → 税率がDRY化されていない証拠
# → 1箇所の変更が6ファイルに波及 = Shotgun Surgery
 
# OK: 税計算を1箇所に集約
class TaxCalculator:
    """税計算の単一責任"""
    TAX_RATE = Decimal('0.10')  # 税率は1箇所で管理
 
    @classmethod
    def calculate(cls, subtotal: Decimal) -> TaxResult:
        tax = subtotal * cls.TAX_RATE
        return TaxResult(subtotal=subtotal, tax=tax, total=subtotal + tax)
 
    @classmethod
    def get_display_rate(cls) -> str:
        return f"{cls.TAX_RATE * 100}%"
 
# 全モジュールが TaxCalculator を使用
# 税率変更時は TaxCalculator.TAX_RATE の1箇所のみ修正

# NG: 暗黙の実行順序依存
class DataProcessor:
    def __init__(self):
        self.data = None
        self.processed = None
 
    def load(self, path):
        self.data = read_file(path)
 
    def process(self):
        # load() が先に呼ばれていることを暗黙に仮定
        self.processed = transform(self.data)  # data が None だとエラー
 
    def save(self, path):
        # process() が先に呼ばれていることを暗黙に仮定
        write_file(path, self.processed)  # processed が None だとエラー
 
# 呼び出し側が正しい順序を知っている必要がある（時間的結合）
processor = DataProcessor()
processor.load("input.csv")
processor.process()
processor.save("output.csv")
 
# OK: メソッドチェーンまたは単一メソッドで順序を保証
class DataProcessor:
    @staticmethod
    def process_file(input_path: str, output_path: str) -> None:
        """ファイル処理の全手順を1メソッドで実行"""
        data = read_file(input_path)
        processed = transform(data)
        write_file(output_path, processed)
 
# または不変オブジェクトのパイプライン
class DataProcessor:
    @staticmethod
    def load(path: str) -> RawData:
        return RawData(read_file(path))
 
    @staticmethod
    def process(data: RawData) -> ProcessedData:
        return ProcessedData(transform(data.content))
 
    @staticmethod
    def save(data: ProcessedData, path: str) -> None:
        write_file(path, data.content)
 
# 型システムが順序を強制
raw = DataProcessor.load("input.csv")
processed = DataProcessor.process(raw)
DataProcessor.save(processed, "output.csv")

# 評価対象
config = {"db_host": "localhost", "db_port": 5432, "api_key": "secret"}
 
class AppService:
    def get_user(self, user_id):
        host = config["db_host"]  # グローバル変数に依存
        conn = connect(host, config["db_port"])
        return conn.query(f"SELECT * FROM users WHERE id = {user_id}")
 
    def send_report(self, email):
        import smtplib
        server = smtplib.SMTP("smtp.example.com")
        server.sendmail("noreply@example.com", email, "Report attached")
 
    def resize_image(self, image_path, width, height):
        from PIL import Image
        img = Image.open(image_path)
        return img.resize((width, height))

class CheckoutPage {
  async checkout(cartId: string) {
    const cart = await fetch(`/api/carts/${cartId}`).then(r => r.json());
    const user = await fetch(`/api/users/${cart.userId}`).then(r => r.json());
    const inventory = await fetch('/api/inventory/check', {
      method: 'POST', body: JSON.stringify(cart.items)
    }).then(r => r.json());
 
    if (!inventory.available) throw new Error('在庫不足');
 
    const tax = cart.subtotal * 0.1;
    const shipping = cart.items.length > 3 ? 0 : 500;
    const total = cart.subtotal + tax + shipping;
 
    const payment = await fetch('/api/payments/charge', {
      method: 'POST',
      body: JSON.stringify({ userId: user.id, amount: total, card: user.defaultCard })
    }).then(r => r.json());
 
    await fetch('/api/notifications/email', {
      method: 'POST',
      body: JSON.stringify({ to: user.email, template: 'order-confirm', data: { total } })
    });
 
    return { orderId: payment.orderId, total };
  }
}

// CheckoutFacade: 内部の複雑さを隠蔽
class CheckoutFacade {
  constructor(
    private cartService: CartService,
    private userService: UserService,
    private inventoryService: InventoryService,
    private pricingService: PricingService,
    private paymentService: PaymentService,
    private notificationService: NotificationService
  ) {}
 
  async checkout(cartId: string): Promise<CheckoutResult> {
    const cart = await this.cartService.getCart(cartId);
    const user = await this.userService.getUser(cart.userId);
 
    await this.inventoryService.ensureAvailable(cart.items);
 
    const pricing = this.pricingService.calculate(cart);
    const payment = await this.paymentService.charge(user, pricing.total);
 
    // 非クリティカル: 失敗しても注文は成功
    await this.notificationService
      .sendOrderConfirmation(user.email, pricing)
      .catch(err => console.warn('通知失敗', err));
 
    return { orderId: payment.orderId, total: pricing.total };
  }
}
 
// CheckoutPage は Facade だけに依存
class CheckoutPage {
  constructor(private checkout: CheckoutFacade) {}
 
  async checkout(cartId: string) {
    return this.checkout.checkout(cartId);
  }
}

class ReportManager:
    def __init__(self):
        self.sales_data = []
        self.employee_data = []
        self.inventory_data = []
 
    def add_sale(self, sale):
        self.sales_data.append(sale)
 
    def get_total_sales(self):
        return sum(s.amount for s in self.sales_data)
 
    def get_top_seller(self):
        return max(self.sales_data, key=lambda s: s.amount)
 
    def add_employee(self, employee):
        self.employee_data.append(employee)
 
    def get_average_salary(self):
        return sum(e.salary for e in self.employee_data) / len(self.employee_data)
 
    def add_inventory_item(self, item):
        self.inventory_data.append(item)
 
    def get_low_stock_items(self):
        return [i for i in self.inventory_data if i.quantity < 10]
 
    def get_inventory_value(self):
        return sum(i.price * i.quantity for i in self.inventory_data)

class SalesReport:
    """売上レポート（機能的凝集）"""
    def __init__(self):
        self.sales_data: list[Sale] = []
 
    def add_sale(self, sale: Sale) -> None:
        self.sales_data.append(sale)
 
    def get_total(self) -> float:
        return sum(s.amount for s in self.sales_data)
 
    def get_top_seller(self) -> Sale:
        return max(self.sales_data, key=lambda s: s.amount)
    # LCOM* = (3 - (1/1) * 3) / (3-1) = 0 / 2 = 0 ★完全凝集
 
class EmployeeReport:
    """従業員レポート（機能的凝集）"""
    def __init__(self):
        self.employee_data: list[Employee] = []
 
    def add_employee(self, employee: Employee) -> None:
        self.employee_data.append(employee)
 
    def get_average_salary(self) -> float:
        if not self.employee_data:
            return 0.0
        return sum(e.salary for e in self.employee_data) / len(self.employee_data)
    # LCOM* = (2 - (1/1) * 2) / (2-1) = 0 / 1 = 0 ★完全凝集
 
class InventoryReport:
    """在庫レポート（機能的凝集）"""
    def __init__(self):
        self.inventory_data: list[InventoryItem] = []
 
    def add_item(self, item: InventoryItem) -> None:
        self.inventory_data.append(item)
 
    def get_low_stock_items(self, threshold: int = 10) -> list[InventoryItem]:
        return [i for i in self.inventory_data if i.quantity < threshold]
 
    def get_total_value(self) -> float:
        return sum(i.price * i.quantity for i in self.inventory_data)
    # LCOM* = (3 - (1/1) * 3) / (3-1) = 0 / 2 = 0 ★完全凝集