# 概念的な例：注意機構の重要性
# "The bank of the river" vs "The bank account"
# "bank"の意味は文脈によって変わる

# AIコード生成での実例
def process_data(data):
    # AIは関数名とパラメータ名から文脈を推測
    # "process_data"という名前から、データ処理の
    # 一般的なパターンを適用しようとする
    if not data:
        return None  # よくあるパターン
    
    # しかし、具体的な処理内容は文脈依存
    # ここでAIの推測が外れる可能性がある

# 温度パラメータの影響
# 低温度（0.1）: 最も確率の高い選択 → 保守的、予測可能
# 高温度（1.0）: より多様な選択 → 創造的、予測困難

# テストへの影響
# - 再現性の課題
# - 網羅的テストの困難さ
# - 品質のばらつき

# プロンプト: "ユーザーの年齢を検証する関数"
def validate_age(age):
    # AIの暗黙の前提：年齢は0-150の範囲
    if not isinstance(age, int):
        return False
    if age < 0 or age > 150:  # この上限は暗黙の前提
        return False
    return True

# しかし、システムによっては異なる要件があるかもしれない
# 例：未来の生年月日を許可するシステム
# 例：歴史的データを扱うシステム（150歳以上）

# 危険な例：ユーザー入力をそのままプロンプトに含める
user_request = "'; DROP TABLE users; --"
prompt = f"Create a SQL query to {user_request}"

# AIが生成する可能性のあるコード
query = f"SELECT * FROM data WHERE condition = '{user_request}'"
# SQLインジェクションの脆弱性

# よく見られる低品質パターン
def get_user_data(user_id):
    # エラーハンドリングなし
    data = database.query(f"SELECT * FROM users WHERE id = {user_id}")
    return data[0]  # インデックスエラーの可能性

# 本番環境に適したパターン
def get_user_data(user_id):
    """ユーザーデータを安全に取得する"""
    if not isinstance(user_id, int) or user_id <= 0:
        raise ValueError(f"Invalid user_id: {user_id}")
    
    try:
        # パラメータ化クエリでSQLインジェクション対策
        data = database.query(
            "SELECT * FROM users WHERE id = %s",
            (user_id,)
        )
        
        if not data:
            raise UserNotFoundException(f"User {user_id} not found")
            
        return data[0]
    except DatabaseException as e:
        logger.error(f"Database error for user {user_id}: {e}")
        raise ServiceException("Failed to retrieve user data")

# AIが得意とする典型的パターン

# 1. CRUD操作
class UserRepository:
    def __init__(self, db_connection):
        self.db = db_connection
    
    def create(self, user_data):
        # AIは標準的なCREATEパターンを認識
        query = """
            INSERT INTO users (name, email, created_at)
            VALUES (%s, %s, %s)
            RETURNING id
        """
        return self.db.execute(query, (
            user_data['name'],
            user_data['email'],
            datetime.now()
        ))
    
    # READ, UPDATE, DELETEも同様に生成可能

# 2. 一般的なアルゴリズム
def binary_search(arr, target):
    # AIは教科書的な実装を正確に再現
    left, right = 0, len(arr) - 1
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1

# AIが苦手とする例：ビジネスロジック

# プロンプト：「在庫管理システムの予約処理を実装」
def reserve_inventory(product_id, quantity):
    # AIの典型的な実装（過度に単純化）
    product = get_product(product_id)
    if product.stock >= quantity:
        product.stock -= quantity
        save_product(product)
        return True
    return False

# 実際に必要な考慮事項（AIが見逃しがち）
def reserve_inventory_complete(product_id, quantity, customer_tier, timestamp):
    """実際のビジネスロジックを含む在庫予約"""
    with transaction() as tx:
        product = get_product_for_update(product_id)  # 行ロック
        
        # 優先顧客の在庫確保分を考慮
        available = product.stock - product.reserved_for_vip
        if customer_tier != 'VIP' and available < quantity:
            return ReservationResult.INSUFFICIENT_STOCK
        
        # 予約期限の管理
        expiry = timestamp + timedelta(hours=2)
        
        # 在庫タイプ別の処理
        if product.type == 'PERISHABLE':
            # 期限切れ間近の在庫から割り当て
            allocated = allocate_by_expiry(product, quantity)
        else:
            # FIFO/LIFOなどの在庫割当戦略
            allocated = allocate_by_strategy(product, quantity)
        
        # 予約レコードの作成
        reservation = create_reservation(
            product_id, quantity, customer_tier, expiry, allocated
        )
        
        # イベント発行（他システムへの通知）
        publish_event('inventory.reserved', reservation)
        
        return ReservationResult.SUCCESS

