// Using generic built-in exceptions
public class BankAccount {
    private double balance;
    
    public void withdraw(double amount) {
        if (amount <= 0) {
            // Generic exception - not very descriptive
            throw new IllegalArgumentException("Invalid amount");
        }
        
        if (amount > balance) {
            // Generic exception - doesn't convey business meaning
            throw new RuntimeException("Not enough money");
        }
        
        balance -= amount;
    }
}

// Problems with generic exceptions:
// 1. Not descriptive of business domain
// 2. Hard to handle different error types specifically
// 3. No additional context or data
// 4. Generic error messages

// Using custom business-specific exceptions
public class BankAccount {
    private double balance;
    
    public void withdraw(double amount) throws WithdrawalException {
        if (amount <= 0) {
            // Specific exception with business context
            throw new InvalidAmountException(
                "Withdrawal amount must be positive: " + amount);
        }
        
        if (amount > balance) {
            // Business-specific exception with detailed info
            throw new InsufficientFundsException(
                "Cannot withdraw " + amount + ", available balance: " + balance,
                amount, balance);
        }
        
        balance -= amount;
    }
}

// Benefits of custom exceptions:
// 1. Clear business domain meaning
// 2. Specific handling for different scenarios  
// 3. Additional context and data
// 4. Better error reporting and debugging

// E-commerce order processing
try {
    orderService.processOrder(order);
} catch (InvalidCustomerException e) {
    // Redirect to customer registration
    redirectToRegistration();
} catch (InsufficientInventoryException e) {
    // Show alternative products
    showAlternatives(e.getUnavailableItems());
} catch (PaymentDeclinedException e) {
    // Ask for different payment method
    requestDifferentPayment(e.getDeclineReason());
} catch (ShippingUnavailableException e) {
    // Offer different shipping options
    showShippingOptions(e.getAvailableOptions());
}

// Basic custom exception class
public class AccountException extends Exception {
    
    // Default constructor
    public AccountException() {
        super();
    }
    
    // Constructor with message
    public AccountException(String message) {
        super(message);
    }
    
    // Constructor with message and cause
    public AccountException(String message, Throwable cause) {
        super(message, cause);
    }
    
    // Constructor with cause only
    public AccountException(Throwable cause) {
        super(cause);
    }
}

// Usage example
public class BankAccount {
    private String accountNumber;
    private double balance;
    
    public void withdraw(double amount) throws AccountException {
        if (amount <= 0) {
            throw new AccountException("Withdrawal amount must be positive");
        }
        
        if (amount > balance) {
            throw new AccountException(
                "Insufficient funds: requested=" + amount + ", available=" + balance);
        }
        
        balance -= amount;
        System.out.println("Withdrawal successful. New balance: " + balance);
    }
}

// Runtime exception - doesn't need to be declared
public class InvalidConfigurationException extends RuntimeException {
    
    public InvalidConfigurationException() {
        super();
    }
    
    public InvalidConfigurationException(String message) {
        super(message);
    }
    
    public InvalidConfigurationException(String message, Throwable cause) {
        super(message, cause);
    }
    
    public InvalidConfigurationException(Throwable cause) {
        super(cause);
    }
}

// Usage - no need to declare in throws clause
public class ConfigurationManager {
    public void loadConfiguration(String filename) {
        if (filename == null || filename.isEmpty()) {
            // Runtime exception - optional to declare
            throw new InvalidConfigurationException(
                "Configuration filename cannot be null or empty");
        }
        
        try {
            // Load configuration logic
            Properties props = new Properties();
            props.load(new FileInputStream(filename));
            
            // Validate required properties
            if (!props.containsKey("database.url")) {
                throw new InvalidConfigurationException(
                    "Required property 'database.url' not found in " + filename);
            }
            
        } catch (IOException e) {
            throw new InvalidConfigurationException(
                "Failed to load configuration from " + filename, e);
        }
    }
}

// Exception with additional context information
public class InsufficientFundsException extends Exception {
    private double requestedAmount;
    private double availableBalance;
    private String accountNumber;
    
