# Before: 長いメソッドに複数の関心が混在
class Order:
    def print_invoice(self):
        print("========== 請求書 ==========")
        print(f"顧客: {self.customer.name}")
        print(f"日付: {self.date}")
        print()
 
        # 明細の出力
        total = 0
        for item in self.items:
            line_total = item.price * item.quantity
            total += line_total
            print(f"  {item.name}: {item.price} x {item.quantity} = {line_total}")
 
        # 合計の計算と出力
        tax = total * 0.10
        grand_total = total + tax
        print()
        print(f"小計: {total}")
        print(f"消費税(10%): {tax}")
        print(f"合計: {grand_total}")
        print("============================")
 
 
# After: 意図ごとにメソッドを抽出
class Order:
    def print_invoice(self):
        """請求書の出力 ── 高レベルの流れが一目で分かる"""
        self._print_header()
        self._print_line_items()
        self._print_totals()
 
    def _print_header(self):
        """ヘッダー部分の出力"""
        print("========== 請求書 ==========")
        print(f"顧客: {self.customer.name}")
        print(f"日付: {self.date}")
        print()
 
    def _print_line_items(self):
        """明細の出力"""
        for item in self.items:
            line_total = item.price * item.quantity
            print(f"  {item.name}: {item.price} x {item.quantity} = {line_total}")
 
    def _print_totals(self):
        """合計部分の出力"""
        subtotal = self.calculate_subtotal()
        tax = subtotal * Decimal("0.10")
        print()
        print(f"小計: {subtotal}")
        print(f"消費税(10%): {tax}")
        print(f"合計: {subtotal + tax}")
        print("============================")
 
    def calculate_subtotal(self) -> Decimal:
        """小計の計算 ── 他のメソッドからも再利用可能"""
        return sum(item.price * item.quantity for item in self.items)

# Before: ローカル変数が多く、抽出が難しいケース
def generate_report(orders: list[Order], start_date: date, end_date: date) -> str:
    # フィルタリング
    filtered = [o for o in orders
                if start_date <= o.date <= end_date]
 
    # 集計
    total_revenue = sum(o.total for o in filtered)
    total_orders = len(filtered)
    avg_order_value = total_revenue / total_orders if total_orders > 0 else 0
 
    # 上位商品の集計
    product_counts = {}
    for order in filtered:
        for item in order.items:
            product_counts[item.name] = (
                product_counts.get(item.name, 0) + item.quantity
            )
    top_products = sorted(
        product_counts.items(), key=lambda x: x[1], reverse=True
    )[:10]
 
    # レポート文字列の生成
    lines = [
        f"=== レポート ({start_date} ~ {end_date}) ===",
        f"総売上: {total_revenue:,.0f}円",
        f"注文数: {total_orders}件",
        f"平均注文額: {avg_order_value:,.0f}円",
        "",
        "--- 上位商品 ---",
    ]
    for name, count in top_products:
        lines.append(f"  {name}: {count}個")
 
    return "\n".join(lines)
 
 
# After: 各段階を独立したメソッドに抽出
@dataclass
class ReportStatistics:
    """レポートの集計結果を保持するデータクラス"""
    total_revenue: Decimal
    total_orders: int
    avg_order_value: Decimal
    top_products: list[tuple[str, int]]
 
 
class ReportGenerator:
    def generate(self, orders: list[Order],
                 start_date: date, end_date: date) -> str:
        """レポート生成のオーケストレーション"""
        filtered = self._filter_by_date(orders, start_date, end_date)
        stats = self._calculate_statistics(filtered)
        return self._format_report(stats, start_date, end_date)
 
    def _filter_by_date(self, orders: list[Order],
                        start: date, end: date) -> list[Order]:
        """期間でフィルタリング"""
        return [o for o in orders if start <= o.date <= end]
 
    def _calculate_statistics(self, orders: list[Order]) -> ReportStatistics:
        """注文リストから統計情報を計算"""
        total_revenue = sum(o.total for o in orders)
        total_orders = len(orders)
        avg = total_revenue / total_orders if total_orders > 0 else Decimal("0")
        top_products = self._aggregate_products(orders)
        return ReportStatistics(total_revenue, total_orders, avg, top_products)
 
    def _aggregate_products(self, orders: list[Order]) -> list[tuple[str, int]]:
        """商品ごとの販売数を集計"""
        counts: dict[str, int] = {}
        for order in orders:
            for item in order.items:
                counts[item.name] = counts.get(item.name, 0) + item.quantity
        return sorted(counts.items(), key=lambda x: x[1], reverse=True)[:10]
 
    def _format_report(self, stats: ReportStatistics,
                       start: date, end: date) -> str:
        """統計情報をレポート文字列に整形"""
        lines = [
            f"=== レポート ({start} ~ {end}) ===",
            f"総売上: {stats.total_revenue:,.0f}円",
            f"注文数: {stats.total_orders}件",
            f"平均注文額: {stats.avg_order_value:,.0f}円",
            "",
            "--- 上位商品 ---",
        ]
        for name, count in stats.top_products:
            lines.append(f"  {name}: {count}個")
        return "\n".join(lines)