# AIが生成する「創造的」なコード
class SmartCache:
    """LRUとTTLを組み合わせたキャッシュ実装"""
    def __init__(self, max_size=100, default_ttl=3600):
        # 既存のパターン1: LRUキャッシュ
        self.cache = OrderedDict()
        self.max_size = max_size
        
        # 既存のパターン2: TTL管理
        self.timestamps = {}
        self.default_ttl = default_ttl
    
    # パターンの組み合わせ
    def get(self, key):
        if key in self.cache:
            # TTLチェック（パターン2）
            if time.time() - self.timestamps[key] > self.default_ttl:
                del self.cache[key]
                del self.timestamps[key]
                return None
            
            # LRU更新（パターン1）
            self.cache.move_to_end(key)
            return self.cache[key]
        return None

# ローカルコンテキスト（AIが理解しやすい）
def calculate_discount(price, discount_rate):
    """価格と割引率から割引額を計算"""
    # 関数シグネチャから目的が明確
    return price * discount_rate

# グローバルコンテキスト（AIが理解しにくい）
def calculate_discount(price, discount_rate):
    """価格と割引率から割引額を計算"""
    # AIが知らない暗黙のビジネスルール：
    # - 会員ランクによる割引上限
    # - 商品カテゴリ別の割引制限
    # - キャンペーン期間の考慮
    # - 他の割引との併用不可ルール
    
    # これらの文脈はコードからは読み取れない

# AIが生成しがちなコード
class OrderService:
    def process_order(self, order_data):
        # 在庫確認
        if not self.check_inventory(order_data['items']):
            return False
        
        # 支払い処理
        payment_result = self.process_payment(order_data['payment'])
        
        # 注文確定
        if payment_result:
            self.finalize_order(order_data)
            return True
        return False

# 見落とされがちな依存関係と副作用
class OrderServiceComplete:
    def process_order(self, order_data):
        # トランザクション境界の考慮
        with distributed_transaction() as tx:
            # 在庫の悲観的ロック
            locked_items = self.lock_inventory(order_data['items'])
            
            try:
                # 価格の再計算（リアルタイム価格変動対応）
                current_price = self.calculate_current_price(locked_items)
                if current_price != order_data['expected_price']:
                    raise PriceMismatchException()
                
                # 与信枠の確認（B2B取引の場合）
                if order_data['payment']['type'] == 'credit':
                    self.check_credit_limit(order_data['customer_id'])
                
                # 配送可能性の確認
                if not self.validate_shipping(order_data['shipping']):
                    raise ShippingException()
                
                # 支払い処理（冪等性の保証）
                payment_result = self.process_payment_idempotent(
                    order_data['payment'],
                    order_data['idempotency_key']
                )
                
                # 外部サービスへの通知（非同期）
                self.notify_external_services(order_data)
                
                # 監査ログの記録
                self.audit_log.record(order_data, payment_result)
                
                return self.finalize_order(order_data)
                
            except Exception as e:
                # 補償トランザクション
                self.compensate(order_data, locked_items)
                raise

# AIが見逃しがちな時間的側面

# 単純な実装
def get_user_status(user_id):
    user = get_user(user_id)
    return user.status

# 時間的文脈を考慮した実装
def get_user_status(user_id, as_of_date=None):
    """特定時点でのユーザーステータスを取得"""
    if as_of_date is None:
        as_of_date = datetime.now()
    
    # ステータス履歴から該当時点のステータスを取得
    status_history = get_status_history(user_id)
    
    # 二分探索で効率的に検索
    left, right = 0, len(status_history) - 1
    result = None
    
    while left <= right:
        mid = (left + right) // 2
        if status_history[mid].effective_date <= as_of_date:
            result = status_history[mid]
            left = mid + 1
        else:
            right = mid - 1
    
    if result is None:
        raise NoStatusFoundException(
            f"No status found for user {user_id} as of {as_of_date}"
        )
    
    # 有効期限の確認
    if result.expiry_date and result.expiry_date < as_of_date:
        return 'EXPIRED'
    
    return result.status

