# ダーティコード: 何をしているか読み取れない
def calc(l, t):
    r = []
    for i in l:
        if i['a'] > t and i['s'] == 1:
            r.append(i['n'])
    return r
 
# クリーンコード: 意図が明確
ACTIVE = 1
 
def find_active_users_above_threshold(
    users: list[dict],
    age_threshold: int
) -> list[str]:
    """指定年齢以上のアクティブユーザー名を返す。
 
    Args:
        users: ユーザー情報の辞書リスト。各辞書は 'age', 'status', 'name' キーを持つ。
        age_threshold: 年齢の下限値（この値より大きいユーザーが対象）。
 
    Returns:
        条件に合致するユーザー名のリスト。
 
    Examples:
        >>> users = [
        ...     {'name': '田中', 'age': 25, 'status': 1},
        ...     {'name': '鈴木', 'age': 17, 'status': 1},
        ...     {'name': '佐藤', 'age': 30, 'status': 0},
        ... ]
        >>> find_active_users_above_threshold(users, 20)
        ['田中']
    """
    active_senior_users = []
    for user in users:
        if user['age'] > age_threshold and user['status'] == ACTIVE:
            active_senior_users.append(user['name'])
    return active_senior_users

# ダーティコード: エラーが飲み込まれる
def get_user(id):
    try:
        return db.query(id)
    except:
        return None  # どんなエラーも握りつぶす → デバッグ不可能
 
# クリーンコード: エラーの意味が明確
class UserNotFoundError(Exception):
    """ユーザーが見つからない場合のエラー"""
    def __init__(self, user_id: int):
        self.user_id = user_id
        super().__init__(f"ユーザーID {user_id} は存在しません")
 
class DatabaseConnectionError(Exception):
    """データベース接続に失敗した場合のエラー"""
    pass
 
def get_user_by_id(user_id: int) -> "User":
    """ユーザーIDからユーザーを取得する。
 
    Args:
        user_id: 取得対象のユーザーID。
 
    Returns:
        該当するUserオブジェクト。
 
    Raises:
        UserNotFoundError: ユーザーが見つからない場合。
        DatabaseConnectionError: DB接続に失敗した場合。
    """
    try:
        user = user_repository.find_by_id(user_id)
    except ConnectionError as e:
        raise DatabaseConnectionError(f"DB接続失敗: {e}") from e
 
    if user is None:
        raise UserNotFoundError(user_id)
 
    return user

// ダーティコード: 1つの関数で複数の責任
function processOrder(order) {
  // バリデーション (責任1)
  if (!order.items || order.items.length === 0) return false;
  if (!order.customer) return false;
 
  // 合計計算 (責任2)
  let total = 0;
  for (const item of order.items) {
    total += item.price * item.quantity;
    if (item.discount) total -= item.discount;
  }
 
  // DB保存 (責任3)
  db.save({ ...order, total, status: 'confirmed' });
 
  // メール送信 (責任4)
  sendEmail(order.customer.email, `注文確定: ${total}円`);
 
  return true;
}
 
// クリーンコード: 各責任を分離
function processOrder(order) {
  validateOrder(order);
  const total = calculateOrderTotal(order.items);
  const confirmedOrder = confirmOrder(order, total);
  notifyCustomer(confirmedOrder);
  return confirmedOrder;
}
 
function validateOrder(order) {
  if (!order.items || order.items.length === 0) {
    throw new InvalidOrderError('注文には1つ以上の商品が必要です');
  }
  if (!order.customer) {
    throw new InvalidOrderError('顧客情報が必要です');
  }
}
 
function calculateOrderTotal(items) {
  return items.reduce((total, item) => {
    const itemTotal = item.price * item.quantity;
    const discount = item.discount || 0;
    return total + itemTotal - discount;
  }, 0);
}
 
function confirmOrder(order, total) {
  const confirmedOrder = { ...order, total, status: 'confirmed' };
  orderRepository.save(confirmedOrder);
  return confirmedOrder;
}
 
function notifyCustomer(order) {
  emailService.send(
    order.customer.email,
    `注文確定: ${order.total}円`
  );
}

// ダーティコード: マジックナンバーだらけ
if (user.getAge() >= 18 && user.getScore() > 70 && user.getType() == 3) {
    applyDiscount(0.15);
}
 
// クリーンコード: 定数で意味を付与
private static final int LEGAL_AGE = 18;
private static final int PREMIUM_SCORE_THRESHOLD = 70;
private static final int GOLD_MEMBER_TYPE = 3;
private static final double GOLD_MEMBER_DISCOUNT_RATE = 0.15;
 
