import threading
 
 
class DatabaseConnection:
    """スレッドセーフな Singleton パターンの実装例。
 
    __new__ メソッドをオーバーライドし、Lock を使って
    マルチスレッド環境でも安全にインスタンスを1つに制限する。
    """
 
    _instance = None
    _lock = threading.Lock()
 
    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            with cls._lock:
                # ダブルチェックロッキング
                if cls._instance is None:
                    cls._instance = super().__new__(cls)
                    cls._instance._initialized = False
        return cls._instance
 
    def __init__(self, host: str = "localhost", port: int = 5432):
        if self._initialized:
            return
        self.host = host
        self.port = port
        self.connection = None
        self._initialized = True
 
    def connect(self) -> str:
        self.connection = f"Connected to {self.host}:{self.port}"
        return self.connection
 
    def disconnect(self) -> None:
        self.connection = None
 
 
# 使用例
db1 = DatabaseConnection("db.example.com", 5432)
db2 = DatabaseConnection("other.host.com", 3306)
 
assert db1 is db2               # 同一インスタンス
assert db1.host == "db.example.com"  # 最初の初期化値が保持される
 
db1.connect()
print(db2.connection)  # "Connected to db.example.com:5432"

# config.py — モジュール自体が Singleton
_settings: dict = {}
 
 
def load(path: str) -> None:
    """設定ファイルを読み込む。"""
    import json
    with open(path) as f:
        _settings.update(json.load(f))
 
 
def get(key: str, default=None):
    """設定値を取得する。"""
    return _settings.get(key, default)

from abc import ABC, abstractmethod
 
 
class Notification(ABC):
    """通知の基底クラス。"""
 
    @abstractmethod
    def send(self, message: str) -> str:
        """メッセージを送信する。"""
        ...
 
 
class EmailNotification(Notification):
    def __init__(self, recipient: str):
        self.recipient = recipient
 
    def send(self, message: str) -> str:
        return f"Email to {self.recipient}: {message}"
 
 
class SMSNotification(Notification):
    def __init__(self, phone_number: str):
        self.phone_number = phone_number
 
    def send(self, message: str) -> str:
        return f"SMS to {self.phone_number}: {message}"
 
 
class PushNotification(Notification):
    def __init__(self, device_token: str):
        self.device_token = device_token
 
    def send(self, message: str) -> str:
        return f"Push to {self.device_token}: {message}"
 
 
class NotificationFactory:
    """Factory Method パターンによる通知オブジェクト生成。
 
    辞書ベースのレジストリで拡張性を確保する。
    新しい通知タイプを追加するには register() を呼ぶだけでよい。
    """
 
    _creators: dict[str, type[Notification]] = {}
 
    @classmethod
    def register(cls, notification_type: str, creator: type[Notification]) -> None:
        """通知タイプを登録する。"""
        cls._creators[notification_type] = creator
 
    @classmethod
    def create(cls, notification_type: str, **kwargs) -> Notification:
        """登録済みの通知タイプからインスタンスを生成する。"""
        creator = cls._creators.get(notification_type)
        if creator is None:
            raise ValueError(
                f"Unknown notification type: {notification_type}. "
                f"Available: {list(cls._creators.keys())}"
            )
        return creator(**kwargs)
 
 
# タイプの登録
NotificationFactory.register("email", EmailNotification)
NotificationFactory.register("sms", SMSNotification)
NotificationFactory.register("push", PushNotification)
 
# 使用例
notif = NotificationFactory.create("email", recipient="user@example.com")
print(notif.send("Hello!"))  # "Email to user@example.com: Hello!"
 
notif2 = NotificationFactory.create("sms", phone_number="+81-90-1234-5678")
print(notif2.send("確認コード: 1234"))

from dataclasses import dataclass, field
 
 
@dataclass
class HttpRequest:
    """構築済みの HTTP リクエストオブジェクト。"""
    method: str = "GET"
    url: str = ""
    headers: dict[str, str] = field(default_factory=dict)
    body: str | None = None
    timeout: int = 30
    retries: int = 0
    auth_token: str | None = None
 
 
