// ❌ God Object の典型例
class ApplicationManager {
  // ユーザー管理
  private users: Map<string, User> = new Map();
  private sessions: Map<string, Session> = new Map();
 
  createUser(data: any) { /* ... */ }
  deleteUser(id: string) { /* ... */ }
  authenticateUser(email: string, password: string) { /* ... */ }
  updateUserProfile(id: string, profile: any) { /* ... */ }
  getUserPermissions(id: string) { /* ... */ }
 
  // 注文管理
  private orders: Map<string, Order> = new Map();
 
  createOrder(userId: string, items: any[]) { /* ... */ }
  cancelOrder(orderId: string) { /* ... */ }
  getOrderHistory(userId: string) { /* ... */ }
  updateOrderStatus(orderId: string, status: string) { /* ... */ }
 
  // 支払い管理
  processPayment(orderId: string, card: any) { /* ... */ }
  refundPayment(paymentId: string) { /* ... */ }
  getPaymentHistory(userId: string) { /* ... */ }
 
  // 通知管理
  sendEmail(to: string, body: string) { /* ... */ }
  sendSms(to: string, body: string) { /* ... */ }
  sendPushNotification(userId: string, message: string) { /* ... */ }
 
  // レポート
  generateMonthlyReport() { /* ... */ }
  generateUserReport(userId: string) { /* ... */ }
  generateSalesReport(from: Date, to: Date) { /* ... */ }
 
  // 設定管理
  getConfig(key: string) { /* ... */ }
  updateConfig(key: string, value: any) { /* ... */ }
 
  // キャッシュ管理
  clearCache() { /* ... */ }
  warmUpCache() { /* ... */ }
 
  // ... さらに100メソッド以上
}

// Phase 1: 責任の識別（コメントでグループ化）
 
// Phase 2: インターフェース抽出
interface IUserService {
  createUser(data: CreateUserDTO): Promise<User>;
  deleteUser(id: string): Promise<void>;
  authenticateUser(email: string, password: string): Promise<AuthResult>;
  updateUserProfile(id: string, profile: ProfileDTO): Promise<User>;
}
 
interface IOrderService {
  createOrder(userId: string, items: OrderItemDTO[]): Promise<Order>;
  cancelOrder(orderId: string): Promise<void>;
  getOrderHistory(userId: string): Promise<Order[]>;
}
 
interface IPaymentService {
  processPayment(orderId: string, card: CardDTO): Promise<PaymentResult>;
  refundPayment(paymentId: string): Promise<void>;
}
 
interface INotificationService {
  sendEmail(to: string, body: string): Promise<void>;
  sendSms(to: string, body: string): Promise<void>;
  sendPushNotification(userId: string, message: string): Promise<void>;
}
 
// Phase 3: クラス抽出
class UserService implements IUserService {
  constructor(
    private readonly userRepo: UserRepository,
    private readonly passwordHasher: PasswordHasher,
    private readonly eventBus: EventBus,
  ) {}
 
  async createUser(data: CreateUserDTO): Promise<User> {
    const hashedPassword = await this.passwordHasher.hash(data.password);
    const user = new User({
      email: Email.create(data.email),
      password: hashedPassword,
      name: data.name,
    });
    await this.userRepo.save(user);
    await this.eventBus.publish(new UserCreatedEvent(user.id));
    return user;
  }
 
  async deleteUser(id: string): Promise<void> {
    const user = await this.userRepo.findById(id);
    if (!user) throw new UserNotFoundError(id);
    await this.userRepo.delete(id);
    await this.eventBus.publish(new UserDeletedEvent(id));
  }
 
  async authenticateUser(email: string, password: string): Promise<AuthResult> {
    const user = await this.userRepo.findByEmail(email);
    if (!user) throw new AuthenticationError("Invalid credentials");
    const isValid = await this.passwordHasher.verify(password, user.password);
    if (!isValid) throw new AuthenticationError("Invalid credentials");
    return { userId: user.id, token: this.generateToken(user) };
  }
 
  async updateUserProfile(id: string, profile: ProfileDTO): Promise<User> {
    const user = await this.userRepo.findById(id);
    if (!user) throw new UserNotFoundError(id);
    user.updateProfile(profile);
    await this.userRepo.save(user);
    return user;
  }
 
  private generateToken(user: User): string {
    // JWT生成ロジック
    return "token";
  }
}
 
class OrderService implements IOrderService {
  constructor(
    private readonly orderRepo: OrderRepository,
    private readonly userService: IUserService,
    private readonly eventBus: EventBus,
  ) {}
 
  async createOrder(userId: string, items: OrderItemDTO[]): Promise<Order> {
    const order = Order.create(userId, items);
    await this.orderRepo.save(order);
    await this.eventBus.publish(new OrderCreatedEvent(order.id));
    return order;
  }
 