    public InsufficientFundsException(double requestedAmount, 
                                     double availableBalance, 
                                     String accountNumber) {
        super("Insufficient funds: requested=" + requestedAmount + 
              ", available=" + availableBalance + 
              ", account=" + accountNumber);
        
        this.requestedAmount = requestedAmount;
        this.availableBalance = availableBalance;
        this.accountNumber = accountNumber;
    }
    
    // Getters for additional context
    public double getRequestedAmount() { 
        return requestedAmount; 
    }
    
    public double getAvailableBalance() { 
        return availableBalance; 
    }
    
    public String getAccountNumber() { 
        return accountNumber; 
    }
    
    public double getShortfall() {
        return requestedAmount - availableBalance;
    }
}

// Usage with specific error handling
public class ATMService {
    public void processWithdrawal(String accountNumber, double amount) {
        try {
            BankAccount account = getAccount(accountNumber);
            account.withdraw(amount);
            
        } catch (InsufficientFundsException e) {
            // Use additional exception data for specific handling
            System.err.println("Withdrawal failed:");
            System.err.println("  Account: " + e.getAccountNumber());
            System.err.println("  Requested: $" + e.getRequestedAmount());
            System.err.println("  Available: $" + e.getAvailableBalance());
            System.err.println("  Shortfall: $" + e.getShortfall());
            
            // Offer alternative options
            if (e.getShortfall() < 50) {
                System.out.println("Consider withdrawing $" + e.getAvailableBalance());
            }
        }
    }
}

// Exception for validation errors with detailed information
public class ValidationException extends Exception {
    private String fieldName;
    private Object invalidValue;
    private String validationRule;
    private List<String> validationErrors;
    
    // Single field validation error
    public ValidationException(String fieldName, Object invalidValue, 
                              String validationRule) {
        super("Validation failed for field '" + fieldName + "': " + validationRule);
        this.fieldName = fieldName;
        this.invalidValue = invalidValue;
        this.validationRule = validationRule;
        this.validationErrors = Arrays.asList(getMessage());
    }
    
    // Multiple validation errors
    public ValidationException(List<String> validationErrors) {
        super("Validation failed: " + String.join("; ", validationErrors));
        this.validationErrors = new ArrayList<>(validationErrors);
    }
    
    // Getters
    public String getFieldName() { return fieldName; }
    public Object getInvalidValue() { return invalidValue; }
    public String getValidationRule() { return validationRule; }
    public List<String> getValidationErrors() { return validationErrors; }
}

// Base application exception
public abstract class ApplicationException extends Exception {
    private String errorCode;
    private LocalDateTime timestamp;
    
    public ApplicationException(String message) {
        super(message);
        this.timestamp = LocalDateTime.now();
    }
    
    public ApplicationException(String message, String errorCode) {
        super(message);
        this.errorCode = errorCode;
        this.timestamp = LocalDateTime.now();
    }
    
    public ApplicationException(String message, Throwable cause) {
        super(message, cause);
        this.timestamp = LocalDateTime.now();
    }
    
    public String getErrorCode() { return errorCode; }
    public LocalDateTime getTimestamp() { return timestamp; }
}

// Business layer exceptions
public abstract class BusinessException extends ApplicationException {
    public BusinessException(String message) {
        super(message);
    }
    
    public BusinessException(String message, String errorCode) {
        super(message, errorCode);
    }
    
    public BusinessException(String message, Throwable cause) {
        super(message, cause);
    }
}

// System layer exceptions
public abstract class SystemException extends ApplicationException {
    public SystemException(String message) {
        super(message);
    }
    
    public SystemException(String message, Throwable cause) {
        super(message, cause);
    }
}

// Specific business exceptions
public class UserNotFoundException extends BusinessException {
    private String userId;
    
    public UserNotFoundException(String userId) {
        super("User not found: " + userId, "USER_NOT_FOUND");
        this.userId = userId;
    }
    
    public String getUserId() { return userId; }
}

public class InvalidCredentialsException extends BusinessException {
    private String username;
    private int attemptCount;
    
    public InvalidCredentialsException(String username, int attemptCount) {
        super("Invalid credentials for user: " + username, "INVALID_CREDENTIALS");
        this.username = username;
        this.attemptCount = attemptCount;
    }
    
    public String getUsername() { return username; }
    public int getAttemptCount() { return attemptCount; }
}