# AIが生成する標準的なコード
class UserController:
    """RESTful APIの標準的な実装"""
    
    def get(self, user_id):
        try:
            user = User.query.get(user_id)
            if not user:
                return {"error": "User not found"}, 404
            return user.to_dict(), 200
        except Exception as e:
            logger.error(f"Error getting user {user_id}: {e}")
            return {"error": "Internal server error"}, 500
    
    def post(self, user_data):
        try:
            # 標準的なバリデーション
            if not self.validate_user_data(user_data):
                return {"error": "Invalid data"}, 400
            
            user = User(**user_data)
            db.session.add(user)
            db.session.commit()
            
            return user.to_dict(), 201
        except IntegrityError:
            return {"error": "User already exists"}, 409
        except Exception as e:
            logger.error(f"Error creating user: {e}")
            return {"error": "Internal server error"}, 500

# より効率的だが、AIが生成しにくいコード
class OptimizedUserController:
    """パフォーマンスを最適化したAPI実装"""
    
    def __init__(self):
        # 接続プーリング
        self.db_pool = create_connection_pool(
            min_connections=10,
            max_connections=100
        )
        
        # キャッシュ戦略
        self.cache = RedisCache(
            serializer=msgpack,  # JSONより高速
            compression=True
        )
        
        # バッチ処理用のキュー
        self.write_queue = Queue(maxsize=1000)
        self.start_batch_processor()
    
    async def get_multiple(self, user_ids):
        """複数ユーザーの効率的な取得"""
        # キャッシュから一括取得
        cache_keys = [f"user:{uid}" for uid in user_ids]
        cached_users = await self.cache.mget(cache_keys)
        
        # キャッシュミスのIDを特定
        missing_ids = [
            uid for uid, cached in zip(user_ids, cached_users)
            if cached is None
        ]
        
        if missing_ids:
            # データベースから一括取得（N+1問題の回避）
            query = """
                SELECT * FROM users 
                WHERE id = ANY(%s)
                AND deleted_at IS NULL
            """
            
            async with self.db_pool.acquire() as conn:
                rows = await conn.fetch(query, missing_ids)
                
            # 非同期でキャッシュに保存
            cache_tasks = [
                self.cache.set(
                    f"user:{row['id']}", 
                    dict(row),
                    expire=3600
                )
                for row in rows
            ]
            await asyncio.gather(*cache_tasks)
        
        # 結果の組み立て
        return self.merge_results(cached_users, rows)

# 革新的だがリスクのあるアプローチ
class EventSourcingUserService:
    """イベントソーシングパターンの実装"""
    
    def __init__(self):
        self.event_store = EventStore()
        self.projections = {}
        self.snapshots = SnapshotStore()
    
    def create_user(self, command: CreateUserCommand):
        # コマンドの検証
        self.validate_command(command)
        
        # イベントの生成
        events = [
            UserCreatedEvent(
                user_id=generate_uuid(),
                email=command.email,
                name=command.name,
                timestamp=datetime.now()
            )
        ]
        
        # ビジネスルールの適用
        if command.referrer_id:
            events.append(
                UserReferredEvent(
                    user_id=events[0].user_id,
                    referrer_id=command.referrer_id,
                    bonus_points=100
                )
            )
        
        # イベントの永続化
        self.event_store.append(events)
        
        # プロジェクションの更新（最終的整合性）
        self.update_projections_async(events)
        
        return events[0].user_id
    
    def get_user_history(self, user_id, as_of_date=None):
        """任意時点でのユーザー状態を再構築"""
        # スナップショットの取得
        snapshot = self.snapshots.get_latest(user_id, as_of_date)
        
        # スナップショット以降のイベントを適用
        events = self.event_store.get_events(
            user_id, 
            after=snapshot.timestamp if snapshot else None,
            until=as_of_date
        )
        
        # 状態の再構築
        state = snapshot.state if snapshot else {}
        for event in events:
            state = self.apply_event(state, event)
        
        return state