  async cancelOrder(orderId: string): Promise<void> {
    const order = await this.orderRepo.findById(orderId);
    if (!order) throw new OrderNotFoundError(orderId);
    order.cancel();
    await this.orderRepo.save(order);
    await this.eventBus.publish(new OrderCancelledEvent(orderId));
  }
 
  async getOrderHistory(userId: string): Promise<Order[]> {
    return this.orderRepo.findByUserId(userId);
  }
}
 
// Phase 4: 利用側の変更
// Before: const app = new ApplicationManager(); app.createUser(...);
// After:  直接各サービスを利用
class OrderController {
  constructor(
    private readonly orderService: IOrderService,
    private readonly paymentService: IPaymentService,
    private readonly notificationService: INotificationService,
  ) {}
 
  async placeOrder(req: Request): Promise<Response> {
    const order = await this.orderService.createOrder(req.userId, req.items);
    const payment = await this.paymentService.processPayment(order.id, req.card);
    await this.notificationService.sendEmail(req.userEmail, "注文完了");
    return { orderId: order.id, paymentId: payment.id };
  }
}

// ❌ Anemic Domain Model
class Order {
  id: string = "";
  items: OrderItem[] = [];
  status: string = "pending";
  totalPrice: number = 0;
  discount: number = 0;
  shippingAddress: string = "";
  createdAt: Date = new Date();
  // getter/setter だけ。ロジックなし
}
 
class OrderService {
  // 全てのロジックがサービスに
  calculateTotal(order: Order): number {
    order.totalPrice = order.items.reduce(
      (sum, item) => sum + item.price * item.quantity, 0
    );
    return order.totalPrice;
  }
 
  applyDiscount(order: Order, discountRate: number): void {
    // バリデーションがサービス側にある
    if (discountRate < 0 || discountRate > 0.5) {
      throw new Error("Invalid discount rate");
    }
    order.discount = order.totalPrice * discountRate;
    order.totalPrice -= order.discount;
  }
 
  canCancel(order: Order): boolean {
    return order.status === "pending" || order.status === "confirmed";
  }
 
  cancel(order: Order): void {
    if (!this.canCancel(order)) throw new Error("Cannot cancel");
    order.status = "cancelled";
  }
 
  validate(order: Order): string[] {
    const errors: string[] = [];
    if (order.items.length === 0) errors.push("商品が必要です");
    if (!order.shippingAddress) errors.push("配送先が必要です");
    if (order.totalPrice < 0) errors.push("合計金額が不正です");
    return errors;
  }
}
 
// 問題: 不正な状態を簡単に作れてしまう
const order = new Order();
order.status = "shipped";      // いきなり出荷済み？
order.totalPrice = -1000;      // 負の金額？
order.items = [];              // 商品なしで出荷済み？
// → 何のエラーも発生しない！

// ✅ Rich Domain Model
type OrderStatus = "pending" | "confirmed" | "shipped" | "delivered" | "cancelled";
 
class OrderId {
  constructor(private readonly value: string) {
    if (!value || value.length === 0) {
      throw new Error("OrderId cannot be empty");
    }
  }
  toString(): string { return this.value; }
  equals(other: OrderId): boolean { return this.value === other.value; }
}
 
class Order {
  private _items: OrderItem[] = [];
  private _status: OrderStatus = "pending";
  private _discount: Money = Money.zero("JPY");
  private _shippingAddress?: Address;
  private readonly _createdAt: Date = new Date();
 
  constructor(private readonly _id: OrderId) {}
 
  // ビジネスルールを持つメソッド
  addItem(item: OrderItem): void {
    if (this._status !== "pending") {
      throw new DomainError("確定済みの注文には追加できません");
    }
    const existing = this._items.find(i => i.productId === item.productId);
    if (existing) {
      existing.increaseQuantity(item.quantity);
    } else {
      this._items.push(item);
    }
  }
 
  removeItem(productId: string): void {
    if (this._status !== "pending") {
      throw new DomainError("確定済みの注文からは削除できません");
    }
    const index = this._items.findIndex(i => i.productId === productId);
    if (index === -1) throw new DomainError("商品が見つかりません");
    this._items.splice(index, 1);
  }
 
  // 計算ロジックがドメインオブジェクト内
  get subtotal(): Money {
    return this._items.reduce(
      (sum, item) => sum.add(item.totalPrice),
      Money.zero("JPY")
    );
  }
 
  get totalPrice(): Money {
    return this.subtotal.subtract(this._discount);
  }
 
  applyDiscount(coupon: Coupon): void {
    if (this._status !== "pending") {
      throw new DomainError("確定済みの注文に割引は適用できません");
    }
    if (!coupon.isValid()) {
      throw new DomainError("無効なクーポンです");
    }
    this._discount = coupon.calculateDiscount(this.subtotal);
  }
 
  setShippingAddress(address: Address): void {
    if (this._status === "shipped" || this._status === "delivered") {
      throw new DomainError("発送済みの注文の配送先は変更できません");
    }
    this._shippingAddress = address;
  }
 
