// Bad: too vague, tells us nothing
throw new IllegalArgumentException("Invalid ID");

// Good: includes What (ID format error), Where (User update),
//       Why (too short) and Offending Value
throw new IllegalArgumentException(
    String.format("Failed to update user: ID '%s' is too short. Expected at least 8 chars.", userId)
);

// Boundary crossing: clear error message for API callers
if (input == null) {
    throw new IllegalArgumentException(
        "Request payload cannot be null at OrderService.createOrder()");
}

// Async scenario: no immediate Stack trace available, must carry its own context
CompletableFuture.runAsync(() -> {
    if (dbConnection == null) {
        throw new IllegalStateException(
            "Database connection lost during background batch processing");
    }
});

// Validation failure: include the offending value
if (email != null && !email.contains("@")) {
    throw new ValidationException(
        String.format("Invalid email format: '%s' does not contain '@'", email));
}

// Bad: leaking internals and meaningless info
try {
    // ...
} catch (Exception e) {
    throw new RuntimeException(
        "Something went wrong at com.myapp.internal.UserDAO.findById(): "
        + "SELECT * FROM users WHERE password = '" + password + "'", e);
}

// Good: Catch specific exceptions
try {
    processPayment(orderId);
} catch (PaymentNetworkException e) {
    // Retry or fallback
    handleNetworkFailure(orderId);
} catch (InsufficientFundsException e) {
    // Alert the user
    notifyUserInsufficientFunds(orderId);
}

// Bad: Catch generic Exception
try {
    processPayment(orderId);
} catch (Exception e) {
    // We don't know what actually went wrong!
    log.error("Something went wrong");
}

public void handleExceptionFates() {
    // 1. Propagate: Rethrow as-is
    try {
        doSomethingRisky();
    } catch (SpecificException e) {
        throw e;
    }

    // 2. Translate: Wrap with context
    try {
        readConfigFile();
    } catch (IOException e) {
        // Wrap the original exception to preserve stack trace
        throw new ConfigurationLoadException("Failed to load app.yml", e);
    }

    // 3. Swallow: Ignore safely
    try {
        closeResource();
    } catch (IOException e) {
        // Ignored intentionally: resource is already closing
        log.debug("Resource close failed, safe to ignore", e);
    }
}

public void badPractices() throws Exception {
    // Anti-pattern 1: Empty catch block
    try {
        Files.readString(Path.of("data.txt"));
    } catch (IOException e) {
        // Nothing here... the error vanishes into thin air
    }

    // Anti-pattern 2: Log-and-rethrow
    try {
        connectToDatabase();
    } catch (SQLException e) {
        // This causes duplicate logs when the caller also logs it
        log.error("Database connection failed", e);
        throw e;
    }

    // Anti-pattern 3: Swallowing at the wrong layer
    try {
        validateUser(userId);
    } catch (ValidationException e) {
        // Swallowed! The caller thinks validation passed!
        log.warn("Validation failed");
    }
}

public class BadOrderService {
    public void processOrder(String orderId) {
        try {
            Order order = findOrder(orderId);
            chargePayment(order);
            sendConfirmation(order);
        } catch (Exception e) {
            // Anti-pattern: catch-all at the wrong layer
            // Anti-pattern: log-and-rethrow
            log.error("Error", e);
            throw new RuntimeException("Something went wrong");
        }
    }

    private Order findOrder(String orderId) {
        try {
            return orderRepository.findById(orderId);
        } catch (SQLException e) {
            // Anti-pattern: swallowing at the wrong layer
            return null;
        }
    }

    private void chargePayment(Order order) {
        if (order == null) {
            // Anti-pattern: meaningless message
            throw new RuntimeException("error");
        }
        paymentGateway.charge(order.getAmount());
    }
}

public class OrderService {
    public void processOrder(String orderId) {
        // Application Boundary: catch specific exceptions, translate to response
        try {
            Order order = findOrder(orderId);
            chargePayment(order);
            sendConfirmation(order);
        } catch (OrderNotFoundException e) {
            // Translate: convert to user-facing response
            throw new ApiException(HttpStatus.NOT_FOUND, e.getMessage(), e);
        } catch (PaymentFailedException e) {
            throw new ApiException(HttpStatus.PAYMENT_REQUIRED, e.getMessage(), e);
        }
    }

    private Order findOrder(String orderId) {
        // Infrastructure Boundary: map external error to domain error
        try {
            return orderRepository.findById(orderId);
        } catch (SQLException e) {
            throw new OrderNotFoundException(
                String.format("Order '%s' not found or database unavailable", orderId), e);
        }
    }

    private void chargePayment(Order order) {
        // Domain Layer: validate and throw with context
        if (order.getAmount() <= 0) {
            throw new IllegalArgumentException(
                String.format("Cannot charge non-positive amount %d for order '%s'",
                    order.getAmount(), order.getId()));
        }
        try {
            paymentGateway.charge(order.getAmount());
        } catch (PaymentGatewayException e) {
            throw new PaymentFailedException(
                String.format("Payment of %d failed for order '%s': %s",
                    order.getAmount(), order.getId(), e.getMessage()), e);
        }
    }
}