// Before: calculateDiscount() は Order のデータを使っている (Feature Envy)
class Customer {
    private Address address;
    private List<Order> orders;
 
    // この計算は Order の責任であるべき
    public double calculateOrderDiscount(Order order) {
        double total = order.getTotal();
        int itemCount = order.getItems().size();
 
        if (total > 10000 && itemCount > 5) return 0.15;
        if (total > 10000) return 0.10;
        if (total > 5000) return 0.05;
        return 0;
    }
 
    // この計算も Order の内部データに依存
    public String formatOrderSummary(Order order) {
        return String.format("注文 #%s: %d品目, 合計 %.0f円",
            order.getId(),
            order.getItems().size(),
            order.getTotal());
    }
}
 
 
// After: メソッドを Order に移動
class Order {
    private String id;
    private List<OrderItem> items;
    private double total;
 
    public double calculateDiscount() {
        if (this.total > 10000 && this.items.size() > 5) return 0.15;
        if (this.total > 10000) return 0.10;
        if (this.total > 5000) return 0.05;
        return 0;
    }
 
    public String formatSummary() {
        return String.format("注文 #%s: %d品目, 合計 %.0f円",
            this.id, this.items.size(), this.total);
    }
 
    public double getDiscountedTotal() {
        return this.total * (1 - calculateDiscount());
    }
}
 
// Customer は Order のメソッドを呼ぶだけ
class Customer {
    public double getOrderDiscount(Order order) {
        return order.calculateDiscount();  // 委譲
    }
}

// Before: 意味不明な名前
class Mgr {
  proc(d: any[]): any[] {
    return d.filter(i => i.s === 1).map(i => ({ ...i, t: Date.now() }));
  }
 
  chk(v: string): boolean {
    return v.length > 0 && v.length <= 100;
  }
 
  calc(a: number, b: number, c: number): number {
    return a * b - c;
  }
}
 
 
// After: 意図が明確な名前
class ActiveUserProcessor {
  /**
   * アクティブなユーザーをフィルタリングし、処理タイムスタンプを付与する。
   */
  filterAndTimestamp(users: User[]): TimestampedUser[] {
    return users
      .filter(user => user.status === UserStatus.ACTIVE)
      .map(user => ({
        ...user,
        processedAt: Date.now(),
      }));
  }
 
  /**
   * 表示名が有効な長さであるかを検証する。
   */
  isValidDisplayName(name: string): boolean {
    return name.length > 0 && name.length <= 100;
  }
 
  /**
   * 販売利益を計算する: 単価 x 数量 - 割引額
   */
  calculateProfit(unitPrice: number, quantity: number, discount: number): number {
    return unitPrice * quantity - discount;
  }
}

# Before: 型による条件分岐が複数メソッドに散在
class Employee:
    def __init__(self, employee_type: str, **kwargs):
        self.type = employee_type
        self.salary = kwargs.get('salary', 0)
        self.hourly_rate = kwargs.get('hourly_rate', 0)
        self.hours_worked = kwargs.get('hours_worked', 0)
        self.daily_rate = kwargs.get('daily_rate', 0)
        self.days_worked = kwargs.get('days_worked', 0)
 
    def calculate_pay(self) -> Decimal:
        if self.type == 'full_time':
            return self.salary
        elif self.type == 'part_time':
            return self.hourly_rate * self.hours_worked
        elif self.type == 'contractor':
            return self.daily_rate * self.days_worked
        elif self.type == 'intern':
            return Decimal("0")  # 無給インターン
        else:
            raise ValueError(f"Unknown type: {self.type}")
 
    def calculate_benefits(self) -> Decimal:
        if self.type == 'full_time':
            return self.salary * Decimal("0.2")
        elif self.type == 'part_time':
            return self.hourly_rate * self.hours_worked * Decimal("0.05")
        elif self.type == 'contractor':
            return Decimal("0")
        elif self.type == 'intern':
            return Decimal("0")
        else:
            raise ValueError(f"Unknown type: {self.type}")
 
    def get_title(self) -> str:
        if self.type == 'full_time':
            return "正社員"
        elif self.type == 'part_time':
            return "パートタイム"
        elif self.type == 'contractor':
            return "業務委託"
        elif self.type == 'intern':
            return "インターン"
        else:
            return "不明"
 
 