class HttpRequestBuilder:
    """Builder パターンによる HTTP リクエスト構築。
 
    メソッドチェーンで段階的にリクエストを組み立て、
    build() で最終的な HttpRequest オブジェクトを返す。
    """
 
    def __init__(self):
        self._method = "GET"
        self._url = ""
        self._headers: dict[str, str] = {}
        self._body: str | None = None
        self._timeout = 30
        self._retries = 0
        self._auth_token: str | None = None
 
    def method(self, method: str) -> "HttpRequestBuilder":
        self._method = method.upper()
        return self
 
    def url(self, url: str) -> "HttpRequestBuilder":
        self._url = url
        return self
 
    def header(self, key: str, value: str) -> "HttpRequestBuilder":
        self._headers[key] = value
        return self
 
    def body(self, body: str) -> "HttpRequestBuilder":
        self._body = body
        return self
 
    def timeout(self, seconds: int) -> "HttpRequestBuilder":
        self._timeout = seconds
        return self
 
    def retries(self, count: int) -> "HttpRequestBuilder":
        self._retries = count
        return self
 
    def auth(self, token: str) -> "HttpRequestBuilder":
        self._auth_token = token
        return self
 
    def build(self) -> HttpRequest:
        if not self._url:
            raise ValueError("URL is required")
        if self._auth_token:
            self._headers["Authorization"] = f"Bearer {self._auth_token}"
        return HttpRequest(
            method=self._method,
            url=self._url,
            headers=self._headers,
            body=self._body,
            timeout=self._timeout,
            retries=self._retries,
            auth_token=self._auth_token,
        )
 
 
# 使用例: メソッドチェーンで読みやすく構築
request = (
    HttpRequestBuilder()
    .method("POST")
    .url("https://api.example.com/users")
    .header("Content-Type", "application/json")
    .body('{"name": "Alice", "age": 30}')
    .auth("my-secret-token")
    .timeout(10)
    .retries(3)
    .build()
)
 
print(request.method)   # "POST"
print(request.url)      # "https://api.example.com/users"
print(request.headers)  # {"Content-Type": "application/json", "Authorization": "Bearer my-secret-token"}
print(request.retries)  # 3
 
 
# 比較: Builder を使わない場合（可読性が低い）
# request = HttpRequest("POST", "https://api.example.com/users",
#     {"Content-Type": "application/json", "Authorization": "Bearer my-secret-token"},
#     '{"name": "Alice", "age": 30}', 10, 3, "my-secret-token")

import copy
from dataclasses import dataclass, field
 
 
@dataclass
class GameCharacter:
    """ゲームキャラクターのプロトタイプ。"""
    name: str
    hp: int
    attack: int
    defense: int
    skills: list[str] = field(default_factory=list)
    position: dict[str, int] = field(default_factory=lambda: {"x": 0, "y": 0})
 
    def clone(self) -> "GameCharacter":
        """ディープコピーで完全な複製を作成する。"""
        return copy.deepcopy(self)
 
 
# テンプレートの作成
goblin_template = GameCharacter(
    name="Goblin",
    hp=50,
    attack=10,
    defense=5,
    skills=["slash", "dodge"],
)
 
# プロトタイプからクローンを生成
goblin1 = goblin_template.clone()
goblin1.name = "Goblin A"
goblin1.position = {"x": 10, "y": 20}
 
goblin2 = goblin_template.clone()
goblin2.name = "Goblin B"
goblin2.position = {"x": 30, "y": 40}
goblin2.skills.append("poison")  # テンプレートには影響しない
 
print(goblin_template.skills)  # ["slash", "dodge"]
print(goblin2.skills)          # ["slash", "dodge", "poison"]

from abc import ABC, abstractmethod
import json
from xml.etree import ElementTree as ET
 
 
class ModernAPI(ABC):
    """新しいシステムが期待する JSON インターフェース。"""
 
    @abstractmethod
    def get_data(self) -> dict:
        ...
 
 
class LegacyXMLService:
    """レガシーシステム: XML でデータを返す。"""
 
    def fetch_xml(self) -> str:
        return """
        <users>
            <user>
                <name>Alice</name>
                <age>30</age>
            </user>
            <user>
                <name>Bob</name>
                <age>25</age>
            </user>
        </users>
        """
 
 