if (user.isAdult(LEGAL_AGE)
    && user.hasPremiumScore(PREMIUM_SCORE_THRESHOLD)
    && user.isGoldMember()) {
    applyDiscount(GOLD_MEMBER_DISCOUNT_RATE);
}
 
// さらに改善: ビジネスロジックをメソッドに抽出
if (user.isEligibleForGoldDiscount()) {
    applyDiscount(GOLD_MEMBER_DISCOUNT_RATE);
}

// ダーティコード: ネストが深い
function getPayAmount(employee: Employee): number {
  let result: number;
  if (employee.isSeparated) {
    result = separatedAmount(employee);
  } else {
    if (employee.isRetired) {
      result = retiredAmount(employee);
    } else {
      if (employee.isOnLeave) {
        result = leaveAmount(employee);
      } else {
        result = normalPayAmount(employee);
      }
    }
  }
  return result;
}
 
// クリーンコード: ガード節で平坦化
function getPayAmount(employee: Employee): number {
  if (employee.isSeparated) return separatedAmount(employee);
  if (employee.isRetired) return retiredAmount(employee);
  if (employee.isOnLeave) return leaveAmount(employee);
  return normalPayAmount(employee);
}

# ダーティコード: コメントに頼る
# 30日以上ログインしていないユーザーを取得
# ステータスがアクティブで、トライアル期間が終了しているもの
users = []
for u in all_users:
    d = (datetime.now() - u.last_login).days
    if d >= 30 and u.status == 1 and u.trial_end < datetime.now():
        users.append(u)
 
# クリーンコード: コード自体が意図を語る
INACTIVE_THRESHOLD_DAYS = 30
 
def find_inactive_but_subscribed_users(
    all_users: list[User],
    threshold_days: int = INACTIVE_THRESHOLD_DAYS
) -> list[User]:
    """トライアル終了済みのアクティブユーザーで、一定期間ログインしていない人を返す。"""
    return [
        user for user in all_users
        if user.is_inactive_for(threshold_days)
        and user.is_active
        and user.has_trial_ended()
    ]

// ダーティコード: 複雑な条件式
if (date.getMonth() >= 6 && date.getMonth() <= 8
    && temperature > 30
    && !isHoliday(date)
    && employee.getVacationDaysLeft() > 0
    && !employee.isOnCriticalProject()) {
    applySummerBonus(employee);
}
 
// クリーンコード: 条件をメソッドに抽出
if (isSummerBonusEligible(date, temperature, employee)) {
    applySummerBonus(employee);
}
 
private boolean isSummerBonusEligible(
    LocalDate date, int temperature, Employee employee
) {
    return isSummerSeason(date)
        && isHotDay(temperature)
        && isWorkingDay(date)
        && employee.hasAvailableVacationDays()
        && !employee.isOnCriticalProject();
}
 
private boolean isSummerSeason(LocalDate date) {
    int month = date.getMonthValue();
    return month >= 6 && month <= 8;
}
 
private boolean isHotDay(int temperature) {
    return temperature > SUMMER_BONUS_TEMPERATURE_THRESHOLD;
}

# 複雑度1: 分岐なし
def greet(name: str) -> str:
    return f"Hello, {name}"
 
# 複雑度2: if文が1つ
def check_age(age: int) -> str:
    if age >= 18:
        return "成人"
    return "未成年"
 
# 複雑度4: if + elif + for
def classify_scores(scores: list[int]) -> dict:
    result = {"high": 0, "mid": 0, "low": 0}
    for score in scores:           # +1
        if score >= 80:            # +1
            result["high"] += 1
        elif score >= 50:          # +1
            result["mid"] += 1
        else:
            result["low"] += 1
    return result
 
# 計算方法: M = E - N + 2P
# E = エッジ数, N = ノード数, P = 連結成分数
# 簡易計算: M = 分岐キーワード数(if, elif, for, while, and, or, except) + 1

# NG: 読みにくい最適化を早期に行う
def f(d):
    return {k: v for k, v in sorted(
        ((k, sum(x['v'] for x in g))
         for k, g in __import__('itertools').groupby(
             sorted(d, key=lambda x: x['k']),
             key=lambda x: x['k'])),
        key=lambda x: -x[1])}
 
# OK: まず可読性を優先し、必要時に最適化
from collections import defaultdict
 