# After: ポリモーフィズムで各型が自分の振る舞いを持つ
from abc import ABC, abstractmethod
from decimal import Decimal
 
class Employee(ABC):
    """従業員の基底クラス"""
 
    def __init__(self, name: str):
        self.name = name
 
    @abstractmethod
    def calculate_pay(self) -> Decimal:
        """給与を計算する"""
 
    @abstractmethod
    def calculate_benefits(self) -> Decimal:
        """福利厚生費を計算する"""
 
    @abstractmethod
    def get_title(self) -> str:
        """職種名を返す"""
 
    def total_cost(self) -> Decimal:
        """会社の総コスト = 給与 + 福利厚生"""
        return self.calculate_pay() + self.calculate_benefits()
 
 
class FullTimeEmployee(Employee):
    def __init__(self, name: str, salary: Decimal):
        super().__init__(name)
        self.salary = salary
 
    def calculate_pay(self) -> Decimal:
        return self.salary
 
    def calculate_benefits(self) -> Decimal:
        return self.salary * Decimal("0.2")
 
    def get_title(self) -> str:
        return "正社員"
 
 
class PartTimeEmployee(Employee):
    def __init__(self, name: str, hourly_rate: Decimal, hours_worked: int):
        super().__init__(name)
        self.hourly_rate = hourly_rate
        self.hours_worked = hours_worked
 
    def calculate_pay(self) -> Decimal:
        return self.hourly_rate * self.hours_worked
 
    def calculate_benefits(self) -> Decimal:
        return self.calculate_pay() * Decimal("0.05")
 
    def get_title(self) -> str:
        return "パートタイム"
 
 
class Contractor(Employee):
    def __init__(self, name: str, daily_rate: Decimal, days_worked: int):
        super().__init__(name)
        self.daily_rate = daily_rate
        self.days_worked = days_worked
 
    def calculate_pay(self) -> Decimal:
        return self.daily_rate * self.days_worked
 
    def calculate_benefits(self) -> Decimal:
        return Decimal("0")  # 福利厚生なし
 
    def get_title(self) -> str:
        return "業務委託"
 
 
class Intern(Employee):
    def __init__(self, name: str, stipend: Decimal = Decimal("0")):
        super().__init__(name)
        self.stipend = stipend
 
    def calculate_pay(self) -> Decimal:
        return self.stipend
 
    def calculate_benefits(self) -> Decimal:
        return Decimal("0")
 
    def get_title(self) -> str:
        return "インターン"
 
 
# ファクトリ関数: 旧コードとの互換性を維持
def create_employee(employee_type: str, name: str, **kwargs) -> Employee:
    """型文字列からEmployeeを生成するファクトリ"""
    factories = {
        'full_time': lambda: FullTimeEmployee(name, Decimal(str(kwargs['salary']))),
        'part_time': lambda: PartTimeEmployee(
            name, Decimal(str(kwargs['hourly_rate'])), kwargs['hours_worked']),
        'contractor': lambda: Contractor(
            name, Decimal(str(kwargs['daily_rate'])), kwargs['days_worked']),
        'intern': lambda: Intern(name, Decimal(str(kwargs.get('stipend', 0)))),
    }
    factory = factories.get(employee_type)
    if factory is None:
        raise ValueError(f"Unknown employee type: {employee_type}")
    return factory()

// Before: 関連するパラメータの群れが繰り返し登場
function searchProducts(
  query: string,
  minPrice: number,
  maxPrice: number,
  category: string,
  sortBy: string,
  sortOrder: 'asc' | 'desc',
  page: number,
  pageSize: number
): Product[] { /* ... */ }
 
function countProducts(
  query: string,
  minPrice: number,
  maxPrice: number,
  category: string
): number { /* ... */ }
 
function exportProducts(
  query: string,
  minPrice: number,
  maxPrice: number,
  category: string,
  format: 'csv' | 'json'
): Buffer { /* ... */ }
 
 
// After: パラメータオブジェクトに集約
interface ProductSearchCriteria {
  query: string;
  priceRange: PriceRange;
  category: string;
}
 
