🚨 Lesson 7.2: Custom Errors and Exceptions

# Python uses 'raise' to throw errors
def set_age(age):
    if age < 0:
        raise ValueError("Age cannot be negative")
    if age > 150:
        raise ValueError("Age seems unrealistic")
    return age

# This works fine
print(set_age(25))    # 25

# This raises an error you created
try:
    set_age(-5)
except ValueError as e:
    print(f"Error: {e}")    # Error: Age cannot be negative

# You can raise any built-in exception type
raise TypeError("Expected a string, got int")
raise FileNotFoundError("Config file missing: app.yaml")
raise PermissionError("User lacks admin access")
raise RuntimeError("Something unexpected happened")

// JavaScript uses 'throw' to throw errors
function setAge(age) {
    if (age < 0) {
        throw new RangeError("Age cannot be negative");
    }
    if (age > 150) {
        throw new RangeError("Age seems unrealistic");
    }
    return age;
}

// This works fine
console.log(setAge(25));    // 25

// This throws an error you created
try {
    setAge(-5);
} catch (error) {
    console.log(`Error: ${error.message}`);  // Error: Age cannot be negative
}

// You can throw any built-in error type
throw new TypeError("Expected a string, got number");
throw new RangeError("Value out of acceptable range");
throw new ReferenceError("Configuration not initialized");
throw new Error("Something unexpected happened");

// JS can technically throw anything — but don't do this!
// throw "bad!";        // ❌ No stack trace, no .message
// throw 42;            // ❌ Loses all error information
// throw { msg: "!" };  // ❌ Not an Error instance

// C# uses 'throw' to throw errors
static int SetAge(int age)
{
    if (age < 0)
        throw new ArgumentOutOfRangeException(nameof(age), "Age cannot be negative");
    if (age > 150)
        throw new ArgumentOutOfRangeException(nameof(age), "Age seems unrealistic");
    return age;
}

// This works fine
Console.WriteLine(SetAge(25));    // 25

// This throws an error you created
try
{
    SetAge(-5);
}
catch (ArgumentOutOfRangeException e)
{
    Console.WriteLine($"Error: {e.Message}");
}

// Common built-in exception types to throw
throw new ArgumentNullException(nameof(name), "Name is required");
throw new ArgumentException("Email format is invalid");
throw new InvalidOperationException("Cannot edit a locked record");
throw new NotImplementedException("Feature coming soon");
throw new NotSupportedException("PDF export not available");

# Custom exceptions inherit from Exception (or a subclass)
class InsufficientFundsError(Exception):
    """Raised when a withdrawal exceeds the account balance."""
    pass

class AccountLockedError(Exception):
    """Raised when an operation is attempted on a locked account."""
    pass

class InvalidAmountError(ValueError):
    """Raised when a monetary amount is invalid (negative or zero)."""
    pass

# Using custom exceptions
class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance
        self.locked = False

    def withdraw(self, amount):
        if self.locked:
            raise AccountLockedError(f"Account for {self.owner} is locked")
        if amount <= 0:
            raise InvalidAmountError(f"Amount must be positive, got {amount}")
        if amount > self.balance:
            raise InsufficientFundsError(
                f"Cannot withdraw ${amount:.2f} — balance is ${self.balance:.2f}"
            )
        self.balance -= amount
        return self.balance

# Catching custom exceptions
account = BankAccount("Alice", 100)

try:
    account.withdraw(150)
except InsufficientFundsError as e:
    print(f"💰 {e}")
# 💰 Cannot withdraw $150.00 — balance is $100.00

try:
    account.withdraw(-50)
except InvalidAmountError as e:
    print(f"❌ {e}")
# ❌ Amount must be positive, got -50

// Custom exceptions extend Error
class InsufficientFundsError extends Error {
    constructor(message) {
        super(message);
        this.name = "InsufficientFundsError";  // Override the name!
    }
}

class AccountLockedError extends Error {
    constructor(message) {
        super(message);
        this.name = "AccountLockedError";
    }
}

class InvalidAmountError extends RangeError {
    constructor(message) {
        super(message);
        this.name = "InvalidAmountError";
    }
}

// Using custom exceptions
class BankAccount {
    constructor(owner, balance = 0) {
        this.owner = owner;
        this.balance = balance;
        this.locked = false;
    }