class XMLToJSONAdapter(ModernAPI):
    """Adapter: XML を返すレガシーサービスを JSON インターフェースに適合させる。
 
    Adaptee（LegacyXMLService）を内部に保持し、
    クライアントが期待する ModernAPI インターフェースを実装する。
    """
 
    def __init__(self, legacy_service: LegacyXMLService):
        self._legacy = legacy_service
 
    def get_data(self) -> dict:
        xml_str = self._legacy.fetch_xml()
        root = ET.fromstring(xml_str)
        users = []
        for user_elem in root.findall("user"):
            users.append({
                "name": user_elem.findtext("name", ""),
                "age": int(user_elem.findtext("age", "0")),
            })
        return {"users": users, "count": len(users)}
 
 
# 使用例
legacy = LegacyXMLService()
adapter = XMLToJSONAdapter(legacy)
data = adapter.get_data()
print(json.dumps(data, indent=2))
# {
#   "users": [
#     {"name": "Alice", "age": 30},
#     {"name": "Bob", "age": 25}
#   ],
#   "count": 2
# }

from abc import ABC, abstractmethod
 
 
class Beverage(ABC):
    """飲み物の基底クラス。"""
 
    @abstractmethod
    def cost(self) -> float:
        ...
 
    @abstractmethod
    def description(self) -> str:
        ...
 
 
class Coffee(Beverage):
    """ベースとなるコーヒー。"""
 
    def cost(self) -> float:
        return 300.0
 
    def description(self) -> str:
        return "Coffee"
 
 
class Espresso(Beverage):
    """ベースとなるエスプレッソ。"""
 
    def cost(self) -> float:
        return 350.0
 
    def description(self) -> str:
        return "Espresso"
 
 
class BeverageDecorator(Beverage):
    """Decorator の基底クラス。内部に Beverage を保持する。"""
 
    def __init__(self, beverage: Beverage):
        self._beverage = beverage
 
 
class MilkDecorator(BeverageDecorator):
    def cost(self) -> float:
        return self._beverage.cost() + 50.0
 
    def description(self) -> str:
        return self._beverage.description() + " + Milk"
 
 
class SugarDecorator(BeverageDecorator):
    def cost(self) -> float:
        return self._beverage.cost() + 30.0
 
    def description(self) -> str:
        return self._beverage.description() + " + Sugar"
 
 
class WhippedCreamDecorator(BeverageDecorator):
    def cost(self) -> float:
        return self._beverage.cost() + 80.0
 
    def description(self) -> str:
        return self._beverage.description() + " + Whipped Cream"
 
 
# 使用例: Decorator を自由に組み合わせる
order = Coffee()
order = MilkDecorator(order)
order = SugarDecorator(order)
order = WhippedCreamDecorator(order)
 
print(order.description())  # "Coffee + Milk + Sugar + Whipped Cream"
print(f"合計: {order.cost()}円")  # "合計: 460.0円"
 
# Python のデコレータ構文 (@decorator) との関係:
# Python の @decorator は関数/クラスのラッピング機能であり、
# GoF の Decorator パターンとは概念的に類似するが別物である。
# ただし、@decorator を使って GoF の Decorator パターンを実装することもできる。

def logging_decorator(func):
    """関数呼び出しのログを自動追加する Python デコレータ。"""
    def wrapper(*args, **kwargs):
        print(f"[LOG] Calling {func.__name__} with args={args}, kwargs={kwargs}")
        result = func(*args, **kwargs)
        print(f"[LOG] {func.__name__} returned {result}")
        return result
    return wrapper
 
 
def retry_decorator(max_retries: int = 3):
    """リトライ機能を追加する Python デコレータ。"""
    def decorator(func):
        def wrapper(*args, **kwargs):
            for attempt in range(max_retries):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if attempt == max_retries - 1:
                        raise
                    print(f"[RETRY] Attempt {attempt + 1} failed: {e}")
        return wrapper
    return decorator
 
 
@logging_decorator
@retry_decorator(max_retries=3)
def fetch_data(url: str) -> str:
    return f"Data from {url}"

class InventoryService:
    """在庫管理サブシステム。"""
 
    def check_stock(self, product_id: str) -> bool:
        print(f"[Inventory] Checking stock for {product_id}")
        return True  # 在庫あり
 
    def reserve(self, product_id: str, qty: int) -> str:
        print(f"[Inventory] Reserved {qty} units of {product_id}")
        return f"RESERVE-{product_id}-{qty}"
 
 
class PaymentService:
    """決済サブシステム。"""
 
    def authorize(self, amount: float, card_token: str) -> str:
        print(f"[Payment] Authorized {amount} yen with card {card_token[:4]}****")
        return "AUTH-12345"
 
    def capture(self, auth_id: str) -> bool:
        print(f"[Payment] Captured payment {auth_id}")
        return True
 
 