# AIが生成しがちな誤ったコード
def calculate_age_category(age):
    if age < 18:
        return "minor"
    elif age < 65:
        return "adult"
    else:
        return "senior"
    
# 問題：
# - age が負の値の場合の処理なし
# - age が数値でない場合のエラーハンドリングなし
# - 境界値（18歳、65歳）の扱いが曖昧

# 改善版
def calculate_age_category(age):
    """年齢に基づいてカテゴリを判定"""
    if not isinstance(age, (int, float)):
        raise TypeError(f"Age must be a number, got {type(age)}")
    
    if age < 0:
        raise ValueError(f"Age cannot be negative: {age}")
    
    if age > 150:
        raise ValueError(f"Age seems unrealistic: {age}")
    
    # 境界値を含む明確な条件
    if age < 18:
        return "minor"
    elif age < 65:
        return "adult"
    else:
        return "senior"

# AIが見逃しがちな状態管理の複雑さ
class OrderStateMachine:
    # 単純化されすぎた実装
    def transition(self, order, new_status):
        order.status = new_status
        order.save()
    
# 実際に必要な状態遷移管理
class OrderStateMachineComplete:
    # 有効な状態遷移の定義
    VALID_TRANSITIONS = {
        'DRAFT': ['PENDING', 'CANCELLED'],
        'PENDING': ['CONFIRMED', 'CANCELLED'],
        'CONFIRMED': ['PROCESSING', 'CANCELLED'],
        'PROCESSING': ['SHIPPED', 'FAILED'],
        'SHIPPED': ['DELIVERED', 'RETURNED'],
        'DELIVERED': ['COMPLETED', 'RETURNED'],
        'CANCELLED': [],  # 終端状態
        'FAILED': ['PENDING'],  # リトライ可能
        'RETURNED': ['REFUNDED'],
        'REFUNDED': [],  # 終端状態
        'COMPLETED': []  # 終端状態
    }
    
    def transition(self, order, new_status, metadata=None):
        """安全な状態遷移の実行"""
        current_status = order.status
        
        # 遷移の妥当性検証
        if new_status not in self.VALID_TRANSITIONS.get(current_status, []):
            raise InvalidTransitionException(
                f"Cannot transition from {current_status} to {new_status}"
            )
        
        # 遷移前のビジネスルールチェック
        self._validate_transition_rules(order, new_status)
        
        # 遷移の記録（監査証跡）
        transition_log = OrderTransitionLog(
            order_id=order.id,
            from_status=current_status,
            to_status=new_status,
            timestamp=datetime.now(),
            metadata=metadata
        )
        
        # アトミックな更新
        with transaction():
            order.status = new_status
            order.status_updated_at = datetime.now()
            order.save()
            transition_log.save()
            
            # 状態遷移に伴う副作用の実行
            self._execute_side_effects(order, current_status, new_status)
        
        # イベントの発行
        self._publish_transition_event(order, current_status, new_status)
        
        return transition_log

# AIが生成する浮動小数点計算
def calculate_total_price(items):
    total = 0
    for item in items:
        total += item.price * item.quantity
    
    # 税計算
    tax = total * 0.1
    return total + tax

# 金額計算での精度問題
# 0.1 + 0.2 = 0.30000000000000004

# 改善版：Decimalを使用
from decimal import Decimal, ROUND_HALF_UP

def calculate_total_price_precise(items):
    """正確な金額計算"""
    total = Decimal('0')
    
    for item in items:
        # 文字列から Decimal を生成（精度保持）
        price = Decimal(str(item.price))
        quantity = Decimal(str(item.quantity))
        total += price * quantity
    
    # 税計算（四捨五入規則を明示）
    tax_rate = Decimal('0.1')
    tax = total * tax_rate
    tax = tax.quantize(Decimal('0.01'), rounding=ROUND_HALF_UP)
    
    grand_total = total + tax
    
    return {
        'subtotal': str(total.quantize(Decimal('0.01'))),
        'tax': str(tax),
        'total': str(grand_total.quantize(Decimal('0.01')))
    }

