Replace Error Codes with Exceptions/Results

• Problema: Método que retorna códigos de error especiales.
• Solución: Lanzar excepciones o usar objetos Result/Either.
• Code Smells que resuelve: Códigos de Error, Manejo de Errores Inconsistente

fun processPayment(amount: Double): Int {
    if (amount <= 0) {
        return -1  // Error: Monto inválido
    }
    
    val account = getAccount()
    if (account == null) {
        return -2  // Error: Cuenta no encontrada
    }
    
    if (account.balance < amount) {
        return -3  // Error: Fondos insuficientes
    }
    
    // Procesar pago
    account.debit(amount)
    return 0  // Éxito
}

// Uso:
val result = processPayment(100.0)
if (result == -1) {
    println("Monto inválido")
} else if (result == -2) {
    println("Cuenta no encontrada")
} else if (result == -3) {
    println("Fondos insuficientes")
} else if (result == 0) {
    println("Pago exitoso")
}

fun processPayment(amount: Double) {
    if (amount <= 0) {
        throw InvalidAmountException("El monto debe ser positivo")
    }
    
    val account = getAccount() ?: throw AccountNotFoundException("Cuenta no encontrada")
    
    if (account.balance < amount) {
        throw InsufficientFundsException("Fondos insuficientes")
    }
    
    // Procesar pago
    account.debit(amount)
}

// Uso:
try {
    processPayment(100.0)
    println("Pago exitoso")
} catch (e: InvalidAmountException) {
    println(e.message)
} catch (e: AccountNotFoundException) {
    println(e.message)
} catch (e: InsufficientFundsException) {
    println(e.message)
}

sealed class PaymentResult {
    object Success : PaymentResult()
    sealed class Error : PaymentResult() {
        object InvalidAmount : Error()
        object AccountNotFound : Error()
        object InsufficientFunds : Error()
    }
}

fun processPayment(amount: Double): PaymentResult {
    if (amount <= 0) {
        return PaymentResult.Error.InvalidAmount
    }
    
    val account = getAccount() ?: return PaymentResult.Error.AccountNotFound
    
    if (account.balance < amount) {
        return PaymentResult.Error.InsufficientFunds
    }
    
    // Procesar pago
    account.debit(amount)
    return PaymentResult.Success
}

// Uso:
when (val result = processPayment(100.0)) {
    is PaymentResult.Success -> println("Pago exitoso")
    is PaymentResult.Error.InvalidAmount -> println("Monto inválido")
    is PaymentResult.Error.AccountNotFound -> println("Cuenta no encontrada")
    is PaymentResult.Error.InsufficientFunds -> println("Fondos insuficientes")
}