def aggregate_and_sort_by_value(data: list[dict]) -> dict:
    """キーごとに値を集計し、降順で返す。
 
    Args:
        data: 'key' と 'value' を持つ辞書のリスト。
 
    Returns:
        キーごとの合計値を降順に並べた辞書。
 
    Examples:
        >>> data = [
        ...     {'key': 'a', 'value': 10},
        ...     {'key': 'b', 'value': 5},
        ...     {'key': 'a', 'value': 20},
        ... ]
        >>> aggregate_and_sort_by_value(data)
        {'a': 30, 'b': 5}
    """
    aggregated = defaultdict(int)
    for item in data:
        aggregated[item['key']] += item['value']
 
    return dict(sorted(
        aggregated.items(),
        key=lambda pair: pair[1],
        reverse=True
    ))

// NG: コメントで複雑さを説明
// i は顧客のインデックス、j は注文のインデックス、
// k は商品のインデックス、t は合計金額
for (int i = 0; i < c.length; i++) {
    for (int j = 0; j < c[i].o.length; j++) {
        for (int k = 0; k < c[i].o[j].p.length; k++) {
            t += c[i].o[j].p[k].pr * c[i].o[j].p[k].q;
        }
    }
}
 
// OK: コード自体が意味を語る
for (Customer customer : customers) {
    for (Order order : customer.getOrders()) {
        for (Product product : order.getProducts()) {
            totalRevenue += product.getPrice() * product.getQuantity();
        }
    }
}

# NG: 単純な処理を過度に抽象化
class AbstractDataProcessorFactory:
    def create_processor(self): ...
 
class ConcreteDataProcessorFactory(AbstractDataProcessorFactory):
    def create_processor(self):
        return DataProcessor(
            reader=FileReaderAdapter(CsvReader()),
            transformer=DataTransformationPipeline([
                WhitespaceNormalizer(),
                EncodingConverter(),
            ]),
            writer=OutputWriterAdapter(ConsoleWriter()),
        )
 
# OK: 直接的でシンプル
import csv
 
def read_and_display_csv(filepath: str) -> None:
    """CSVファイルを読み込んでコンソールに表示する。"""
    with open(filepath) as f:
        reader = csv.reader(f)
        for row in reader:
            print(", ".join(row))

# 改善前
def p(d):
    r = 0
    for x in d:
        if x['t'] == 'i':
            r += x['a']
        elif x['t'] == 'e':
            r -= x['a']
    if r < 0:
        r = 0
    return r

INCOME = 'income'
EXPENSE = 'expense'
 
def calculate_balance(transactions: list[dict]) -> float:
    """取引リストから残高を計算する。残高は0未満にならない。
 
    Args:
        transactions: 'type' ('income' or 'expense') と 'amount' (float) を持つ辞書リスト。
 
    Returns:
        計算された残高（最小値は0）。
    """
    balance = 0.0
    for transaction in transactions:
        if transaction['type'] == INCOME:
            balance += transaction['amount']
        elif transaction['type'] == EXPENSE:
            balance -= transaction['amount']
    return max(balance, 0.0)

import json, os, smtplib, sqlite3
 
class App:
    def run(self, action, data):
        conn = sqlite3.connect('app.db')
        if action == 'register':
            if data.get('email') and '@' in data['email'] and len(data.get('password', '')) >= 8:
                conn.execute("INSERT INTO users VALUES (?, ?, ?)",
                    (data['email'], data['password'], json.dumps({'created': str(datetime.now())})))
                conn.commit()
                try:
                    s = smtplib.SMTP('localhost')
                    s.sendmail('noreply@app.com', data['email'], 'Welcome!')
                    s.quit()
                except:
                    pass
                return {'status': 'ok'}
            return {'status': 'error', 'msg': 'invalid'}
        elif action == 'login':
            r = conn.execute("SELECT * FROM users WHERE email=? AND password=?",
                (data.get('email', ''), data.get('password', ''))).fetchone()
            if r:
                return {'status': 'ok', 'token': os.urandom(16).hex()}
            return {'status': 'error'}
        elif action == 'delete':
            conn.execute("DELETE FROM users WHERE email=?", (data.get('email', ''),))
            conn.commit()
            return {'status': 'ok'}
        conn.close()

from abc import ABC, abstractmethod
from dataclasses import dataclass
from typing import Optional
import bcrypt
 
# ドメインモデル
@dataclass
class User:
    email: str
    password_hash: str
 
# リポジトリ層
class UserRepository(ABC):
    @abstractmethod
    def save(self, user: User) -> None: ...
 
    @abstractmethod
    def find_by_email(self, email: str) -> Optional[User]: ...
 
    @abstractmethod
    def delete_by_email(self, email: str) -> None: ...
 