  // 状態遷移を管理するメソッド
  confirm(): void {
    if (this._items.length === 0) {
      throw new DomainError("商品がない注文は確定できません");
    }
    if (!this._shippingAddress) {
      throw new DomainError("配送先が設定されていません");
    }
    if (this._status !== "pending") {
      throw new DomainError(`${this._status} の注文は確定できません`);
    }
    this._status = "confirmed";
  }
 
  ship(): void {
    if (this._status !== "confirmed") {
      throw new DomainError("確定済みの注文のみ発送できます");
    }
    this._status = "shipped";
  }
 
  deliver(): void {
    if (this._status !== "shipped") {
      throw new DomainError("発送済みの注文のみ配達完了にできます");
    }
    this._status = "delivered";
  }
 
  cancel(): void {
    if (this._status === "shipped" || this._status === "delivered") {
      throw new DomainError("発送済みの注文はキャンセルできません");
    }
    this._status = "cancelled";
  }
 
  get id(): OrderId { return this._id; }
  get status(): OrderStatus { return this._status; }
  get items(): ReadonlyArray<OrderItem> { return [...this._items]; }
  get createdAt(): Date { return this._createdAt; }
}
 
// → 不正な状態を作ることができない
// → ビジネスルールがオブジェクト内に集約
// → テストが明確（Orderだけテストすれば良い）

// ✅ Java での Rich Domain Model
public class BankAccount {
    private final AccountId id;
    private Money balance;
    private AccountStatus status;
    private final List<Transaction> transactions;
 
    private BankAccount(AccountId id, Money initialDeposit) {
        if (initialDeposit.isLessThan(Money.of(1000, "JPY"))) {
            throw new DomainException("最低入金額は1000円です");
        }
        this.id = id;
        this.balance = initialDeposit;
        this.status = AccountStatus.ACTIVE;
        this.transactions = new ArrayList<>();
        this.transactions.add(Transaction.initialDeposit(initialDeposit));
    }
 
    public static BankAccount open(AccountId id, Money initialDeposit) {
        return new BankAccount(id, initialDeposit);
    }
 
    public void deposit(Money amount) {
        ensureActive();
        if (amount.isLessThanOrEqual(Money.zero("JPY"))) {
            throw new DomainException("入金額は正の数である必要があります");
        }
        this.balance = this.balance.add(amount);
        this.transactions.add(Transaction.deposit(amount));
    }
 
    public void withdraw(Money amount) {
        ensureActive();
        if (amount.isLessThanOrEqual(Money.zero("JPY"))) {
            throw new DomainException("出金額は正の数である必要があります");
        }
        if (this.balance.isLessThan(amount)) {
            throw new InsufficientFundsException(this.balance, amount);
        }
        this.balance = this.balance.subtract(amount);
        this.transactions.add(Transaction.withdrawal(amount));
    }
 
    public void freeze() {
        ensureActive();
        this.status = AccountStatus.FROZEN;
    }
 
    public void close() {
        if (this.balance.isGreaterThan(Money.zero("JPY"))) {
            throw new DomainException("残高がある口座は閉鎖できません");
        }
        this.status = AccountStatus.CLOSED;
    }
 
    private void ensureActive() {
        if (this.status != AccountStatus.ACTIVE) {
            throw new DomainException("アクティブな口座でのみ操作可能です");
        }
    }
 
    // 不変条件が常に保証される
    public Money getBalance() { return this.balance; }
    public AccountStatus getStatus() { return this.status; }
    public List<Transaction> getTransactionHistory() {
        return Collections.unmodifiableList(this.transactions);
    }
}

// ❌ 深い継承
class BaseComponent { /* 基本機能 */ }
class StyledComponent extends BaseComponent { /* スタイル */ }
class InteractiveComponent extends StyledComponent { /* インタラクション */ }
class AnimatedComponent extends InteractiveComponent { /* アニメーション */ }
class AccessibleComponent extends AnimatedComponent { /* a11y */ }
class MyButton extends AccessibleComponent { /* ボタン */ }
 
// ✅ コンポジション + インターフェース
interface Stylable { applyStyles(styles: Styles): void; }
interface Interactive { onClick(handler: () => void): void; }
interface Animatable { animate(animation: Animation): void; }
interface Accessible { setAriaLabel(label: string): void; }
 
class StyleEngine implements Stylable {
  applyStyles(styles: Styles): void {
    // スタイル適用ロジック
  }
}
 
class AnimationEngine implements Animatable {
  animate(animation: Animation): void {
    // アニメーションロジック
  }
}
 
class AccessibilityManager implements Accessible {
  setAriaLabel(label: string): void {
    // ARIA属性設定ロジック
  }
}
 
class MyButton implements Stylable, Interactive, Animatable, Accessible {
  private styleEngine: StyleEngine;
  private animationEngine: AnimationEngine;
  private accessibilityManager: AccessibilityManager;
 