class PriceRange {
  constructor(
    readonly min: number,
    readonly max: number
  ) {
    if (min < 0) throw new Error("最小価格は0以上");
    if (max < min) throw new Error("最大価格は最小価格以上");
  }
 
  contains(price: number): boolean {
    return this.min <= price && price <= this.max;
  }
 
  static unbounded(): PriceRange {
    return new PriceRange(0, Number.MAX_SAFE_INTEGER);
  }
}
 
interface SortOptions {
  field: string;
  order: 'asc' | 'desc';
}
 
interface Pagination {
  page: number;
  pageSize: number;
 
  get offset(): number;
  get limit(): number;
}
 
function searchProducts(
  criteria: ProductSearchCriteria,
  sort: SortOptions,
  pagination: Pagination
): Product[] { /* ... */ }
 
function countProducts(criteria: ProductSearchCriteria): number { /* ... */ }
 
function exportProducts(
  criteria: ProductSearchCriteria,
  format: 'csv' | 'json'
): Buffer { /* ... */ }

# Before: 過度に細分化されたメソッド
class OrderValidator:
    def validate(self, order):
        if not self._has_items(order):
            raise ValidationError("商品なし")
        if not self._has_customer(order):
            raise ValidationError("顧客なし")
        if not self._is_positive_total(order):
            raise ValidationError("合計が不正")
 
    def _has_items(self, order) -> bool:
        return len(order.items) > 0        # メソッド名と本体が同じ意味
 
    def _has_customer(self, order) -> bool:
        return order.customer is not None   # メソッド名と本体が同じ意味
 
    def _is_positive_total(self, order) -> bool:
        return order.total > 0             # メソッド名と本体が同じ意味
 
 
# After: 不要な間接参照を排除
class OrderValidator:
    def validate(self, order):
        """注文の基本バリデーション"""
        if not order.items:
            raise ValidationError("商品が選択されていません")
        if order.customer is None:
            raise ValidationError("顧客情報がありません")
        if order.total <= 0:
            raise ValidationError("合計金額が不正です")
 
# ★ インライン化の判断基準:
#   - メソッドの本体がメソッド名と同じくらい明確
#   - メソッドが1箇所からしか呼ばれていない
#   - メソッドがただの委譲で、追加のロジックがない

# Before: User クラスが認証と住所の両方の責任を持つ
class User:
    def __init__(self, name, email, password_hash,
                 street, city, zip_code, country,
                 login_attempts, last_login, is_locked):
        self.name = name
        self.email = email
        self.password_hash = password_hash
        self.street = street
        self.city = city
        self.zip_code = zip_code
        self.country = country
        self.login_attempts = login_attempts
        self.last_login = last_login
        self.is_locked = is_locked
 
    def verify_password(self, password):
        return bcrypt.checkpw(password.encode(), self.password_hash)
 
    def record_login_attempt(self, success: bool):
        if success:
            self.login_attempts = 0
            self.last_login = datetime.now()
        else:
            self.login_attempts += 1
            if self.login_attempts >= 5:
                self.is_locked = True
 
    def format_address(self) -> str:
        return f"〒{self.zip_code} {self.city}{self.street}"
 
    def is_domestic(self) -> bool:
        return self.country == "日本"
 
    def calculate_shipping(self) -> Decimal:
        if self.is_domestic():
            return Decimal("500")
        return Decimal("2000")
 
 
# After: 責任ごとにクラスを分離
@dataclass(frozen=True)
class Address:
    """住所 ── 値オブジェクト"""
    street: str
    city: str
    zip_code: str
    country: str
 
    def format(self) -> str:
        return f"〒{self.zip_code} {self.city}{self.street}"
 
    def is_domestic(self) -> bool:
        return self.country == "日本"
 
    def calculate_shipping(self) -> Decimal:
        return Decimal("500") if self.is_domestic() else Decimal("2000")
 
 
class LoginSecurity:
    """認証セキュリティ ── ログイン試行の管理"""
    MAX_ATTEMPTS = 5
 
    def __init__(self, password_hash: bytes):
        self._password_hash = password_hash
        self._login_attempts = 0
        self._last_login: datetime | None = None
        self._is_locked = False
 
    def verify_password(self, password: str) -> bool:
        return bcrypt.checkpw(password.encode(), self._password_hash)
 
    def record_attempt(self, success: bool) -> None:
        if success:
            self._login_attempts = 0
            self._last_login = datetime.now()
        else:
            self._login_attempts += 1
            if self._login_attempts >= self.MAX_ATTEMPTS:
                self._is_locked = True
 
    @property
    def is_locked(self) -> bool:
        return self._is_locked
 
 