    withdraw(amount) {
        if (this.locked) {
            throw new AccountLockedError(`Account for ${this.owner} is locked`);
        }
        if (amount <= 0) {
            throw new InvalidAmountError(`Amount must be positive, got ${amount}`);
        }
        if (amount > this.balance) {
            throw new InsufficientFundsError(
                `Cannot withdraw $${amount.toFixed(2)} — balance is $${this.balance.toFixed(2)}`
            );
        }
        this.balance -= amount;
        return this.balance;
    }
}

// Catching custom exceptions
let account = new BankAccount("Alice", 100);

try {
    account.withdraw(150);
} catch (error) {
    if (error instanceof InsufficientFundsError) {
        console.log(`💰 ${error.message}`);
    }
}
// 💰 Cannot withdraw $150.00 — balance is $100.00

// Custom exceptions inherit from Exception (or a subclass)
class InsufficientFundsException : Exception
{
    public InsufficientFundsException(string message) : base(message) { }
}

class AccountLockedException : InvalidOperationException
{
    public AccountLockedException(string message) : base(message) { }
}

class InvalidAmountException : ArgumentException
{
    public InvalidAmountException(string message) : base(message) { }
}

// Using custom exceptions
class BankAccount
{
    public string Owner;
    public decimal Balance;
    public bool Locked;

    public BankAccount(string owner, decimal balance = 0)
    {
        Owner = owner;
        Balance = balance;
        Locked = false;
    }

    public decimal Withdraw(decimal amount)
    {
        if (Locked)
            throw new AccountLockedException($"Account for {Owner} is locked");
        if (amount <= 0)
            throw new InvalidAmountException($"Amount must be positive, got {amount}");
        if (amount > Balance)
            throw new InsufficientFundsException(
                $"Cannot withdraw {amount:C} — balance is {Balance:C}");

        Balance -= amount;
        return Balance;
    }
}

// Catching custom exceptions
var account = new BankAccount("Alice", 100);

try
{
    account.Withdraw(150);
}
catch (InsufficientFundsException e)
{
    Console.WriteLine($"💰 {e.Message}");
}
// 💰 Cannot withdraw $150.00 — balance is $100.00

class InsufficientFundsError(Exception):
    """Carries the shortage amount so callers can act on it."""
    def __init__(self, balance, amount):
        self.balance = balance
        self.amount = amount
        self.shortage = amount - balance
        super().__init__(
            f"Cannot withdraw ${amount:.2f} from ${balance:.2f} "
            f"(short ${self.shortage:.2f})"
        )

class ValidationError(Exception):
    """Carries a field name and error code."""
    def __init__(self, field, message, code=None):
        self.field = field
        self.code = code
        super().__init__(f"{field}: {message}")

# Using the rich exception data
def withdraw(balance, amount):
    if amount > balance:
        raise InsufficientFundsError(balance, amount)
    return balance - amount

try:
    withdraw(75.00, 100.00)
except InsufficientFundsError as e:
    print(f"Error: {e}")
    print(f"  Balance:  ${e.balance:.2f}")
    print(f"  Requested: ${e.amount:.2f}")
    print(f"  Short by:  ${e.shortage:.2f}")
    # Now you can offer: "Would you like to withdraw $75.00 instead?"

# Error: Cannot withdraw $100.00 from $75.00 (short $25.00)
#   Balance:  $75.00
#   Requested: $100.00
#   Short by:  $25.00

# Validation with error codes
try:
    raise ValidationError("email", "Invalid format", code="INVALID_EMAIL")
except ValidationError as e:
    print(f"Field: {e.field}, Code: {e.code}, Message: {e}")

class InsufficientFundsError extends Error {
    constructor(balance, amount) {
        let shortage = amount - balance;
        super(
            `Cannot withdraw $${amount.toFixed(2)} from $${balance.toFixed(2)} ` +
            `(short $${shortage.toFixed(2)})`
        );
        this.name = "InsufficientFundsError";
        this.balance = balance;
        this.amount = amount;
        this.shortage = shortage;
    }
}

class ValidationError extends Error {
    constructor(field, message, code = null) {
        super(`${field}: ${message}`);
        this.name = "ValidationError";
        this.field = field;
        this.code = code;
    }
}

// Using the rich exception data
function withdraw(balance, amount) {
    if (amount > balance) {
        throw new InsufficientFundsError(balance, amount);
    }
    return balance - amount;
}

try {
    withdraw(75.00, 100.00);
} catch (error) {
    if (error instanceof InsufficientFundsError) {
        console.log(`Error: ${error.message}`);
        console.log(`  Balance:  $${error.balance.toFixed(2)}`);
        console.log(`  Requested: $${error.amount.toFixed(2)}`);
        console.log(`  Short by:  $${error.shortage.toFixed(2)}`);
    }
}