  constructor(deps: ButtonDeps) {
    this.styleEngine = deps.styleEngine;
    this.animationEngine = deps.animationEngine;
    this.accessibilityManager = deps.accessibilityManager;
  }
 
  applyStyles(styles: Styles): void {
    this.styleEngine.applyStyles(styles);
  }
 
  onClick(handler: () => void): void {
    // クリックイベント処理
  }
 
  animate(animation: Animation): void {
    this.animationEngine.animate(animation);
  }
 
  setAriaLabel(label: string): void {
    this.accessibilityManager.setAriaLabel(label);
  }
}

# ❌ 深い単一継承
class BaseModel:
    def save(self): pass
 
class TimestampedModel(BaseModel):
    created_at: datetime
    updated_at: datetime
 
class SoftDeletableModel(TimestampedModel):
    deleted_at: datetime | None = None
 
    def soft_delete(self):
        self.deleted_at = datetime.now()
 
class AuditableModel(SoftDeletableModel):
    created_by: str
    updated_by: str
 
class VersionedModel(AuditableModel):
    version: int = 1
 
class Product(VersionedModel):  # 5段階の継承！
    name: str
    price: float
 
 
# ✅ Mixin パターン
class TimestampMixin:
    """タイムスタンプ機能"""
    created_at: datetime
    updated_at: datetime
 
    def touch(self):
        self.updated_at = datetime.now()
 
class SoftDeleteMixin:
    """論理削除機能"""
    deleted_at: datetime | None = None
 
    def soft_delete(self):
        self.deleted_at = datetime.now()
 
    @property
    def is_deleted(self) -> bool:
        return self.deleted_at is not None
 
class AuditMixin:
    """監査ログ機能"""
    created_by: str
    updated_by: str
 
class VersionMixin:
    """バージョニング機能"""
    version: int = 1
 
    def increment_version(self):
        self.version += 1
 
class BaseModel:
    """基底モデル"""
    def save(self): pass
 
class Product(BaseModel, TimestampMixin, SoftDeleteMixin, AuditMixin, VersionMixin):
    """必要な機能だけをMixinで組み合わせ（継承は1段階）"""
    name: str
    price: float
 
# 別のモデルには異なる組み合わせ
class LogEntry(BaseModel, TimestampMixin):
    """ログエントリ: タイムスタンプだけ必要"""
    message: str
    level: str

// ❌ 循環依存の例
// user.ts
import { Order } from "./order";
 
class User {
  orders: Order[] = [];
 
  getActiveOrders(): Order[] {
    return this.orders.filter(o => o.isActive());
  }
 
  getTotalSpent(): number {
    return this.orders.reduce((sum, o) => sum + o.totalPrice, 0);
  }
}
 
// order.ts
import { User } from "./user";  // ← 循環依存！
 
class Order {
  user: User;
  items: OrderItem[] = [];
 
  isActive(): boolean {
    return this.status !== "cancelled";
  }
 
  get totalPrice(): number {
    return this.items.reduce((sum, i) => sum + i.price * i.quantity, 0);
  }
 
  // User の情報を使うメソッド
  getShippingAddress(): Address {
    return this.user.defaultAddress;  // User に依存
  }
}

// ✅ 解決策1: インターフェースの導入（依存性逆転）
// interfaces.ts（共通モジュール）
interface IUser {
  id: string;
  defaultAddress: Address;
}
 
interface IOrder {
  isActive(): boolean;
  totalPrice: number;
}
 
// user.ts
import { IOrder } from "./interfaces";
 
class User implements IUser {
  private orders: IOrder[] = [];  // インターフェースに依存
 
  getActiveOrders(): IOrder[] {
    return this.orders.filter(o => o.isActive());
  }
}
 
// order.ts
import { IUser } from "./interfaces";
 
class Order implements IOrder {
  private userId: string;  // User オブジェクトではなく ID で参照
 
  constructor(private readonly userProvider: (id: string) => IUser) {}
 
  getShippingAddress(): Address {
    const user = this.userProvider(this.userId);
    return user.defaultAddress;
  }
}

// ✅ 解決策2: 中間モジュールの導入
// user.ts - User は Order を知らない
class User {
  id: string;
  defaultAddress: Address;
}
 
// order.ts - Order は User を知らない
class Order {
  userId: string;
  items: OrderItem[] = [];
 
  get totalPrice(): number {
    return this.items.reduce((sum, i) => sum + i.price * i.quantity, 0);
  }
}
 
// user-order-service.ts - 両方を知る仲介者
import { User } from "./user";
import { Order } from "./order";
 
class UserOrderService {
  constructor(
    private userRepo: UserRepository,
    private orderRepo: OrderRepository,
  ) {}
 
  async getUserActiveOrders(userId: string): Promise<Order[]> {
    const orders = await this.orderRepo.findByUserId(userId);
    return orders.filter(o => o.isActive());
  }
 