// System exceptions
public class DatabaseException extends SystemException {
    private String operation;
    private String tableName;
    
    public DatabaseException(String operation, String tableName, 
                           String message, Throwable cause) {
        super("Database operation failed: " + operation + 
              " on table " + tableName + " - " + message, cause);
        this.operation = operation;
        this.tableName = tableName;
    }
    
    public String getOperation() { return operation; }
    public String getTableName() { return tableName; }
}

public class NetworkException extends SystemException {
    private String host;
    private int port;
    
    public NetworkException(String host, int port, String message, Throwable cause) {
        super("Network error connecting to " + host + ":" + port + " - " + message, cause);
        this.host = host;
        this.port = port;
    }
    
    public String getHost() { return host; }
    public int getPort() { return port; }
}

// Service layer using hierarchical handling
public class UserService {
    public User authenticateUser(String username, String password) 
            throws BusinessException, SystemException {
        
        try {
            // Check if user exists
            User user = userRepository.findByUsername(username);
            if (user == null) {
                throw new UserNotFoundException(username);
            }
            
            // Validate password
            if (!passwordEncoder.matches(password, user.getHashedPassword())) {
                int attempts = getFailedAttempts(username) + 1;
                recordFailedAttempt(username, attempts);
                throw new InvalidCredentialsException(username, attempts);
            }
            
            // Clear failed attempts on success
            clearFailedAttempts(username);
            
            return user;
            
        } catch (BusinessException e) {
            // Re-throw business exceptions as-is
            throw e;
            
        } catch (DatabaseException e) {
            // Convert database exception to system exception
            throw new SystemException("Authentication service temporarily unavailable", e);
            
        } catch (Exception e) {
            // Convert unexpected exceptions
            throw new SystemException("Unexpected error during authentication", e);
        }
    }
}

// Controller layer with hierarchical exception handling
@RestController
public class AuthController {
    @PostMapping("/authenticate")
    public ResponseEntity<?> authenticate(@RequestBody LoginRequest request) {
        try {
            User user = userService.authenticateUser(request.getUsername(), request.getPassword());
            String token = jwtService.generateToken(user);
            return ResponseEntity.ok(new AuthResponse(token, user.getId()));
            
        } catch (UserNotFoundException e) {
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED)
                .body(new ErrorResponse(e.getErrorCode(), "Invalid username or password"));
                
        } catch (InvalidCredentialsException e) {
            ErrorResponse response = new ErrorResponse(e.getErrorCode(), "Invalid username or password");
            
            // Add lockout warning after multiple attempts
            if (e.getAttemptCount() >= 3) {
                response.setWarning("Account will be locked after 5 failed attempts");
            }
            
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(response);
            
        } catch (BusinessException e) {
            // Handle other business exceptions generically
            return ResponseEntity.badRequest()
                .body(new ErrorResponse(e.getErrorCode(), e.getMessage()));
                
        } catch (SystemException e) {
            // Log system exceptions for monitoring
            logger.error("System error during authentication", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body(new ErrorResponse("SYSTEM_ERROR", "Service temporarily unavailable"));
        }
    }
}

// Base e-commerce exception
public abstract class EcommerceException extends Exception {
    private String orderId;
    private String customerId;
    
    public EcommerceException(String message) {
        super(message);
    }
    
    public EcommerceException(String message, String orderId, String customerId) {
        super(message);
        this.orderId = orderId;
        this.customerId = customerId;
    }
    
    public String getOrderId() { return orderId; }
    public String getCustomerId() { return customerId; }
}

// Inventory related exceptions
public class InsufficientInventoryException extends EcommerceException {
    private String productId;
    private int requestedQuantity;
    private int availableQuantity;
    
    public InsufficientInventoryException(String productId, 
                                        int requestedQuantity, 
                                        int availableQuantity) {
        super("Insufficient inventory for product " + productId + 
              ": requested=" + requestedQuantity + 
              ", available=" + availableQuantity);
        this.productId = productId;
        this.requestedQuantity = requestedQuantity;
        this.availableQuantity = availableQuantity;
    }
    
    public String getProductId() { return productId; }
    public int getRequestedQuantity() { return requestedQuantity; }
    public int getAvailableQuantity() { return availableQuantity; }
    public int getShortfall() { return requestedQuantity - availableQuantity; }
}