class User:
    """ユーザー ── 住所と認証を組み合わせる"""
    def __init__(self, name: str, email: str,
                 address: Address, security: LoginSecurity):
        self.name = name
        self.email = email
        self.address = address
        self.security = security

# Before: 一時変数で中間結果を保持
class ShoppingCart:
    def checkout_summary(self) -> str:
        subtotal = sum(item.price * item.quantity for item in self.items)
        discount = subtotal * Decimal("0.1") if subtotal > 10000 else Decimal("0")
        tax = (subtotal - discount) * Decimal("0.10")
        total = subtotal - discount + tax
 
        return (f"小計: {subtotal}, 割引: {discount}, "
                f"税: {tax}, 合計: {total}")
 
 
# After: 一時変数をメソッドに変換
class ShoppingCart:
    @property
    def subtotal(self) -> Decimal:
        """商品合計"""
        return sum(item.price * item.quantity for item in self.items)
 
    @property
    def discount(self) -> Decimal:
        """割引額: 1万円以上で10%"""
        return self.subtotal * Decimal("0.1") if self.subtotal > 10000 else Decimal("0")
 
    @property
    def tax(self) -> Decimal:
        """消費税"""
        return (self.subtotal - self.discount) * Decimal("0.10")
 
    @property
    def total(self) -> Decimal:
        """支払い合計"""
        return self.subtotal - self.discount + self.tax
 
    def checkout_summary(self) -> str:
        return (f"小計: {self.subtotal}, 割引: {self.discount}, "
                f"税: {self.tax}, 合計: {self.total}")
 
    # ★ 他のメソッドからも self.total 等を利用可能に
    def can_apply_coupon(self, min_amount: Decimal) -> bool:
        return self.subtotal >= min_amount

# Before: 複雑な条件式
def calculate_charge(date: date, quantity: int, rate: Decimal) -> Decimal:
    if (date.month >= 6 and date.month <= 9) or \
       (date.weekday() >= 5) or \
       (date in get_holidays(date.year)):
        # 夏季・週末・祝日料金
        charge = quantity * rate * Decimal("1.5")
        if quantity > 100:
            charge *= Decimal("0.9")
    else:
        # 通常料金
        charge = quantity * rate
        if quantity > 200:
            charge *= Decimal("0.95")
    return charge
 
 
# After: 条件と各ブランチを意図が明確なメソッドに分解
def calculate_charge(date: date, quantity: int, rate: Decimal) -> Decimal:
    if is_peak_season(date):
        return calculate_peak_charge(quantity, rate)
    return calculate_regular_charge(quantity, rate)
 
def is_peak_season(date: date) -> bool:
    """繁忙期: 夏季 or 週末 or 祝日"""
    return is_summer(date) or is_weekend(date) or is_holiday(date)
 
def is_summer(date: date) -> bool:
    return 6 <= date.month <= 9
 
def is_weekend(date: date) -> bool:
    return date.weekday() >= 5
 
def is_holiday(date: date) -> bool:
    return date in get_holidays(date.year)
 
def calculate_peak_charge(quantity: int, rate: Decimal) -> Decimal:
    """繁忙期料金: 1.5倍、100個超で10%割引"""
    charge = quantity * rate * Decimal("1.5")
    if quantity > 100:
        charge *= Decimal("0.9")
    return charge
 
def calculate_regular_charge(quantity: int, rate: Decimal) -> Decimal:
    """通常料金: 200個超で5%割引"""
    charge = quantity * rate
    if quantity > 200:
        charge *= Decimal("0.95")
    return charge

// Before: 同じメソッドが複数のサブクラスに重複
class SavingsAccount extends Account {
    public double calculateInterest() {
        return this.balance * this.interestRate / 12;  // 重複
    }
}
 
class CheckingAccount extends Account {
    public double calculateInterest() {
        return this.balance * this.interestRate / 12;  // 重複
    }
}
 
class MoneyMarketAccount extends Account {
    public double calculateInterest() {
        return this.balance * this.interestRate / 12;  // 重複
    }
}
 
 
// After: 共通メソッドを親クラスに引き上げ
abstract class Account {
    protected double balance;
    protected double interestRate;
 