  async getOrderShippingAddress(orderId: string): Promise<Address> {
    const order = await this.orderRepo.findById(orderId);
    const user = await this.userRepo.findById(order.userId);
    return user.defaultAddress;
  }
}

// ✅ 解決策3: イベント駆動アーキテクチャ
// user.ts
class User {
  deactivate(eventBus: EventBus): void {
    this.status = "inactive";
    eventBus.publish(new UserDeactivatedEvent(this.id));
  }
}
 
// order.ts - User を直接参照しない
class OrderEventHandler {
  constructor(private orderRepo: OrderRepository) {}
 
  @EventListener(UserDeactivatedEvent)
  async onUserDeactivated(event: UserDeactivatedEvent): Promise<void> {
    const orders = await this.orderRepo.findActiveByUserId(event.userId);
    for (const order of orders) {
      order.cancel();
      await this.orderRepo.save(order);
    }
  }
}

// ❌ Feature Envy: InvoiceGenerator が Customer のデータばかり使っている
class InvoiceGenerator {
  generateGreeting(customer: Customer): string {
    // customer のデータを4回も使っている → Feature Envy
    if (customer.getType() === "premium") {
      return `${customer.getTitle()} ${customer.getLastName()} 様、` +
             `いつもご利用ありがとうございます。`;
    }
    return `${customer.getFirstName()} ${customer.getLastName()} 様`;
  }
 
  calculateDiscount(customer: Customer, amount: number): number {
    // またもや customer のデータばかり
    if (customer.getType() === "premium") {
      return amount * customer.getDiscountRate();
    }
    if (customer.getYearsAsCustomer() > 5) {
      return amount * 0.05;
    }
    return 0;
  }
}
 
// ✅ リファクタリング: ロジックをデータのあるクラスに移動
class Customer {
  private type: CustomerType;
  private title: string;
  private firstName: string;
  private lastName: string;
  private discountRate: number;
  private registeredAt: Date;
 
  getGreeting(): string {
    if (this.type === "premium") {
      return `${this.title} ${this.lastName} 様、いつもご利用ありがとうございます。`;
    }
    return `${this.firstName} ${this.lastName} 様`;
  }
 
  calculateDiscount(amount: number): number {
    if (this.type === "premium") {
      return amount * this.discountRate;
    }
    if (this.yearsAsCustomer > 5) {
      return amount * 0.05;
    }
    return 0;
  }
 
  private get yearsAsCustomer(): number {
    return new Date().getFullYear() - this.registeredAt.getFullYear();
  }
}
 
class InvoiceGenerator {
  generateInvoice(customer: Customer, items: InvoiceItem[]): Invoice {
    const subtotal = this.calculateSubtotal(items);
    const discount = customer.calculateDiscount(subtotal);
    return new Invoice({
      greeting: customer.getGreeting(),
      items,
      subtotal,
      discount,
      total: subtotal - discount,
    });
  }
 
  private calculateSubtotal(items: InvoiceItem[]): number {
    return items.reduce((sum, item) => sum + item.price * item.quantity, 0);
  }
}

// ❌ 税率計算が散在
class Order {
  calculateTax(): number {
    return this.subtotal * 0.10;  // ← ハードコード
  }
}
 
class Invoice {
  getTaxAmount(): number {
    return this.amount * 0.10;  // ← 同じ値がここにも
  }
}
 
class Cart {
  estimateTax(): number {
    return this.total * 0.10;  // ← ここにも
  }
}
 
class SalesReport {
  calculateTaxTotal(): number {
    return this.sales.reduce((sum, s) => sum + s.amount * 0.10, 0);  // ← ここにも
  }
}
 
 
// ✅ 税率計算を一箇所に集約
class TaxCalculator {
  private static readonly STANDARD_RATE = 0.10;
  private static readonly REDUCED_RATE = 0.08;  // 軽減税率
 
  static calculate(amount: number, type: TaxType = "standard"): number {
    const rate = type === "reduced"
      ? TaxCalculator.REDUCED_RATE
      : TaxCalculator.STANDARD_RATE;
    return Math.floor(amount * rate);
  }
 
  static getRate(type: TaxType = "standard"): number {
    return type === "reduced"
      ? TaxCalculator.REDUCED_RATE
      : TaxCalculator.STANDARD_RATE;
  }
}
 
class Order {
  calculateTax(): number {
    return TaxCalculator.calculate(this.subtotal);
  }
}
 
class Invoice {
  getTaxAmount(): number {
    return TaxCalculator.calculate(this.amount);
  }
}
 
// → 税率変更時は TaxCalculator だけ修正すれば OK

// ❌ Primitive Obsession
function createUser(
  name: string,
  email: string,
  phone: string,
  age: number,
  zipCode: string,
): void {
  // name, email, phone, zipCode は全て string
  // 引数の順番を間違えてもコンパイルエラーにならない！
  // createUser("test@email.com", "John Doe", "100-0001", 25, "090-1234-5678")
  //            ↑ email と name が逆！でもコンパイル通る
}
 