// Payment related exceptions
public abstract class PaymentException extends EcommerceException {
    private String transactionId;
    private BigDecimal amount;
    
    public PaymentException(String message, String transactionId, BigDecimal amount) {
        super(message);
        this.transactionId = transactionId;
        this.amount = amount;
    }
    
    public String getTransactionId() { return transactionId; }
    public BigDecimal getAmount() { return amount; }
}

public class PaymentDeclinedException extends PaymentException {
    private String declineReason;
    private String declineCode;
    
    public PaymentDeclinedException(String transactionId, BigDecimal amount,
                                  String declineReason, String declineCode) {
        super("Payment declined: " + declineReason, transactionId, amount);
        this.declineReason = declineReason;
        this.declineCode = declineCode;
    }
    
    public String getDeclineReason() { return declineReason; }
    public String getDeclineCode() { return declineCode; }
    
    public boolean isRetryable() {
        // Some decline codes indicate retryable errors
        return "INSUFFICIENT_FUNDS".equals(declineCode) || 
               "TEMPORARY_HOLD".equals(declineCode);
    }
}

public class PaymentTimeoutException extends PaymentException {
    private int timeoutSeconds;
    
    public PaymentTimeoutException(String transactionId, BigDecimal amount, int timeoutSeconds) {
        super("Payment timed out after " + timeoutSeconds + " seconds", transactionId, amount);
        this.timeoutSeconds = timeoutSeconds;
    }
    
    public int getTimeoutSeconds() { return timeoutSeconds; }
}

// Base medical system exception
public abstract class MedicalException extends Exception {
    private String patientId;
    private String facilityId;
    private LocalDateTime occurredAt;
    
    public MedicalException(String message, String patientId, String facilityId) {
        super(message);
        this.patientId = patientId;
        this.facilityId = facilityId;
        this.occurredAt = LocalDateTime.now();
    }
    
    public String getPatientId() { return patientId; }
    public String getFacilityId() { return facilityId; }
    public LocalDateTime getOccurredAt() { return occurredAt; }
}

// Patient related exceptions
public class PatientNotFoundException extends MedicalException {
    public PatientNotFoundException(String patientId, String facilityId) {
        super("Patient not found: " + patientId, patientId, facilityId);
    }
}

public class PatientRecordLockedException extends MedicalException {
    private String lockedByUserId;
    private LocalDateTime lockedSince;
    
    public PatientRecordLockedException(String patientId, String facilityId,
                                      String lockedByUserId, LocalDateTime lockedSince) {
        super("Patient record is currently locked by another user", patientId, facilityId);
        this.lockedByUserId = lockedByUserId;
        this.lockedSince = lockedSince;
    }
    
    public String getLockedByUserId() { return lockedByUserId; }
    public LocalDateTime getLockedSince() { return lockedSince; }
}

// Prescription related exceptions
public class DrugInteractionException extends MedicalException {
    private String drugId1;
    private String drugId2;
    private String interactionType;
    private String severity;
    
    public DrugInteractionException(String patientId, String facilityId,
                                  String drugId1, String drugId2,
                                  String interactionType, String severity) {
        super("Drug interaction detected: " + drugId1 + " and " + drugId2 +
              " - " + interactionType + " (Severity: " + severity + ")",
              patientId, facilityId);
        this.drugId1 = drugId1;
        this.drugId2 = drugId2;
        this.interactionType = interactionType;
        this.severity = severity;
    }
    
    public String getDrugId1() { return drugId1; }
    public String getDrugId2() { return drugId2; }
    public String getInteractionType() { return interactionType; }
    public String getSeverity() { return severity; }
    
    public boolean isCritical() {
        return "CRITICAL".equalsIgnoreCase(severity) || "SEVERE".equalsIgnoreCase(severity);
    }
}

public class AllergicReactionException extends MedicalException {
    private String allergen;
    private String reactionType;
    private List<String> symptoms;
    
    public AllergicReactionException(String patientId, String facilityId,
                                   String allergen, String reactionType,
                                   List<String> symptoms) {
        super("Allergic reaction alert: Patient allergic to " + allergen +
              " - Reaction type: " + reactionType,
              patientId, facilityId);
        this.allergen = allergen;
        this.reactionType = reactionType;
        this.symptoms = new ArrayList<>(symptoms);
    }
    