class ShippingService:
    """配送サブシステム。"""
 
    def calculate_cost(self, address: str) -> float:
        print(f"[Shipping] Calculating cost to {address}")
        return 500.0
 
    def create_shipment(self, product_id: str, address: str) -> str:
        print(f"[Shipping] Created shipment for {product_id} to {address}")
        return "SHIP-67890"
 
 
class NotificationService:
    """通知サブシステム。"""
 
    def send_confirmation(self, email: str, order_id: str) -> None:
        print(f"[Notification] Sent confirmation for {order_id} to {email}")
 
 
class OrderFacade:
    """Facade: 注文処理の複雑さを隠蔽する統一インターフェース。
 
    クライアントは place_order() を呼ぶだけでよい。
    内部では 4 つのサブシステムが協調して動作する。
    """
 
    def __init__(self):
        self._inventory = InventoryService()
        self._payment = PaymentService()
        self._shipping = ShippingService()
        self._notification = NotificationService()
 
    def place_order(
        self,
        product_id: str,
        qty: int,
        card_token: str,
        address: str,
        email: str,
    ) -> dict:
        # Step 1: 在庫確認
        if not self._inventory.check_stock(product_id):
            raise RuntimeError(f"Product {product_id} is out of stock")
 
        # Step 2: 在庫予約
        reservation = self._inventory.reserve(product_id, qty)
 
        # Step 3: 配送料計算
        shipping_cost = self._shipping.calculate_cost(address)
 
        # Step 4: 決済
        total = qty * 1000 + shipping_cost  # 仮の単価 1000 円
        auth_id = self._payment.authorize(total, card_token)
        self._payment.capture(auth_id)
 
        # Step 5: 配送手配
        shipment_id = self._shipping.create_shipment(product_id, address)
 
        # Step 6: 確認メール送信
        order_id = f"ORDER-{reservation}-{shipment_id}"
        self._notification.send_confirmation(email, order_id)
 
        return {
            "order_id": order_id,
            "total": total,
            "shipment_id": shipment_id,
        }
 
 
# 使用例: クライアントは Facade だけを知ればよい
facade = OrderFacade()
result = facade.place_order(
    product_id="ITEM-001",
    qty=2,
    card_token="tok_visa_4242424242424242",
    address="東京都渋谷区...",
    email="customer@example.com",
)
print(f"注文完了: {result['order_id']}")

from abc import ABC, abstractmethod
 
 
class FileSystemNode(ABC):
    """ファイルシステムのノード（Component）。"""
 
    def __init__(self, name: str):
        self.name = name
 
    @abstractmethod
    def size(self) -> int:
        """サイズをバイト単位で返す。"""
        ...
 
    @abstractmethod
    def display(self, indent: int = 0) -> str:
        """ツリー表示用の文字列を返す。"""
        ...
 
 
class File(FileSystemNode):
    """ファイル（Leaf）。"""
 
    def __init__(self, name: str, size_bytes: int):
        super().__init__(name)
        self._size = size_bytes
 
    def size(self) -> int:
        return self._size
 
    def display(self, indent: int = 0) -> str:
        return " " * indent + f"[File] {self.name} ({self._size} bytes)"
 
 
class Directory(FileSystemNode):
    """ディレクトリ（Composite）。子要素を持つ。"""
 
    def __init__(self, name: str):
        super().__init__(name)
        self._children: list[FileSystemNode] = []
 
    def add(self, node: FileSystemNode) -> None:
        self._children.append(node)
 
    def remove(self, node: FileSystemNode) -> None:
        self._children.remove(node)
 
    def size(self) -> int:
        return sum(child.size() for child in self._children)
 
    def display(self, indent: int = 0) -> str:
        lines = [" " * indent + f"[Dir] {self.name} ({self.size()} bytes)"]
        for child in self._children:
            lines.append(child.display(indent + 2))
        return "\n".join(lines)
 
 
# 使用例
root = Directory("project")
src = Directory("src")
src.add(File("main.py", 2048))
src.add(File("utils.py", 1024))
 
tests = Directory("tests")
tests.add(File("test_main.py", 512))
 
root.add(src)
root.add(tests)
root.add(File("README.md", 256))
 