# バリデーション
class UserValidator:
    MIN_PASSWORD_LENGTH = 8
 
    def validate_registration(self, email: str, password: str) -> list[str]:
        errors = []
        if not email or '@' not in email:
            errors.append("有効なメールアドレスを入力してください")
        if len(password) < self.MIN_PASSWORD_LENGTH:
            errors.append(f"パスワードは{self.MIN_PASSWORD_LENGTH}文字以上必要です")
        return errors
 
# 認証サービス
class AuthService:
    def __init__(self, repository: UserRepository, validator: UserValidator):
        self.repository = repository
        self.validator = validator
 
    def register(self, email: str, password: str) -> "RegistrationResult":
        errors = self.validator.validate_registration(email, password)
        if errors:
            return RegistrationResult.failure(errors)
 
        password_hash = bcrypt.hashpw(
            password.encode(), bcrypt.gensalt()
        ).decode()
 
        user = User(email=email, password_hash=password_hash)
        self.repository.save(user)
        return RegistrationResult.success(user)

# デバッグ用ユーティリティ
import logging
import traceback
from functools import wraps
 
# ロガーの設定
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s [%(levelname)s] %(name)s: %(message)s'
)
logger = logging.getLogger(__name__)
 
def debug_decorator(func):
    """関数の入出力をログ出力するデコレータ"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        logger.debug(f"呼び出し: {func.__name__}(args={args}, kwargs={kwargs})")
        try:
            result = func(*args, **kwargs)
            logger.debug(f"戻り値: {func.__name__} -> {result}")
            return result
        except Exception as e:
            logger.error(f"例外発生: {func.__name__}: {e}")
            logger.error(traceback.format_exc())
            raise
    return wrapper
 
@debug_decorator
def process_data(items):
    """データ処理（デバッグ対象）"""
    if not items:
        raise ValueError("空のデータ")
    return [item * 2 for item in items]

# 設計判断の記録テンプレート
class ArchitectureDecisionRecord:
    """ADR (Architecture Decision Record) の作成"""
 
    def __init__(self, title: str):
        self.title = title
        self.context = ""
        self.decision = ""
        self.consequences = []
        self.alternatives = []
 
    def set_context(self, context: str):
        """背景と課題の記述"""
        self.context = context
        return self
 
    def set_decision(self, decision: str):
        """決定内容の記述"""
        self.decision = decision
        return self
 
    def add_consequence(self, consequence: str, positive: bool = True):
        """結果の追加"""
        self.consequences.append({
            'description': consequence,
            'type': 'positive' if positive else 'negative'
        })
        return self
 
    def add_alternative(self, name: str, reason_rejected: str):
        """却下した代替案の追加"""
        self.alternatives.append({
            'name': name,
            'reason_rejected': reason_rejected
        })
        return self
 
    def to_markdown(self) -> str:
        """Markdown形式で出力"""
        md = f"# ADR: {self.title}\n\n"
        md += f"## 背景\n{self.context}\n\n"
        md += f"## 決定\n{self.decision}\n\n"
        md += "## 結果\n"
        for c in self.consequences:
            icon = "✅" if c['type'] == 'positive' else "⚠️"
            md += f"- {icon} {c['description']}\n"
        md += "\n## 却下した代替案\n"
        for a in self.alternatives:
            md += f"- **{a['name']}**: {a['reason_rejected']}\n"
        return md

# チーム間のAPI契約定義
from dataclasses import dataclass
from typing import List, Optional
from enum import Enum
 
class Priority(Enum):
    LOW = "low"
    MEDIUM = "medium"
    HIGH = "high"
    CRITICAL = "critical"
 
@dataclass
class APIContract:
    """チーム間のAPI契約"""
    endpoint: str
    method: str
    owner_team: str
    consumers: List[str]
    sla_ms: int  # レスポンスタイムSLA
    priority: Priority
 
    def validate_sla(self, actual_ms: int) -> bool:
        """SLA準拠の確認"""
        return actual_ms <= self.sla_ms
 
    def to_openapi(self) -> dict:
        """OpenAPI形式で出力"""
        return {
            'path': self.endpoint,
            'method': self.method,
            'x-owner': self.owner_team,
            'x-consumers': self.consumers,
            'x-sla-ms': self.sla_ms
        }
 
# 使用例
contracts = [
    APIContract(
        endpoint="/api/v1/users",
        method="GET",
        owner_team="user-team",
        consumers=["order-team", "notification-team"],
        sla_ms=200,
        priority=Priority.HIGH
    ),
    APIContract(
        endpoint="/api/v1/orders",
        method="POST",
        owner_team="order-team",
        consumers=["payment-team", "inventory-team"],
        sla_ms=500,
        priority=Priority.CRITICAL
    )
]