# AIが生成しがちな非効率なコード
def find_common_elements(list1, list2):
    common = []
    for item1 in list1:
        for item2 in list2:
            if item1 == item2:
                common.append(item1)
    return common
# 時間複雑度: O(n*m)

# 効率的な実装
def find_common_elements_efficient(list1, list2):
    # セットを使用してO(n+m)に改善
    set1 = set(list1)
    return [item for item in list2 if item in set1]

# さらに大規模データ用の最適化
def find_common_elements_large_scale(list1, list2):
    """メモリ効率も考慮した実装"""
    # 小さい方をセットに変換（メモリ節約）
    if len(list1) < len(list2):
        smaller, larger = set(list1), list2
    else:
        smaller, larger = set(list2), list1
    
    # ジェネレータで遅延評価
    return (item for item in larger if item in smaller)

# N+1問題を含むコード
def get_orders_with_items():
    orders = db.query("SELECT * FROM orders")
    for order in orders:
        # 各注文ごとにクエリ実行（非効率）
        order['items'] = db.query(
            "SELECT * FROM order_items WHERE order_id = %s",
            order['id']
        )
    return orders

# 最適化版
def get_orders_with_items_optimized():
    # 1回のクエリで全データ取得
    query = """
        SELECT 
            o.id as order_id,
            o.customer_id,
            o.created_at,
            oi.id as item_id,
            oi.product_id,
            oi.quantity,
            oi.price
        FROM orders o
        LEFT JOIN order_items oi ON o.id = oi.order_id
        ORDER BY o.id, oi.id
    """
    
    rows = db.query(query)
    
    # メモリ効率的な結果の組み立て
    orders = {}
    for row in rows:
        order_id = row['order_id']
        
        if order_id not in orders:
            orders[order_id] = {
                'id': order_id,
                'customer_id': row['customer_id'],
                'created_at': row['created_at'],
                'items': []
            }
        
        if row['item_id']:  # LEFT JOINのNULL対応
            orders[order_id]['items'].append({
                'id': row['item_id'],
                'product_id': row['product_id'],
                'quantity': row['quantity'],
                'price': row['price']
            })
    
    return list(orders.values())

# AIが生成する脆弱なコード
@app.route('/search')
def search():
    query = request.args.get('q')
    # SQLインジェクション脆弱性
    results = db.query(f"SELECT * FROM products WHERE name LIKE '%{query}%'")
    return jsonify(results)

# セキュアな実装
@app.route('/search')
def search():
    query = request.args.get('q', '')
    
    # 入力検証
    if not query or len(query) < 3:
        return jsonify({'error': 'Query too short'}), 400
    
    if len(query) > 100:
        return jsonify({'error': 'Query too long'}), 400
    
    # 特殊文字のサニタイゼーション
    if not re.match(r'^[\w\s\-\.]+$', query):
        return jsonify({'error': 'Invalid characters in query'}), 400
    
    # パラメータ化クエリ
    results = db.query(
        "SELECT * FROM products WHERE name LIKE %s",
        (f'%{query}%',)
    )
    
    # 結果の制限
    return jsonify(results[:100])  # 最大100件

# 不完全な認証実装
@app.route('/api/user/<user_id>')
def get_user(user_id):
    # 認証チェックなし
    user = User.query.get(user_id)
    return jsonify(user.to_dict())

# 包括的なセキュリティ実装
from functools import wraps
import jwt

def require_auth(f):
    @wraps(f)
    def decorated_function(*args, **kwargs):
        token = request.headers.get('Authorization', '').replace('Bearer ', '')
        
        if not token:
            return jsonify({'error': 'No token provided'}), 401
        
        try:
            # トークン検証
            payload = jwt.decode(
                token, 
                app.config['SECRET_KEY'],
                algorithms=['HS256']
            )
            
            # トークンの有効期限確認
            if payload['exp'] < time.time():
                return jsonify({'error': 'Token expired'}), 401
            
            # ユーザー情報の取得
            request.current_user = User.query.get(payload['user_id'])
            
            if not request.current_user:
                return jsonify({'error': 'Invalid user'}), 401
                
        except jwt.InvalidTokenError:
            return jsonify({'error': 'Invalid token'}), 401
        
        return f(*args, **kwargs)
    
    return decorated_function

