// 重構前：驗證 IP 地址
public boolean isValidIp(String ip) {
    // 使用正則表達式
    return ip.matches("^\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}$");
}

// 重構後：使用更清晰的邏輯
public boolean isValidIp(String ip) {
    String[] parts = ip.split("\\.");
    if (parts.length != 4) return false;
    for (String part : parts) {
        int value = Integer.parseInt(part);
        if (value < 0 || value > 255) return false;
    }
    return true;
}

// 單元測試確保行為一致
@Test
void testValidIp() {
    assertTrue(isValidIp("192.168.1.1"));
    assertTrue(isValidIp("0.0.0.0"));
    assertTrue(isValidIp("255.255.255.255"));
    assertFalse(isValidIp("256.1.1.1"));
    assertFalse(isValidIp("1.2.3"));
}

public class Transaction {
    public boolean execute(String id, Long buyerId) {
        // 直接 new 物件，無法替換為 mock
        User buyer = new UserRepo().getUser(buyerId);
        // 直接呼叫靜態方法
        if (!IdGenerator.isValid(id)) {
            return false;
        }
        // 使用全域變數
        if (Runtime.getRuntime().freeMemory() < 1024) {
            return false;
        }
        return true;
    }
}

public class Transaction {
    private UserRepo userRepo;
    private IdValidator idValidator;
    private MemoryChecker memoryChecker;

    // 依賴注入
    public Transaction(UserRepo userRepo,
                       IdValidator idValidator,
                       MemoryChecker memoryChecker) {
        this.userRepo = userRepo;
        this.idValidator = idValidator;
        this.memoryChecker = memoryChecker;
    }

    public boolean execute(String id, Long buyerId) {
        User buyer = userRepo.getUser(buyerId);
        if (!idValidator.isValid(id)) {
            return false;
        }
        if (!memoryChecker.hasEnoughMemory()) {
            return false;
        }
        return true;
    }
}

// 耦合：直接使用實作類別
RedisClient client = new RedisClient();

// 解耦：使用介面
Cache cache = new RedisCache();

// 耦合：模組 A 直接依賴模組 B
A -> B

// 解耦：通過介面層
A -> Interface <- B

// 耦合：內部創建依賴
class OrderService {
    private UserService userService = new UserService();
}

// 解耦：外部注入依賴
class OrderService {
    private UserService userService;
    public OrderService(UserService userService) {
        this.userService = userService;
    }
}

// 耦合：直接呼叫
orderService.createOrder();
paymentService.processPayment();
inventoryService.reduceStock();

// 解耦：發布事件
eventBus.publish(new OrderCreatedEvent());
// 各服務訂閱事件自行處理

// 過度設計：為了可能的擴展引入工廠 + 策略
interface PaymentStrategy { }
class PaymentStrategyFactory { }
class WechatPaymentStrategy implements PaymentStrategy { }
class AlipayPaymentStrategy implements PaymentStrategy { }

// 簡單直觀：目前只有一種支付方式
class PaymentService {
    void pay(Order order) {
        wechatApi.pay(order);
    }
}
// 等需要多種支付方式時再重構

// 不知道正確輸出該是什麼，就先讓測試告訴你目前輸出
@Test
void characterize() {
    String actual = legacyReport(sampleInput);
    // 先填一個猜的值，跑一次，把實際輸出貼回來
    assertEquals("PASTE_ACTUAL_OUTPUT_HERE", actual);
}

// 沒有接縫：依賴寫死在內部，無從替換
class OrderService {
    boolean place(Order o) {
        return new PaymentGateway().charge(o); // 寫死
    }
}

// 開出物件接縫：注入依賴，測試可傳替身
class OrderService {
    private final PaymentGateway gateway;
    OrderService(PaymentGateway gateway) { this.gateway = gateway; }

    boolean place(Order o) {
        return gateway.charge(o);
    }
}

// 舊方法又長又難測，但新規則可以「抽芽」成獨立方法
class Invoice {
    void post() {
        // ...原有大量難測邏輯...
        applyLateFee(entries); // 新增：呼叫抽芽出來的新方法
        // ...原有邏輯...
    }

    // 新方法乾淨、無糾纏依賴，可直接單元測試
    List<Entry> applyLateFee(List<Entry> entries) {
        // 新規則的純邏輯
        return ...;
    }
}