function sendEmail(to: string, subject: string, body: string): void {
  // to が有効なメールアドレスか検証が必要...毎回
  if (!to.match(/^[^\s@]+@[^\s@]+\.[^\s@]+$/)) {
    throw new Error(`Invalid email: ${to}`);
  }
  // ...
}
 
// ✅ 値オブジェクトで型安全に
class Email {
  private constructor(private readonly value: string) {}
 
  static create(value: string): Email {
    const trimmed = value.trim().toLowerCase();
    if (!trimmed.match(/^[^\s@]+@[^\s@]+\.[^\s@]+$/)) {
      throw new InvalidEmailError(value);
    }
    return new Email(trimmed);
  }
 
  get domain(): string {
    return this.value.split("@")[1];
  }
 
  toString(): string { return this.value; }
  equals(other: Email): boolean { return this.value === other.value; }
}
 
class PhoneNumber {
  private constructor(private readonly value: string) {}
 
  static create(value: string): PhoneNumber {
    const normalized = value.replace(/[-\s()]/g, "");
    if (!normalized.match(/^0\d{9,10}$/)) {
      throw new InvalidPhoneNumberError(value);
    }
    return new PhoneNumber(normalized);
  }
 
  get formatted(): string {
    // 090-1234-5678 形式
    if (this.value.length === 11) {
      return `${this.value.slice(0,3)}-${this.value.slice(3,7)}-${this.value.slice(7)}`;
    }
    return this.value;
  }
 
  toString(): string { return this.value; }
  equals(other: PhoneNumber): boolean { return this.value === other.value; }
}
 
class Money {
  constructor(
    public readonly amount: number,
    public readonly currency: "JPY" | "USD" | "EUR",
  ) {
    if (!Number.isFinite(amount)) throw new Error("金額は有限の数値");
    if (amount < 0) throw new Error("金額は0以上");
    if (currency === "JPY" && !Number.isInteger(amount)) {
      throw new Error("日本円は整数のみ");
    }
  }
 
  add(other: Money): Money {
    this.ensureSameCurrency(other);
    return new Money(this.amount + other.amount, this.currency);
  }
 
  subtract(other: Money): Money {
    this.ensureSameCurrency(other);
    const result = this.amount - other.amount;
    if (result < 0) throw new Error("金額が負になります");
    return new Money(result, this.currency);
  }
 
  multiply(factor: number): Money {
    return new Money(
      this.currency === "JPY"
        ? Math.floor(this.amount * factor)
        : Math.round(this.amount * factor * 100) / 100,
      this.currency,
    );
  }
 
  isGreaterThan(other: Money): boolean {
    this.ensureSameCurrency(other);
    return this.amount > other.amount;
  }
 
  private ensureSameCurrency(other: Money): void {
    if (this.currency !== other.currency) {
      throw new CurrencyMismatchError(this.currency, other.currency);
    }
  }
 
  static zero(currency: "JPY" | "USD" | "EUR"): Money {
    return new Money(0, currency);
  }
 
  toString(): string {
    if (this.currency === "JPY") return `¥${this.amount.toLocaleString()}`;
    if (this.currency === "USD") return `$${this.amount.toFixed(2)}`;
    return `€${this.amount.toFixed(2)}`;
  }
}
 
class ZipCode {
  private constructor(private readonly value: string) {}
 
  static create(value: string): ZipCode {
    const normalized = value.replace(/-/g, "");
    if (!normalized.match(/^\d{7}$/)) {
      throw new Error(`Invalid zip code: ${value}`);
    }
    return new ZipCode(normalized);
  }
 
  get formatted(): string {
    return `${this.value.slice(0,3)}-${this.value.slice(3)}`;
  }
 
  toString(): string { return this.value; }
}
 
// 値オブジェクトを使った関数
function createUser(
  name: UserName,
  email: Email,
  phone: PhoneNumber,
  age: Age,
  zipCode: ZipCode,
): void {
  // 引数の順番を間違えたらコンパイルエラー！
  // 各値は生成時にバリデーション済み
}
 
function sendEmail(to: Email, subject: string, body: string): void {
  // to は必ず有効なメールアドレス。バリデーション不要！
}

from dataclasses import dataclass
from typing import Self
import re
 
# ✅ Python での値オブジェクト（dataclass + __post_init__）
@dataclass(frozen=True)  # frozen=True で不変に
class Email:
    value: str
 
    def __post_init__(self):
        normalized = self.value.strip().lower()
        if not re.match(r'^[^\s@]+@[^\s@]+\.[^\s@]+$', normalized):
            raise ValueError(f"Invalid email: {self.value}")
        # frozen=True でも __post_init__ では object.__setattr__ が使える
        object.__setattr__(self, 'value', normalized)
 
    @property
    def domain(self) -> str:
        return self.value.split('@')[1]
 
    def __str__(self) -> str:
        return self.value
 
 