@app.route('/api/user/<user_id>')
@require_auth
def get_user(user_id):
    # 認可チェック
    if str(request.current_user.id) != user_id and not request.current_user.is_admin:
        return jsonify({'error': 'Unauthorized'}), 403
    
    user = User.query.get(user_id)
    
    if not user:
        return jsonify({'error': 'User not found'}), 404
    
    # 機密情報のフィルタリング
    return jsonify(user.to_dict(exclude=['password_hash', 'security_questions']))

# AIが生成する一貫性のないコード
def proc_data(d):
    res = []
    for item in d:
        if validate_item(item):
            processed = transform(item)
            res.append(processed)
    return res

# 可読性を考慮した実装
def process_customer_orders(raw_orders: List[Dict]) -> List[Order]:
    """
    生の注文データを検証し、Orderオブジェクトのリストに変換する
    
    Args:
        raw_orders: 外部システムから受信した生の注文データ
        
    Returns:
        検証済みのOrderオブジェクトのリスト
        
    Raises:
        ValidationError: 注文データが不正な場合
    """
    validated_orders = []
    
    for raw_order in raw_orders:
        try:
            # ビジネスルールに基づく検証
            validation_result = validate_order_data(raw_order)
            
            if not validation_result.is_valid:
                logger.warning(
                    f"Invalid order skipped: {validation_result.errors}",
                    extra={'order_id': raw_order.get('id')}
                )
                continue
            
            # ドメインオブジェクトへの変換
            order = transform_to_order_entity(raw_order)
            validated_orders.append(order)
            
        except Exception as e:
            logger.error(
                f"Unexpected error processing order: {e}",
                extra={'order_data': raw_order}
            )
            # ビジネス要件に応じて、エラーを握り潰すか再発生させる
            raise OrderProcessingError(f"Failed to process order: {e}")
    
    return validated_orders

# AIが生成する不十分なドキュメント
def calculate_metrics(data):
    # メトリクスを計算
    return {
        'avg': sum(data) / len(data),
        'max': max(data),
        'min': min(data)
    }