    // Pull Up: 共通の計算を親クラスに
    public double calculateInterest() {
        return this.balance * this.interestRate / 12;
    }
}
 
// 特殊な計算が必要なサブクラスのみオーバーライド
class HighYieldAccount extends Account {
    @Override
    public double calculateInterest() {
        // 特殊なロジック: 段階金利
        if (this.balance > 1_000_000) {
            return this.balance * (this.interestRate * 1.5) / 12;
        }
        return super.calculateInterest();
    }
}

# Step 1: 現在のテスト状態を確認
$ pytest tests/ -q
42 passed in 3.2s
 
# Step 2: リファクタリング開始のコミット
$ git stash  # 作業中の変更を退避（もしあれば）
 
# Step 3: Extract Method を適用
# (IDE でコードを選択 → Ctrl+Alt+M → メソッド名入力)
 
# Step 4: テスト実行
$ pytest tests/ -q
42 passed in 3.1s  # OK: テスト数が変わっていない
 
# Step 5: コミット
$ git add -p  # 変更を確認しながらステージング
$ git commit -m "refactor: extract _calculate_discount from process_order"
 
# Step 6: 次の変更（Rename）
# (IDE でシンボルにカーソル → Shift+F6 → 新名前入力)
 
# Step 7: テスト実行
$ pytest tests/ -q
42 passed in 3.1s  # OK
 
# Step 8: コミット
$ git commit -am "refactor: rename 'calc' to 'calculate_monthly_revenue'"
 
# Step 9: 次の変更（Move Method）...
# 以降、同じサイクルを繰り返す

# 問題コード
def process_user_registration(data: dict) -> dict:
    # バリデーション
    errors = []
    if not data.get('name') or len(data['name']) < 2:
        errors.append("名前は2文字以上必須")
    if not data.get('email') or '@' not in data['email']:
        errors.append("有効なメールアドレスが必要")
    if not data.get('password') or len(data['password']) < 8:
        errors.append("パスワードは8文字以上必須")
    if data.get('password') and not any(c.isupper() for c in data['password']):
        errors.append("パスワードに大文字を含める必要")
    if data.get('password') and not any(c.isdigit() for c in data['password']):
        errors.append("パスワードに数字を含める必要")
    if errors:
        return {"success": False, "errors": errors}
 
    # ユーザー作成
    import hashlib
    salt = os.urandom(32)
    password_hash = hashlib.pbkdf2_hmac(
        'sha256', data['password'].encode(), salt, 100000
    )
    user = {
        "name": data['name'].strip(),
        "email": data['email'].lower().strip(),
        "password_hash": password_hash,
        "salt": salt,
        "created_at": datetime.now().isoformat(),
    }
 
    # DB保存
    db.execute("INSERT INTO users ...", user)
 
    # 歓迎メール送信
    email_body = f"""
    {user['name']} 様
    ご登録ありがとうございます。
    """
    send_email(user['email'], "ようこそ", email_body)
 
    return {"success": True, "user_id": user.get('id')}

class ShippingCalculator:
    def calculate(self, order) -> Decimal:
        # Feature Envy: order の内部データに過度に依存
        weight = sum(item.weight * item.quantity for item in order.items)
        destination = order.customer.address.country
 
        # Switch Statements: 配送方法による分岐
        if order.shipping_method == "standard":
            if destination == "日本":
                return Decimal("500") if weight < 5 else Decimal("1000")
            else:
                return Decimal("2000") if weight < 5 else Decimal("4000")
        elif order.shipping_method == "express":
            if destination == "日本":
                return Decimal("1200") if weight < 5 else Decimal("2000")
            else:
                return Decimal("5000") if weight < 5 else Decimal("8000")
        elif order.shipping_method == "overnight":
            if destination == "日本":
                return Decimal("2500")
            else:
                return Decimal("10000")

class ReportEngine:
    """500行のモノリシックなレポート生成エンジン"""
    def generate(self, report_type, data, format_type,
                 start_date, end_date, filters, sort_by,
                 include_charts, email_to, save_path):
        # Step 1: データフィルタリング (50行)
        # Step 2: 集計計算 (80行)
        # Step 3: チャート生成 (60行, include_charts の場合のみ)
        # Step 4: フォーマット変換 (100行, format_type による分岐)
        # Step 5: メール送信 (30行, email_to の場合のみ)
        # Step 6: ファイル保存 (30行, save_path の場合のみ)
        ...