    public String getAllergen() { return allergen; }
    public String getReactionType() { return reactionType; }
    public List<String> getSymptoms() { return symptoms; }
}

// Usage in medical service
@Service
public class PrescriptionService {
    public void prescribeMedication(String patientId, String drugId, String dosage)
            throws MedicalException {
        
        try {
            // Get patient info
            Patient patient = patientRepository.findById(patientId);
            if (patient == null) {
                throw new PatientNotFoundException(patientId, getCurrentFacilityId());
            }
            
            // Check for allergies
            List<String> allergies = patient.getAllergies();
            Drug drug = drugRepository.findById(drugId);
            
            if (allergies.contains(drug.getActiveIngredient())) {
                throw new AllergicReactionException(
                    patientId, getCurrentFacilityId(),
                    drug.getActiveIngredient(), "MEDICATION",
                    Arrays.asList("Potential allergic reaction to prescribed medication"));
            }
            
            // Check for drug interactions
            List<String> currentMedications = getCurrentMedications(patientId);
            for (String currentDrug : currentMedications) {
                DrugInteraction interaction = checkInteraction(drugId, currentDrug);
                if (interaction != null && interaction.getSeverity().equals("CRITICAL")) {
                    throw new DrugInteractionException(
                        patientId, getCurrentFacilityId(),
                        drugId, currentDrug,
                        interaction.getType(), interaction.getSeverity());
                }
            }
            
            // Create prescription
            Prescription prescription = new Prescription(patientId, drugId, dosage);
            prescriptionRepository.save(prescription);
            
        } catch (MedicalException e) {
            // Log medical exceptions for compliance tracking
            medicalAuditLogger.logMedicalException(e);
            throw e;
        }
    }
}

// Data access layer exception with context
public class DataAccessException extends Exception {
    private String operation;
    private String entity;
    private Map<String, Object> parameters;
    
    public DataAccessException(String operation, String entity, 
                              String message, Throwable cause) {
        super("Data access failed: " + operation + " on " + entity + " - " + message, cause);
        this.operation = operation;
        this.entity = entity;
        this.parameters = new HashMap<>();
    }
    
    public DataAccessException addParameter(String key, Object value) {
        parameters.put(key, value);
        return this;
    }
    
    public String getOperation() { return operation; }
    public String getEntity() { return entity; }
    public Map<String, Object> getParameters() { return parameters; }
}

// Service layer exception that chains data access exceptions
public class OrderProcessingException extends Exception {
    private String orderId;
    private String processingStage;
    private Map<String, Object> orderContext;
    
    public OrderProcessingException(String orderId, String processingStage, 
                                  String message, Throwable cause) {
        super("Order processing failed at stage '" + processingStage + 
              "' for order " + orderId + ": " + message, cause);
        this.orderId = orderId;
        this.processingStage = processingStage;
        this.orderContext = new HashMap<>();
    }
    
    public OrderProcessingException addContext(String key, Object value) {
        orderContext.put(key, value);
        return this;
    }
    
    public String getOrderId() { return orderId; }
    public String getProcessingStage() { return processingStage; }
    public Map<String, Object> getOrderContext() { return orderContext; }
    
    // Method to get the full exception chain
    public List<Throwable> getExceptionChain() {
        List<Throwable> chain = new ArrayList<>();
        Throwable current = this;
        while (current != null) {
            chain.add(current);
            current = current.getCause();
        }
        return chain;
    }
}

// Repository implementation with exception chaining
@Repository
public class OrderRepository {
    public Order saveOrder(Order order) throws DataAccessException {
        try {
            // Database save operation
            return entityManager.merge(order);
            
        } catch (PersistenceException e) {
            throw new DataAccessException("INSERT", "Order", 
                "Failed to save order to database", e)
                .addParameter("orderId", order.getId())
                .addParameter("customerId", order.getCustomerId())
                .addParameter("totalAmount", order.getTotalAmount());
                
        } catch (Exception e) {
            throw new DataAccessException("INSERT", "Order",
                "Unexpected error during order save", e)
                .addParameter("orderId", order.getId());
        }
    }
}