@dataclass(frozen=True)
class Money:
    amount: int  # 最小単位（日本円なら1円単位）
    currency: str
 
    def __post_init__(self):
        if self.amount < 0:
            raise ValueError("金額は0以上である必要があります")
        if self.currency not in ("JPY", "USD", "EUR"):
            raise ValueError(f"未対応の通貨: {self.currency}")
 
    def add(self, other: Self) -> Self:
        if self.currency != other.currency:
            raise ValueError(f"通貨が異なります: {self.currency} vs {other.currency}")
        return Money(self.amount + other.amount, self.currency)
 
    def subtract(self, other: Self) -> Self:
        if self.currency != other.currency:
            raise ValueError(f"通貨が異なります")
        return Money(self.amount - other.amount, self.currency)
 
    def multiply(self, factor: float) -> Self:
        return Money(int(self.amount * factor), self.currency)
 
    @classmethod
    def zero(cls, currency: str) -> Self:
        return cls(0, currency)
 
    def __str__(self) -> str:
        if self.currency == "JPY":
            return f"¥{self.amount:,}"
        return f"{self.currency} {self.amount / 100:.2f}"
 
 
# 使用例
email = Email("User@Example.COM")
print(email)         # user@example.com
print(email.domain)  # example.com
 
price = Money(1000, "JPY")
tax = price.multiply(0.10)
total = price.add(tax)
print(total)  # ¥1,100

// Java 16+ の record を使った値オブジェクト
public record Email(String value) {
    public Email {
        // Compact constructor でバリデーション
        value = value.trim().toLowerCase();
        if (!value.matches("^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$")) {
            throw new IllegalArgumentException("Invalid email: " + value);
        }
    }
 
    public String domain() {
        return value.split("@")[1];
    }
}
 
public record Money(long amount, Currency currency) {
    public Money {
        if (amount < 0) {
            throw new IllegalArgumentException("Amount must be non-negative");
        }
        Objects.requireNonNull(currency, "Currency must not be null");
    }
 
    public Money add(Money other) {
        ensureSameCurrency(other);
        return new Money(this.amount + other.amount, this.currency);
    }
 
    public Money subtract(Money other) {
        ensureSameCurrency(other);
        return new Money(this.amount - other.amount, this.currency);
    }
 
    private void ensureSameCurrency(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new IllegalArgumentException("Currency mismatch");
        }
    }
 
    public static Money zero(Currency currency) {
        return new Money(0, currency);
    }
}

// ❌ Singleton の誤用
class Database {
  private static instance: Database;
  private connection: Connection;
 
  private constructor() {
    this.connection = createConnection(/* ... */);
  }
 
  static getInstance(): Database {
    if (!Database.instance) {
      Database.instance = new Database();
    }
    return Database.instance;
  }
 
  query(sql: string): Promise<any[]> {
    return this.connection.query(sql);
  }
}
 
// 利用側 - 隠れた依存
class UserRepository {
  async findById(id: string): Promise<User | null> {
    // Database への依存がコンストラクタに表れない！
    const db = Database.getInstance();
    const rows = await db.query(`SELECT * FROM users WHERE id = '${id}'`);
    return rows[0] ? this.toUser(rows[0]) : null;
  }
}
 
// テスト時の問題
// UserRepository をテストするのに、実際のDBが必要になる
// Database.getInstance() をモック化するのが困難
 
 
// ✅ 依存性注入で解決
interface IDatabase {
  query(sql: string): Promise<any[]>;
}
 
class Database implements IDatabase {
  constructor(private connection: Connection) {}
 
  async query(sql: string): Promise<any[]> {
    return this.connection.query(sql);
  }
}
 
class UserRepository {
  // 依存が明示的
  constructor(private readonly db: IDatabase) {}
 
  async findById(id: string): Promise<User | null> {
    const rows = await this.db.query(`SELECT * FROM users WHERE id = ?`, [id]);
    return rows[0] ? this.toUser(rows[0]) : null;
  }
}
 
// テスト時 - モックを簡単に注入できる
class MockDatabase implements IDatabase {
  private mockData: Map<string, any[]> = new Map();
 
  setMockResult(sql: string, result: any[]): void {
    this.mockData.set(sql, result);
  }
 
  async query(sql: string): Promise<any[]> {
    return this.mockData.get(sql) || [];
  }
}
 
const mockDb = new MockDatabase();
const repo = new UserRepository(mockDb);  // テスト用DBを注入

// ❌ Poltergeist: 何もしていないクラス
class OrderProcessor {
  private orderService: OrderService;
  private paymentService: PaymentService;
  private emailService: EmailService;
 
  processOrder(order: Order): void {
    this.orderService.validate(order);    // 委譲するだけ
    this.paymentService.charge(order);    // 委譲するだけ
    this.emailService.sendConfirmation(order);  // 委譲するだけ
  }
}
 