// Validation with error codes
try {
    throw new ValidationError("email", "Invalid format", "INVALID_EMAIL");
} catch (error) {
    console.log(`Field: ${error.field}, Code: ${error.code}`);
}

class InsufficientFundsException : Exception
{
    public decimal Balance { get; }
    public decimal Amount { get; }
    public decimal Shortage => Amount - Balance;

    public InsufficientFundsException(decimal balance, decimal amount)
        : base($"Cannot withdraw {amount:C} from {balance:C} (short {amount - balance:C})")
    {
        Balance = balance;
        Amount = amount;
    }
}

class ValidationException : Exception
{
    public string Field { get; }
    public string? Code { get; }

    public ValidationException(string field, string message, string? code = null)
        : base($"{field}: {message}")
    {
        Field = field;
        Code = code;
    }
}

// Using the rich exception data
static decimal Withdraw(decimal balance, decimal amount)
{
    if (amount > balance)
        throw new InsufficientFundsException(balance, amount);
    return balance - amount;
}

try
{
    Withdraw(75.00m, 100.00m);
}
catch (InsufficientFundsException e)
{
    Console.WriteLine($"Error: {e.Message}");
    Console.WriteLine($"  Balance:  {e.Balance:C}");
    Console.WriteLine($"  Requested: {e.Amount:C}");
    Console.WriteLine($"  Short by:  {e.Shortage:C}");
}

// Validation with error codes
try
{
    throw new ValidationException("email", "Invalid format", "INVALID_EMAIL");
}
catch (ValidationException e)
{
    Console.WriteLine($"Field: {e.Field}, Code: {e.Code}");
}

# Base error for all banking operations
class BankError(Exception):
    """Base class for all banking exceptions."""
    pass

# Account-related errors
class AccountError(BankError):
    """Base for account-level problems."""
    def __init__(self, account_id, message):
        self.account_id = account_id
        super().__init__(f"Account {account_id}: {message}")

class AccountLockedError(AccountError):
    def __init__(self, account_id, reason="policy violation"):
        self.reason = reason
        super().__init__(account_id, f"Locked ({reason})")

class AccountNotFoundError(AccountError):
    def __init__(self, account_id):
        super().__init__(account_id, "Not found")

# Transaction-related errors
class TransactionError(BankError):
    """Base for transaction-level problems."""
    def __init__(self, amount, message):
        self.amount = amount
        super().__init__(f"Transaction of ${amount:.2f}: {message}")

class InsufficientFundsError(TransactionError):
    def __init__(self, amount, balance):
        self.balance = balance
        self.shortage = amount - balance
        super().__init__(amount, f"Insufficient funds (balance: ${balance:.2f})")

class DailyLimitExceededError(TransactionError):
    def __init__(self, amount, limit):
        self.limit = limit
        super().__init__(amount, f"Exceeds daily limit of ${limit:.2f}")

# --- Catching at different levels of specificity ---

# Specific: handle just insufficient funds
try:
    raise InsufficientFundsError(500, 200)
except InsufficientFundsError as e:
    print(f"Short ${e.shortage:.2f}")

# Medium: handle any transaction error
try:
    raise DailyLimitExceededError(5000, 2000)
except TransactionError as e:
    print(f"Transaction failed: {e}")

# Broad: handle any banking error
try:
    raise AccountLockedError("ACC-123", "fraud investigation")
except BankError as e:
    print(f"Banking error: {e}")

// Base error for all banking operations
class BankError extends Error {
    constructor(message) {
        super(message);
        this.name = "BankError";
    }
}

// Account-related errors
class AccountError extends BankError {
    constructor(accountId, message) {
        super(`Account ${accountId}: ${message}`);
        this.name = "AccountError";
        this.accountId = accountId;
    }
}

class AccountLockedError extends AccountError {
    constructor(accountId, reason = "policy violation") {
        super(accountId, `Locked (${reason})`);
        this.name = "AccountLockedError";
        this.reason = reason;
    }
}

class AccountNotFoundError extends AccountError {
    constructor(accountId) {
        super(accountId, "Not found");
        this.name = "AccountNotFoundError";
    }
}

// Transaction-related errors
class TransactionError extends BankError {
    constructor(amount, message) {
        super(`Transaction of $${amount.toFixed(2)}: ${message}`);
        this.name = "TransactionError";
        this.amount = amount;
    }
}