// Service that chains exceptions with context
@Service
public class OrderService {
    
    public void processOrder(Order order) throws OrderProcessingException {
        String orderId = order.getId();
        
        try {
            // Stage 1: Validate order
            validateOrder(order);
            
            // Stage 2: Reserve inventory
            reserveInventory(order);
            
            // Stage 3: Process payment
            processPayment(order);
            
            // Stage 4: Save order
            Order savedOrder = orderRepository.saveOrder(order);
            
            // Stage 5: Send confirmation
            sendOrderConfirmation(savedOrder);
            
        } catch (ValidationException e) {
            throw new OrderProcessingException(orderId, "VALIDATION",
                "Order validation failed", e)
                .addContext("customerId", order.getCustomerId())
                .addContext("itemCount", order.getItems().size());
                
        } catch (InventoryException e) {
            throw new OrderProcessingException(orderId, "INVENTORY",
                "Inventory reservation failed", e)
                .addContext("unavailableItems", e.getUnavailableItems());
                
        } catch (PaymentException e) {
            throw new OrderProcessingException(orderId, "PAYMENT",
                "Payment processing failed", e)
                .addContext("paymentMethod", order.getPaymentMethod())
                .addContext("amount", order.getTotalAmount());
                
        } catch (DataAccessException e) {
            throw new OrderProcessingException(orderId, "PERSISTENCE",
                "Order save failed", e)
                .addContext("operation", e.getOperation())
                .addContext("entity", e.getEntity());
                
        } catch (Exception e) {
            throw new OrderProcessingException(orderId, "UNKNOWN",
                "Unexpected error during order processing", e);
        }
    }
}

// Controller with comprehensive exception handling
@RestController
public class OrderController {
    
    @PostMapping("/orders")
    public ResponseEntity<?> createOrder(@RequestBody Order order) {
        try {
            orderService.processOrder(order);
            return ResponseEntity.ok("Order processed successfully");
            
        } catch (OrderProcessingException e) {
            // Log the full exception chain for debugging
            logExceptionChain(e);
            
            // Return user-friendly error based on processing stage
            return handleOrderProcessingError(e);
        }
    }
    
    private ResponseEntity<?> handleOrderProcessingError(OrderProcessingException e) {
        ErrorResponse response = new ErrorResponse();
        
        switch (e.getProcessingStage()) {
            case "VALIDATION":
                response.setCode("VALIDATION_ERROR");
                response.setMessage("Please check your order details");
                response.setUserMessage("There was an issue with your order. Please review and try again.");
                break;
                
            case "INVENTORY":
                response.setCode("INVENTORY_ERROR");
                response.setMessage("Some items are no longer available");
                response.setUserMessage("Sorry, some items in your cart are out of stock.");
                // Add available alternatives from context
                break;
                
            case "PAYMENT":
                response.setCode("PAYMENT_ERROR");
                response.setMessage("Payment could not be processed");
                response.setUserMessage("There was an issue processing your payment. Please try a different payment method.");
                break;
                
            case "PERSISTENCE":
                response.setCode("SYSTEM_ERROR");
                response.setMessage("Order could not be saved");
                response.setUserMessage("We're experiencing technical difficulties. Please try again in a few moments.");
                break;
                
            default:
                response.setCode("UNKNOWN_ERROR");
                response.setMessage("An unexpected error occurred");
                response.setUserMessage("Something went wrong. Our team has been notified.");
        }
        
        response.setOrderId(e.getOrderId());
        response.setTimestamp(LocalDateTime.now());
        
        return ResponseEntity.badRequest().body(response);
    }
    
    private void logExceptionChain(OrderProcessingException e) {
        logger.error("Order processing failed for order: {}", e.getOrderId());
        
        List<Throwable> chain = e.getExceptionChain();
        for (int i = 0; i < chain.size(); i++) {
            Throwable exception = chain.get(i);
            logger.error("  Exception level {}: {} - {}", 
                        i, exception.getClass().getSimpleName(), exception.getMessage());
        }
        
        // Log context information
        logger.error("Order context: {}", e.getOrderContext());
        logger.error("Processing stage: {}", e.getProcessingStage());
    }
}