print(root.display())
# [Dir] project (3840 bytes)
#   [Dir] src (3072 bytes)
#     [File] main.py (2048 bytes)
#     [File] utils.py (1024 bytes)
#   [Dir] tests (512 bytes)
#     [File] test_main.py (512 bytes)
#   [File] README.md (256 bytes)
 
print(f"Total size: {root.size()} bytes")  # 3840

from abc import ABC, abstractmethod
from dataclasses import dataclass
from typing import Any
 
 
class Observer(ABC):
    """Observer インターフェース。"""
 
    @abstractmethod
    def update(self, event: str, data: Any) -> None:
        ...
 
 
class EventEmitter:
    """汎用的な Observable（Subject）の実装。
 
    イベント名ごとに Observer を管理し、
    特定のイベントが発生したときに該当する Observer のみに通知する。
    """
 
    def __init__(self):
        self._observers: dict[str, list[Observer]] = {}
 
    def on(self, event: str, observer: Observer) -> None:
        """イベントに Observer を登録する。"""
        self._observers.setdefault(event, []).append(observer)
 
    def off(self, event: str, observer: Observer) -> None:
        """イベントから Observer を解除する。"""
        if event in self._observers:
            self._observers[event].remove(observer)
 
    def emit(self, event: str, data: Any = None) -> None:
        """イベントを発火し、登録済みの全 Observer に通知する。"""
        for observer in self._observers.get(event, []):
            observer.update(event, data)
 
 
@dataclass
class StockPrice:
    symbol: str
    price: float
    change: float
 
 
class ChartObserver(Observer):
    """チャート表示の更新。"""
 
    def update(self, event: str, data: Any) -> None:
        if isinstance(data, StockPrice):
            direction = "▲" if data.change > 0 else "▼"
            print(f"[Chart] {data.symbol}: {data.price:.2f} {direction}")
 
 
class AlertObserver(Observer):
    """価格アラートの通知。"""
 
    def __init__(self, threshold: float):
        self.threshold = threshold
 
    def update(self, event: str, data: Any) -> None:
        if isinstance(data, StockPrice) and abs(data.change) > self.threshold:
            print(f"[ALERT] {data.symbol} moved {data.change:+.2f}% !")
 
 
class LogObserver(Observer):
    """取引ログの記録。"""
 
    def __init__(self):
        self.log: list[str] = []
 
    def update(self, event: str, data: Any) -> None:
        if isinstance(data, StockPrice):
            entry = f"{data.symbol},{data.price},{data.change}"
            self.log.append(entry)
            print(f"[Log] Recorded: {entry}")
 
 
# 使用例
stock_feed = EventEmitter()
 
chart = ChartObserver()
alert = AlertObserver(threshold=2.0)
logger = LogObserver()
 
stock_feed.on("price_update", chart)
stock_feed.on("price_update", alert)
stock_feed.on("price_update", logger)
 
# 株価更新をシミュレーション
stock_feed.emit("price_update", StockPrice("AAPL", 178.50, +1.2))
# [Chart] AAPL: 178.50 ▲
# [Log] Recorded: AAPL,178.5,1.2
 
stock_feed.emit("price_update", StockPrice("GOOG", 141.80, -3.5))
# [Chart] GOOG: 141.80 ▼
# [ALERT] GOOG moved -3.50% !
# [Log] Recorded: GOOG,141.8,-3.5

from abc import ABC, abstractmethod
from dataclasses import dataclass
 
 
class DiscountStrategy(ABC):
    """割引戦略の基底クラス。"""
 
    @abstractmethod
    def calculate(self, price: float) -> float:
        """割引後の価格を返す。"""
        ...
 
    @abstractmethod
    def description(self) -> str:
        """戦略の説明を返す。"""
        ...
 
 
class NoDiscount(DiscountStrategy):
    def calculate(self, price: float) -> float:
        return price
 
    def description(self) -> str:
        return "割引なし"
 
 
class PercentageDiscount(DiscountStrategy):
    def __init__(self, percentage: float):
        self._percentage = percentage
 
    def calculate(self, price: float) -> float:
        return price * (1 - self._percentage / 100)
 
    def description(self) -> str:
        return f"{self._percentage}% OFF"
 
 
class FixedAmountDiscount(DiscountStrategy):
    def __init__(self, amount: float):
        self._amount = amount
 
    def calculate(self, price: float) -> float:
        return max(0, price - self._amount)
 
    def description(self) -> str:
        return f"{self._amount}円引き"
 
 