# 包括的なドキュメンテーション
def calculate_performance_metrics(
    response_times: List[float],
    percentiles: List[int] = None
) -> Dict[str, Union[float, Dict[int, float]]]:
    """
    APIレスポンスタイムのパフォーマンスメトリクスを計算する
    
    このメソッドは、システムのパフォーマンス監視に使用される
    主要なメトリクスを計算します。SLAの評価に使用されます。
    
    Args:
        response_times: ミリ秒単位のレスポンスタイムのリスト
        percentiles: 計算するパーセンタイル値のリスト
                    (デフォルト: [50, 90, 95, 99])
    
    Returns:
        以下のキーを持つ辞書:
        - 'count': データポイント数
        - 'mean': 平均値（ミリ秒）
        - 'median': 中央値（ミリ秒）
        - 'std_dev': 標準偏差
        - 'min': 最小値（ミリ秒）
        - 'max': 最大値（ミリ秒）
        - 'percentiles': パーセンタイル値の辞書
    
    Raises:
        ValueError: response_timesが空または無効な値を含む場合
    
    Example:
        >>> times = [100, 200, 150, 300, 250]
        >>> metrics = calculate_performance_metrics(times)
        >>> print(f"P95: {metrics['percentiles'][95]}ms")
    
    Note:
        大量のデータ（100万件以上）の場合は、
        calculate_performance_metrics_streaming()の使用を推奨
    """
    if not response_times:
        raise ValueError("response_times cannot be empty")
    
    if any(t < 0 for t in response_times):
        raise ValueError("response_times cannot contain negative values")
    
    if percentiles is None:
        percentiles = [50, 90, 95, 99]
    
    # NumPyを使用せず、Pure Pythonで実装（依存性を減らすため）
    sorted_times = sorted(response_times)
    n = len(sorted_times)
    
    # 基本統計量
    mean = sum(sorted_times) / n
    
    # 標準偏差
    variance = sum((x - mean) ** 2 for x in sorted_times) / n
    std_dev = variance ** 0.5
    
    # パーセンタイル計算
    percentile_values = {}
    for p in percentiles:
        if not 0 <= p <= 100:
            raise ValueError(f"Percentile must be between 0 and 100, got {p}")
        
        # パーセンタイルのインデックス計算（線形補間）
        k = (n - 1) * (p / 100)
        f = int(k)
        c = k - f
        
        if f + 1 < n:
            percentile_values[p] = sorted_times[f] * (1 - c) + sorted_times[f + 1] * c
        else:
            percentile_values[p] = sorted_times[f]
    
    return {
        'count': n,
        'mean': round(mean, 2),
        'median': percentile_values.get(50, sorted_times[n // 2]),
        'std_dev': round(std_dev, 2),
        'min': sorted_times[0],
        'max': sorted_times[-1],
        'percentiles': {k: round(v, 2) for k, v in percentile_values.items()}
    }

# 拡張性を考慮していない設計
class PaymentProcessor:
    def process(self, payment_type, amount):
        if payment_type == "credit_card":
            # クレジットカード処理
            return self.process_credit_card(amount)
        elif payment_type == "paypal":
            # PayPal処理
            return self.process_paypal(amount)
        elif payment_type == "bitcoin":
            # Bitcoin処理
            return self.process_bitcoin(amount)
        # 新しい支払い方法を追加するたびに変更が必要

# 拡張可能な設計（戦略パターン）
from abc import ABC, abstractmethod

class PaymentStrategy(ABC):
    """支払い戦略の基底クラス"""
    
    @abstractmethod
    def validate(self, payment_data: Dict) -> bool:
        """支払いデータの検証"""
        pass
    
    @abstractmethod
    def process(self, amount: Decimal) -> PaymentResult:
        """支払い処理の実行"""
        pass
    
    @abstractmethod
    def rollback(self, transaction_id: str) -> bool:
        """支払いのロールバック"""
        pass

class CreditCardPayment(PaymentStrategy):
    """クレジットカード支払いの実装"""
    
    def __init__(self, gateway_config: Dict):
        self.gateway = CreditCardGateway(gateway_config)
    
    def validate(self, payment_data: Dict) -> bool:
        # カード番号、有効期限、CVVの検証
        return (
            self._validate_card_number(payment_data.get('card_number')) and
            self._validate_expiry(payment_data.get('expiry')) and
            self._validate_cvv(payment_data.get('cvv'))
        )
    
    def process(self, amount: Decimal) -> PaymentResult:
        # 実際の決済処理
        return self.gateway.charge(amount)
    
    def rollback(self, transaction_id: str) -> bool:
        return self.gateway.refund(transaction_id)

class PaymentProcessor:
    """拡張可能な支払い処理システム"""
    
    def __init__(self):
        self.strategies: Dict[str, PaymentStrategy] = {}
    
    def register_strategy(self, payment_type: str, strategy: PaymentStrategy):
        """新しい支払い方法の登録"""
        self.strategies[payment_type] = strategy
    
    def process_payment(
        self,
        payment_type: str,
        amount: Decimal,
        payment_data: Dict
    ) -> PaymentResult:
        """支払い処理の実行"""
        strategy = self.strategies.get(payment_type)
        
        if not strategy:
            raise UnsupportedPaymentTypeError(f"Unknown payment type: {payment_type}")
        
        # 検証
        if not strategy.validate(payment_data):
            raise InvalidPaymentDataError("Payment data validation failed")
        
        # 処理実行（リトライロジック付き）
        for attempt in range(3):
            try:
                result = strategy.process(amount)
                
                if result.success:
                    # 監査ログ
                    self.audit_logger.log_payment(payment_type, amount, result)
                    return result
                    
            except TemporaryFailureException:
                if attempt < 2:
                    time.sleep(2 ** attempt)  # 指数バックオフ
                    continue
                raise
        
        raise PaymentProcessingError("Payment processing failed after retries")

# 使用例：新しい支払い方法の追加が容易
processor = PaymentProcessor()
processor.register_strategy("credit_card", CreditCardPayment(config))
processor.register_strategy("cryptocurrency", CryptocurrencyPayment(wallet_config))
processor.register_strategy("bank_transfer", BankTransferPayment(bank_config))