class InsufficientFundsError extends TransactionError {
    constructor(amount, balance) {
        super(amount, `Insufficient funds (balance: $${balance.toFixed(2)})`);
        this.name = "InsufficientFundsError";
        this.balance = balance;
        this.shortage = amount - balance;
    }
}

// --- Catching at different levels ---
try {
    throw new InsufficientFundsError(500, 200);
} catch (error) {
    if (error instanceof InsufficientFundsError) {
        console.log(`Short $${error.shortage.toFixed(2)}`);
    } else if (error instanceof TransactionError) {
        console.log(`Transaction failed: ${error.message}`);
    } else if (error instanceof BankError) {
        console.log(`Banking error: ${error.message}`);
    }
}

// instanceof checks the ENTIRE chain
let err = new InsufficientFundsError(100, 50);
console.log(err instanceof InsufficientFundsError);  // true
console.log(err instanceof TransactionError);         // true
console.log(err instanceof BankError);                // true
console.log(err instanceof Error);                    // true

// Base error for all banking operations
class BankException : Exception
{
    public BankException(string message) : base(message) { }
}

// Account-related errors
class AccountException : BankException
{
    public string AccountId { get; }
    public AccountException(string accountId, string message)
        : base($"Account {accountId}: {message}")
    { AccountId = accountId; }
}

class AccountLockedException : AccountException
{
    public string Reason { get; }
    public AccountLockedException(string accountId, string reason = "policy violation")
        : base(accountId, $"Locked ({reason})")
    { Reason = reason; }
}

class AccountNotFoundException : AccountException
{
    public AccountNotFoundException(string accountId)
        : base(accountId, "Not found") { }
}

// Transaction-related errors
class TransactionException : BankException
{
    public decimal Amount { get; }
    public TransactionException(decimal amount, string message)
        : base($"Transaction of {amount:C}: {message}")
    { Amount = amount; }
}

class InsufficientFundsException : TransactionException
{
    public decimal Balance { get; }
    public decimal Shortage => Amount - Balance;
    public InsufficientFundsException(decimal amount, decimal balance)
        : base(amount, $"Insufficient funds (balance: {balance:C})")
    { Balance = balance; }
}

// --- Catching at different levels ---

// Specific
try { throw new InsufficientFundsException(500, 200); }
catch (InsufficientFundsException e)
{ Console.WriteLine($"Short {e.Shortage:C}"); }

// Medium
try { throw new InsufficientFundsException(500, 200); }
catch (TransactionException e)
{ Console.WriteLine($"Transaction failed: {e.Message}"); }

// Broad
try { throw new AccountLockedException("ACC-123", "fraud"); }
catch (BankException e)
{ Console.WriteLine($"Banking error: {e.Message}"); }

# ❌ Without guards — deeply nested "pyramid of doom"
def create_user(username, email, age):
    if username:
        if len(username) >= 3:
            if email:
                if "@" in email:
                    if age:
                        if age >= 13:
                            # FINALLY, the actual logic, buried 6 levels deep
                            return {"username": username, "email": email, "age": age}
                        else:
                            raise ValueError("Must be 13+")
                    else:
                        raise ValueError("Age required")
                else:
                    raise ValueError("Invalid email")
            else:
                raise ValueError("Email required")
        else:
            raise ValueError("Username too short")
    else:
        raise ValueError("Username required")

# ✅ With guards — flat, clear, and readable
def create_user(username, email, age):
    # Guards: check each requirement, bail immediately if invalid
    if not username:
        raise ValueError("Username is required")
    if len(username) < 3:
        raise ValueError("Username must be at least 3 characters")
    if not email:
        raise ValueError("Email is required")
    if "@" not in email:
        raise ValueError("Email must contain @")
    if not age:
        raise ValueError("Age is required")
    if age < 13:
        raise ValueError("Must be at least 13 years old")

    # Happy path — no nesting needed
    return {"username": username, "email": email, "age": age}

// ❌ Without guards — deeply nested
function createUser(username, email, age) {
    if (username) {
        if (username.length >= 3) {
            if (email) {
                if (email.includes("@")) {
                    if (age) {
                        if (age >= 13) {
                            return { username, email, age };
                        } else { throw new RangeError("Must be 13+"); }
                    } else { throw new Error("Age required"); }
                } else { throw new Error("Invalid email"); }
            } else { throw new Error("Email required"); }
        } else { throw new Error("Username too short"); }
    } else { throw new Error("Username required"); }
}