class BuyNGetFreeDiscount(DiscountStrategy):
    """N 個買うと 1 個無料。"""
 
    def __init__(self, buy_count: int):
        self._buy = buy_count
 
    def calculate(self, price: float) -> float:
        return price * self._buy / (self._buy + 1)
 
    def description(self) -> str:
        return f"{self._buy} 個買うと 1 個無料"
 
 
@dataclass
class ShoppingCart:
    """Strategy パターンで割引戦略を切り替え可能なカート。"""
 
    items: list[tuple[str, float]]
    strategy: DiscountStrategy
 
    def set_strategy(self, strategy: DiscountStrategy) -> None:
        """割引戦略を動的に変更する。"""
        self.strategy = strategy
 
    def subtotal(self) -> float:
        return sum(price for _, price in self.items)
 
    def total(self) -> float:
        return self.strategy.calculate(self.subtotal())
 
    def receipt(self) -> str:
        lines = ["--- レシート ---"]
        for name, price in self.items:
            lines.append(f"  {name}: {price:.0f}円")
        lines.append(f"  小計: {self.subtotal():.0f}円")
        lines.append(f"  {self.strategy.description()}")
        lines.append(f"  合計: {self.total():.0f}円")
        return "\n".join(lines)
 
 
# 使用例
cart = ShoppingCart(
    items=[("Python入門書", 3000), ("ノート", 500), ("ペン", 200)],
    strategy=NoDiscount(),
)
print(cart.receipt())
# 合計: 3700円
 
cart.set_strategy(PercentageDiscount(20))
print(cart.receipt())
# 20% OFF → 合計: 2960円
 
cart.set_strategy(FixedAmountDiscount(500))
print(cart.receipt())
# 500円引き → 合計: 3200円

from typing import Callable
 
# 関数型 Strategy
DiscountFunc = Callable[[float], float]
 
def no_discount(price: float) -> float:
    return price
 
def percentage_off(pct: float) -> DiscountFunc:
    return lambda price: price * (1 - pct / 100)
 
def fixed_off(amount: float) -> DiscountFunc:
    return lambda price: max(0, price - amount)
 
# 使用例
apply_discount: DiscountFunc = percentage_off(15)
print(apply_discount(1000))  # 850.0

from abc import ABC, abstractmethod
from dataclasses import dataclass, field
 
 
class Command(ABC):
    """コマンドの基底クラス。"""
 
    @abstractmethod
    def execute(self) -> None:
        ...
 
    @abstractmethod
    def undo(self) -> None:
        ...
 
    @abstractmethod
    def description(self) -> str:
        ...
 
 
class TextEditor:
    """テキストエディタの本体（Receiver）。"""
 
    def __init__(self):
        self.content: str = ""
        self.cursor: int = 0
 
    def insert(self, text: str, position: int) -> None:
        self.content = self.content[:position] + text + self.content[position:]
        self.cursor = position + len(text)
 
    def delete(self, position: int, length: int) -> str:
        deleted = self.content[position:position + length]
        self.content = self.content[:position] + self.content[position + length:]
        self.cursor = position
        return deleted
 
    def __repr__(self) -> str:
        return f'TextEditor("{self.content}")'
 
 
class InsertCommand(Command):
    def __init__(self, editor: TextEditor, text: str, position: int):
        self._editor = editor
        self._text = text
        self._position = position
 
    def execute(self) -> None:
        self._editor.insert(self._text, self._position)
 
    def undo(self) -> None:
        self._editor.delete(self._position, len(self._text))
 
    def description(self) -> str:
        return f'Insert "{self._text}" at {self._position}'
 
 
class DeleteCommand(Command):
    def __init__(self, editor: TextEditor, position: int, length: int):
        self._editor = editor
        self._position = position
        self._length = length
        self._deleted_text: str = ""
 
    def execute(self) -> None:
        self._deleted_text = self._editor.delete(self._position, self._length)
 
    def undo(self) -> None:
        self._editor.insert(self._deleted_text, self._position)
 
    def description(self) -> str:
        return f'Delete {self._length} chars at {self._position}'
 
 