// ✅ 解決策1: Poltergeist を削除し、直接呼び出す
// （ワークフローが単純な場合）
async function processOrder(
  order: Order,
  orderService: OrderService,
  paymentService: PaymentService,
  emailService: EmailService,
): Promise<void> {
  await orderService.validate(order);
  await paymentService.charge(order);
  await emailService.sendConfirmation(order);
}
 
// ✅ 解決策2: 付加価値のあるオーケストレーター
// （エラーハンドリングやトランザクション管理など、自身のロジックがある場合は正当）
class OrderWorkflow {
  constructor(
    private orderService: OrderService,
    private paymentService: PaymentService,
    private emailService: EmailService,
    private logger: Logger,
  ) {}
 
  async execute(order: Order): Promise<OrderResult> {
    this.logger.info(`Processing order ${order.id}`);
 
    // バリデーション
    const validationResult = await this.orderService.validate(order);
    if (!validationResult.isValid) {
      this.logger.warn(`Order ${order.id} validation failed`, validationResult.errors);
      return OrderResult.failure(validationResult.errors);
    }
 
    // 支払い（リトライ付き）
    let paymentResult: PaymentResult;
    try {
      paymentResult = await this.retryWithBackoff(
        () => this.paymentService.charge(order),
        3,
      );
    } catch (error) {
      this.logger.error(`Payment failed for order ${order.id}`, error);
      await this.orderService.markAsFailed(order.id);
      return OrderResult.paymentFailed(error);
    }
 
    // 確認メール（失敗しても注文は成功）
    try {
      await this.emailService.sendConfirmation(order);
    } catch (error) {
      this.logger.warn(`Email sending failed for order ${order.id}`, error);
      // メール失敗は注文の失敗にはしない
    }
 
    return OrderResult.success(order.id, paymentResult.transactionId);
  }
 
  private async retryWithBackoff<T>(
    fn: () => Promise<T>,
    maxRetries: number,
  ): Promise<T> {
    // リトライロジック
    for (let i = 0; i < maxRetries; i++) {
      try {
        return await fn();
      } catch (error) {
        if (i === maxRetries - 1) throw error;
        await this.delay(Math.pow(2, i) * 1000);
      }
    }
    throw new Error("Unreachable");
  }
 
  private delay(ms: number): Promise<void> {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

// ❌ Lava Flow の例
class OrderProcessor {
  // TODO: refactor this (2019-03-15)
  process(order: Order): void {
    // ...
  }
 
  // 旧バージョン（移行完了後に削除予定）
  // processOld(order: Order): void {
  //   const tax = order.total * 0.08;  // 旧税率
  //   // ... 200行のコメントアウト
  // }
 
  // processV2 もある...
  processV2(order: Order): void {
    // "一時的な" 修正（3年前）
    if (order.type === "legacy") {
      return this.processLegacy(order);
    }
    // ...
  }
 
  // 誰が使っているか不明
  private processLegacy(order: Order): void {
    // 2020年のシステム移行時のコード
    // 今も使われている？ 不明...
  }
}

class AppController {
  // ユーザー認証
  login(email: string, password: string): Token { /* ... */ }
  logout(token: string): void { /* ... */ }
  refreshToken(token: string): Token { /* ... */ }
 
  // プロフィール管理
  getProfile(userId: string): Profile { /* ... */ }
  updateProfile(userId: string, data: any): void { /* ... */ }
  uploadAvatar(userId: string, file: File): string { /* ... */ }
 
  // 商品管理
  listProducts(filter: any): Product[] { /* ... */ }
  getProduct(id: string): Product { /* ... */ }
  searchProducts(query: string): Product[] { /* ... */ }
 
  // カート管理
  addToCart(userId: string, productId: string): void { /* ... */ }
  removeFromCart(userId: string, productId: string): void { /* ... */ }
  getCart(userId: string): Cart { /* ... */ }
 
  // 注文
  checkout(userId: string): Order { /* ... */ }
  getOrderHistory(userId: string): Order[] { /* ... */ }
 
  // 管理者機能
  getSystemStats(): Stats { /* ... */ }
  generateReport(type: string): Report { /* ... */ }
}

class Subscription {
  plan: "free" | "basic" | "premium" = "free";
  startDate: Date = new Date();
  endDate: Date | null = null;
  isCancelled: boolean = false;
  paymentMethod: string | null = null;
}
 
class SubscriptionService {
  upgrade(sub: Subscription, newPlan: string): void {
    if (sub.isCancelled) throw new Error("Cancelled");
    if (newPlan === "free") throw new Error("Cannot downgrade to free");
    sub.plan = newPlan as any;
  }
 
  cancel(sub: Subscription): void {
    if (sub.isCancelled) throw new Error("Already cancelled");
    sub.isCancelled = true;
    sub.endDate = new Date();
  }
 
  isActive(sub: Subscription): boolean {
    return !sub.isCancelled &&
           (sub.endDate === null || sub.endDate > new Date());
  }
}