// ✅ With guards — flat, clear, and readable
function createUser(username, email, age) {
    if (!username) throw new Error("Username is required");
    if (username.length < 3) throw new Error("Username must be at least 3 characters");
    if (!email) throw new Error("Email is required");
    if (!email.includes("@")) throw new Error("Email must contain @");
    if (!age) throw new Error("Age is required");
    if (age < 13) throw new RangeError("Must be at least 13 years old");

    // Happy path — no nesting
    return { username, email, age };
}

// ✅ With guards — clean and modern C#
static User CreateUser(string? username, string? email, int? age)
{
    if (string.IsNullOrWhiteSpace(username))
        throw new ArgumentException("Username is required");
    if (username.Length < 3)
        throw new ArgumentException("Username must be at least 3 characters");
    if (string.IsNullOrWhiteSpace(email))
        throw new ArgumentException("Email is required");
    if (!email.Contains('@'))
        throw new ArgumentException("Email must contain @");
    if (age is null)
        throw new ArgumentNullException(nameof(age), "Age is required");
    if (age < 13)
        throw new ArgumentOutOfRangeException(nameof(age), "Must be at least 13");

    // Happy path
    return new User { Username = username, Email = email, Age = age.Value };
}

// C# 11+ also has ArgumentException.ThrowIfNullOrEmpty()
static void QuickGuards(string name, int count)
{
    ArgumentException.ThrowIfNullOrEmpty(name);
    ArgumentOutOfRangeException.ThrowIfNegative(count);
    // ... happy path
}

# Pattern 1: Throw — for contract violations
def divide(a, b):
    if b == 0:
        raise ZeroDivisionError("Cannot divide by zero")
    return a / b

# Pattern 2: Return None — for "not found" searches
def find_user(users, name):
    for user in users:
        if user["name"] == name:
            return user
    return None  # Not found is a normal outcome

# Pattern 3: Return a result tuple/dict — forces handling
def validate_password(password):
    errors = []
    if len(password) < 8:
        errors.append("Must be at least 8 characters")
    if not any(c.isupper() for c in password):
        errors.append("Must contain an uppercase letter")
    if not any(c.isdigit() for c in password):
        errors.append("Must contain a digit")

    if errors:
        return {"valid": False, "errors": errors}
    return {"valid": True, "errors": []}

# Usage:
result = validate_password("abc")
if not result["valid"]:
    for error in result["errors"]:
        print(f"  ❌ {error}")
# ❌ Must be at least 8 characters
# ❌ Must contain an uppercase letter
# ❌ Must contain a digit

// Pattern 1: Throw — for contract violations
function divide(a, b) {
    if (b === 0) throw new Error("Cannot divide by zero");
    return a / b;
}

// Pattern 2: Return null — for "not found" searches
function findUser(users, name) {
    return users.find(u => u.name === name) || null;
}

// Pattern 3: Return a result object — forces handling
function validatePassword(password) {
    let errors = [];
    if (password.length < 8)
        errors.push("Must be at least 8 characters");
    if (!/[A-Z]/.test(password))
        errors.push("Must contain an uppercase letter");
    if (!/\d/.test(password))
        errors.push("Must contain a digit");

    return { valid: errors.length === 0, errors };
}

let result = validatePassword("abc");
if (!result.valid) {
    result.errors.forEach(err => console.log(`  ❌ ${err}`));
}

// Pattern 1: Throw — for contract violations
static double Divide(double a, double b)
{
    if (b == 0) throw new DivideByZeroException("Cannot divide by zero");
    return a / b;
}

// Pattern 2: TryParse pattern — caller decides how to handle
// This is a very common C# idiom
static bool TryFindUser(List<User> users, string name, out User? found)
{
    found = users.FirstOrDefault(u => u.Name == name);
    return found != null;
}

// Usage:
if (TryFindUser(users, "Alice", out var user))
    Console.WriteLine($"Found: {user.Name}");
else
    Console.WriteLine("User not found");

// Pattern 3: Return a result object
record ValidationResult(bool Valid, List<string> Errors);

static ValidationResult ValidatePassword(string password)
{
    var errors = new List<string>();
    if (password.Length < 8)
        errors.Add("Must be at least 8 characters");
    if (!password.Any(char.IsUpper))
        errors.Add("Must contain an uppercase letter");
    if (!password.Any(char.IsDigit))
        errors.Add("Must contain a digit");
    return new ValidationResult(errors.Count == 0, errors);
}

var result = ValidatePassword("abc");
if (!result.Valid)
    result.Errors.ForEach(e => Console.WriteLine($"  ❌ {e}"));