class CommandHistory:
    """Undo/Redo を管理する Invoker。"""
 
    def __init__(self):
        self._undo_stack: list[Command] = []
        self._redo_stack: list[Command] = []
 
    def execute(self, command: Command) -> None:
        command.execute()
        self._undo_stack.append(command)
        self._redo_stack.clear()  # 新しい操作後は redo 履歴をクリア
 
    def undo(self) -> None:
        if not self._undo_stack:
            print("Nothing to undo")
            return
        command = self._undo_stack.pop()
        command.undo()
        self._redo_stack.append(command)
        print(f"Undo: {command.description()}")
 
    def redo(self) -> None:
        if not self._redo_stack:
            print("Nothing to redo")
            return
        command = self._redo_stack.pop()
        command.execute()
        self._undo_stack.append(command)
        print(f"Redo: {command.description()}")
 
 
# 使用例
editor = TextEditor()
history = CommandHistory()
 
history.execute(InsertCommand(editor, "Hello", 0))
print(editor)  # TextEditor("Hello")
 
history.execute(InsertCommand(editor, " World", 5))
print(editor)  # TextEditor("Hello World")
 
history.execute(DeleteCommand(editor, 5, 6))
print(editor)  # TextEditor("Hello")
 
history.undo()  # Undo: Delete 6 chars at 5
print(editor)  # TextEditor("Hello World")
 
history.undo()  # Undo: Insert " World" at 5
print(editor)  # TextEditor("Hello")
 
history.redo()  # Redo: Insert " World" at 5
print(editor)  # TextEditor("Hello World")

from collections import deque
from typing import Iterator, Generic, TypeVar
 
T = TypeVar("T")
 
 
class BinaryTreeNode(Generic[T]):
    """二分木のノード。"""
 
    def __init__(self, value: T):
        self.value = value
        self.left: "BinaryTreeNode[T] | None" = None
        self.right: "BinaryTreeNode[T] | None" = None
 
 
class InOrderIterator:
    """中順走査（左 → 根 → 右）の Iterator。"""
 
    def __init__(self, root: BinaryTreeNode | None):
        self._stack: list[BinaryTreeNode] = []
        self._push_left(root)
 
    def _push_left(self, node: BinaryTreeNode | None) -> None:
        while node:
            self._stack.append(node)
            node = node.left
 
    def __iter__(self):
        return self
 
    def __next__(self):
        if not self._stack:
            raise StopIteration
        node = self._stack.pop()
        self._push_left(node.right)
        return node.value
 
 
class BreadthFirstIterator:
    """幅優先走査の Iterator。"""
 
    def __init__(self, root: BinaryTreeNode | None):
        self._queue: deque[BinaryTreeNode] = deque()
        if root:
            self._queue.append(root)
 
    def __iter__(self):
        return self
 
    def __next__(self):
        if not self._queue:
            raise StopIteration
        node = self._queue.popleft()
        if node.left:
            self._queue.append(node.left)
        if node.right:
            self._queue.append(node.right)
        return node.value
 
 
class BinaryTree(Generic[T]):
    """複数の走査方法を提供する二分木。"""
 
    def __init__(self, root: BinaryTreeNode[T] | None = None):
        self.root = root
 
    def in_order(self) -> InOrderIterator:
        return InOrderIterator(self.root)
 
    def breadth_first(self) -> BreadthFirstIterator:
        return BreadthFirstIterator(self.root)
 
    def __iter__(self):
        return self.in_order()
 
 
# 使用例: ツリーの構築
#       4
#      / \
#     2   6
#    / \ / \
#   1  3 5  7
root = BinaryTreeNode(4)
root.left = BinaryTreeNode(2)
root.right = BinaryTreeNode(6)
root.left.left = BinaryTreeNode(1)
root.left.right = BinaryTreeNode(3)
root.right.left = BinaryTreeNode(5)
root.right.right = BinaryTreeNode(7)
 
tree = BinaryTree(root)
 
print("In-order:", list(tree.in_order()))
# In-order: [1, 2, 3, 4, 5, 6, 7]
 
print("BFS:", list(tree.breadth_first()))
# BFS: [4, 2, 6, 1, 3, 5, 7]
 
# for ループでも使える（__iter__ が in_order を返す）
for value in tree:
    print(value, end=" ")
# 1 2 3 4 5 6 7

from abc import ABC, abstractmethod
from dataclasses import dataclass, field
from typing import TypeVar, Generic
 
T = TypeVar("T")
 
 
@dataclass
class User:
    id: int
    name: str
    email: str
 
 
class UserRepository(ABC):
    """ユーザーリポジトリのインターフェース。"""
 
    @abstractmethod
    def find_by_id(self, user_id: int) -> User | None:
        ...
 
    @abstractmethod
    def find_by_email(self, email: str) -> User | None:
        ...
 
    @abstractmethod
    def find_all(self) -> list[User]:
        ...
 
    @abstractmethod
    def save(self, user: User) -> None:
        ...
 
    @abstractmethod
    def delete(self, user_id: int) -> None:
        ...
 
 
class InMemoryUserRepository(UserRepository):
    """テスト用のインメモリ実装。"""
 
    def __init__(self):
        self._store: dict[int, User] = {}
 
    def find_by_id(self, user_id: int) -> User | None:
        return self._store.get(user_id)
 
    def find_by_email(self, email: str) -> User | None:
        for user in self._store.values():
            if user.email == email:
                return user
        return None
 
    def find_all(self) -> list[User]:
        return list(self._store.values())
 
    def save(self, user: User) -> None:
        self._store[user.id] = user
 
    def delete(self, user_id: int) -> None:
        self._store.pop(user_id, None)
 
 
class UserService:
    """ビジネスロジック層。Repository に依存する。"""
 
    def __init__(self, repo: UserRepository):
        self._repo = repo
 
    def register(self, user_id: int, name: str, email: str) -> User:
        existing = self._repo.find_by_email(email)
        if existing:
            raise ValueError(f"Email {email} is already registered")
        user = User(id=user_id, name=name, email=email)
        self._repo.save(user)
        return user
 
    def get_user(self, user_id: int) -> User:
        user = self._repo.find_by_id(user_id)
        if not user:
            raise ValueError(f"User {user_id} not found")
        return user
 
 
# 使用例
repo = InMemoryUserRepository()
service = UserService(repo)
 
alice = service.register(1, "Alice", "alice@example.com")
bob = service.register(2, "Bob", "bob@example.com")
 
print(service.get_user(1))   # User(id=1, name='Alice', email='alice@example.com')
print(repo.find_all())       # [User(...), User(...)]
 
# テスト時は InMemoryUserRepository を使い、
# 本番では SQLAlchemyUserRepository 等に差し替える

# アンチパターン: God Object
class Application:
    """何でもやるクラス（やってはいけない例）。"""
 
    def __init__(self):
        self.users = []
        self.products = []
        self.orders = []
        self.db_connection = None
        self.email_client = None
        self.cache = {}
        self.log_file = None
 
    def connect_to_database(self): ...
    def close_database(self): ...
    def create_user(self, name, email): ...
    def delete_user(self, user_id): ...
    def authenticate_user(self, email, password): ...
    def add_product(self, name, price): ...
    def update_product(self, product_id, **kwargs): ...
    def search_products(self, query): ...
    def create_order(self, user_id, items): ...
    def calculate_shipping(self, address): ...
    def process_payment(self, order_id, card): ...
    def send_confirmation_email(self, user_id, order_id): ...
    def generate_report(self, report_type): ...
    def export_to_csv(self, data): ...
    def clear_cache(self): ...
    def write_log(self, message): ...
    # ... 延々と続く

# 改善: 責務ごとにクラスを分割
class UserService:
    """ユーザー管理に特化。"""
    def create(self, name: str, email: str) -> "User": ...
    def authenticate(self, email: str, password: str) -> bool: ...
 
class ProductService:
    """商品管理に特化。"""
    def add(self, name: str, price: float) -> "Product": ...
    def search(self, query: str) -> list["Product"]: ...
 
class OrderService:
    """注文管理に特化。"""
    def create(self, user_id: int, items: list) -> "Order": ...
    def process_payment(self, order_id: int, card: str) -> bool: ...
 
class NotificationService:
    """通知に特化。"""
    def send_confirmation(self, user_id: int, order_id: int) -> None: ...

# Golden Hammer の例: 不要な Factory
# 生成するクラスが 1 種類なら Factory は不要
 
# 過剰設計（やりすぎ）
class LoggerFactory:
    @staticmethod
    def create(logger_type: str):
        if logger_type == "console":
            return ConsoleLogger()
        raise ValueError(f"Unknown: {logger_type}")
 
logger = LoggerFactory.create("console")  # 常に console しか使わない
 
# 適切（シンプル）
logger = ConsoleLogger()  # 直接生成で十分