🛡️ Lesson 7.1: Try, Catch, and Finally

# Division by zero
result = 10 / 0       # ZeroDivisionError: division by zero

# Bad type conversion
number = int("banana")  # ValueError: invalid literal for int()

# Accessing a missing key
data = {"name": "Alice"}
print(data["age"])     # KeyError: 'age'

# Accessing a missing index
items = [1, 2, 3]
print(items[10])       # IndexError: list index out of range

# Using an undefined variable
print(unknown_var)     # NameError: name 'unknown_var' is not defined

# Opening a file that doesn't exist
f = open("nope.txt")  # FileNotFoundError: No such file or directory

// Accessing a property on null/undefined
let user = null;
console.log(user.name);    // TypeError: Cannot read properties of null

// Bad JSON parsing
JSON.parse("not json");    // SyntaxError: Unexpected token

// Calling a non-function
let x = 42;
x();                       // TypeError: x is not a function

// Using an undeclared variable (in strict mode)
"use strict";
console.log(unknownVar);   // ReferenceError: unknownVar is not defined

// Stack overflow (infinite recursion)
function loop() { loop(); }
loop();                    // RangeError: Maximum call stack size exceeded

// Note: JS division by zero gives Infinity, NOT an error
console.log(10 / 0);      // Infinity (no error thrown!)

// Division by zero (integers only — doubles give Infinity)
int result = 10 / 0;        // DivideByZeroException

// Bad type conversion
int number = int.Parse("banana");  // FormatException

// Null reference
string name = null;
Console.WriteLine(name.Length);    // NullReferenceException

// Index out of range
int[] items = { 1, 2, 3 };
Console.WriteLine(items[10]);      // IndexOutOfRangeException

// File not found
string text = File.ReadAllText("nope.txt");  // FileNotFoundException

// Invalid cast
object obj = "hello";
int bad = (int)obj;                // InvalidCastException

# Python uses try/except (not try/catch!)
try:
    number = int(input("Enter a number: "))
    result = 100 / number
    print(f"100 / {number} = {result}")
except:
    print("Something went wrong!")

print("Program continues running!")  # This ALWAYS runs

# --- Example run with "banana" ---
# Enter a number: banana
# Something went wrong!
# Program continues running!

# --- Example run with 0 ---
# Enter a number: 0
# Something went wrong!
# Program continues running!

# --- Example run with 5 ---
# Enter a number: 5
# 100 / 5 = 20.0
# Program continues running!

// JavaScript uses try/catch
try {
    let input = "banana";  // Simulating bad user input
    let number = Number(input);
    if (isNaN(number)) {
        throw new Error("Not a valid number!");
    }
    let result = 100 / number;
    console.log(`100 / ${number} = ${result}`);
} catch (error) {
    console.log("Something went wrong!");
}

console.log("Program continues running!");

// Note: JS needs manual validation for number conversion.
// Number("banana") returns NaN instead of throwing an error.
// We use 'throw' to create our own error — more on this in Lesson 20.

// --- Output ---
// Something went wrong!
// Program continues running!

// C# uses try/catch
try
{
    Console.Write("Enter a number: ");
    int number = int.Parse(Console.ReadLine()!);
    int result = 100 / number;
    Console.WriteLine($"100 / {number} = {result}");
}
catch (Exception e)
{
    Console.WriteLine("Something went wrong!");
}

Console.WriteLine("Program continues running!");

// --- Example run with "banana" ---
// Enter a number: banana
// Something went wrong!
// Program continues running!

# finally always runs — perfect for cleanup
def read_config(filename):
    file = None
    try:
        file = open(filename, "r")
        data = file.read()
        print(f"Read {len(data)} characters")
        return data
    except FileNotFoundError:
        print(f"File '{filename}' not found!")
        return None
    finally:
        # This runs even after a return statement!
        if file:
            file.close()
            print("File closed.")
        print("Cleanup complete.")

# Test with a missing file
result = read_config("settings.txt")
# File 'settings.txt' not found!
# Cleanup complete.

# --- With try/except/else/finally ---
try:
    number = int("42")
except ValueError:
    print("Not a number!")
else:
    # Only runs if NO exception occurred
    print(f"Converted successfully: {number}")
finally:
    # Always runs
    print("Done!")

# Output:
# Converted successfully: 42
# Done!

// finally always runs — perfect for cleanup
function readConfig(filename) {
    let connection = null;
    try {
        // Simulate opening a resource
        connection = { name: filename, open: true };
        console.log(`Reading ${filename}...`);

        // Simulate an error for missing files
        if (filename === "missing.txt") {
            throw new Error(`File '${filename}' not found!`);
        }

        console.log("File read successfully!");
        return "file contents";

    } catch (error) {
        console.log(`Error: ${error.message}`);
        return null;

    } finally {
        // This runs even after a return!
        if (connection) {
            connection.open = false;
            console.log("Connection closed.");
        }
        console.log("Cleanup complete.");
    }
}

readConfig("missing.txt");
// Reading missing.txt...
// Error: File 'missing.txt' not found!
// Connection closed.
// Cleanup complete.

readConfig("settings.txt");
// Reading settings.txt...
// File read successfully!
// Connection closed.
// Cleanup complete.

// finally always runs — perfect for cleanup
static string? ReadConfig(string filename)
{
    StreamReader? reader = null;
    try
    {
        reader = new StreamReader(filename);
        string data = reader.ReadToEnd();
        Console.WriteLine($"Read {data.Length} characters");
        return data;
    }
    catch (FileNotFoundException)
    {
        Console.WriteLine($"File '{filename}' not found!");
        return null;
    }
    finally
    {
        // This runs even after a return!
        reader?.Close();
        Console.WriteLine("Cleanup complete.");
    }
}

ReadConfig("settings.txt");
// File 'settings.txt' not found!
// Cleanup complete.

// --- try/catch/finally together ---
try
{
    int number = int.Parse("42");
    Console.WriteLine($"Converted: {number}");
}
catch (FormatException)
{
    Console.WriteLine("Not a number!");
}
finally
{
    Console.WriteLine("Done!");
}
// Converted: 42
// Done!

def safe_divide(a, b):
    try:
        result = a / b
        return result
    except ZeroDivisionError:
        print("Can't divide by zero!")
        return None
    except TypeError:
        print(f"Can't divide {type(a).__name__} by {type(b).__name__}!")
        return None

print(safe_divide(10, 3))      # 3.333...
print(safe_divide(10, 0))      # Can't divide by zero! → None
print(safe_divide("10", 3))    # Can't divide str by int! → None

# --- Multiple except blocks: order matters ---
def get_value(data, key, index):
    try:
        return data[key][index]
    except KeyError:
        print(f"Key '{key}' not found in data")
    except IndexError:
        print(f"Index {index} is out of range")
    except TypeError:
        print(f"Wrong type — can't index into this")

scores = {"math": [95, 87, 92], "english": [88, 91]}

get_value(scores, "math", 1)      # Returns 87
get_value(scores, "science", 0)   # Key 'science' not found in data
get_value(scores, "math", 10)     # Index 10 is out of range

# --- Catching multiple types in one block ---
try:
    value = int("banana")
except (ValueError, TypeError) as e:
    print(f"Conversion error: {e}")
# Conversion error: invalid literal for int() with base 10: 'banana'

// JS catch gets ONE block — use instanceof to differentiate
function safeParse(jsonString) {
    try {
        return JSON.parse(jsonString);
    } catch (error) {
        if (error instanceof SyntaxError) {
            console.log("Invalid JSON format!");
        } else if (error instanceof TypeError) {
            console.log("Wrong input type!");
        } else {
            console.log(`Unexpected error: ${error.message}`);
        }
        return null;
    }
}

safeParse('{"name": "Alice"}');  // Returns { name: "Alice" }
safeParse("not json at all");    // Invalid JSON format! → null
safeParse(undefined);            // Wrong input type! → null

// --- Common pattern: validate then throw ---
function getElement(arr, index) {
    try {
        if (!Array.isArray(arr)) {
            throw new TypeError("Expected an array");
        }
        if (index < 0 || index >= arr.length) {
            throw new RangeError(`Index ${index} out of bounds (0-${arr.length - 1})`);
        }
        return arr[index];
    } catch (error) {
        if (error instanceof TypeError) {
            console.log(`Type error: ${error.message}`);
        } else if (error instanceof RangeError) {
            console.log(`Range error: ${error.message}`);
        }
        return undefined;
    }
}

getElement([10, 20, 30], 1);    // Returns 20
getElement("not array", 0);     // Type error: Expected an array
getElement([10, 20], 5);        // Range error: Index 5 out of bounds (0-1)

// C# supports multiple catch blocks with specific types
static int? SafeConvert(string input)
{
    try
    {
        return int.Parse(input);
    }
    catch (FormatException)
    {
        Console.WriteLine($"'{input}' is not a valid number!");
        return null;
    }
    catch (OverflowException)
    {
        Console.WriteLine($"'{input}' is too large or too small!");
        return null;
    }
    catch (ArgumentNullException)
    {
        Console.WriteLine("Input cannot be null!");
        return null;
    }
}

SafeConvert("42");                // Returns 42
SafeConvert("banana");            // 'banana' is not a valid number!
SafeConvert("99999999999999");    // Too large or too small!

// --- Order matters: most specific FIRST ---
try
{
    int[] items = { 1, 2, 3 };
    Console.WriteLine(items[10]);
}
catch (IndexOutOfRangeException e)
{
    // Specific catch — handles this exact error type
    Console.WriteLine($"Bad index: {e.Message}");
}
catch (Exception e)
{
    // General catch — catches anything else
    Console.WriteLine($"Something else went wrong: {e.Message}");
}
// C# enforces order: specific exceptions before general ones.
// Putting catch(Exception) first would be a compile error!

try:
    result = 10 / 0
except ZeroDivisionError as e:
    # The error object
    print(f"Type:    {type(e).__name__}")   # ZeroDivisionError
    print(f"Message: {e}")                  # division by zero
    print(f"Args:    {e.args}")             # ('division by zero',)

print()

# Get the full traceback (stack trace)
import traceback

try:
    data = {"a": [1, 2, 3]}
    value = data["b"][0]
except KeyError as e:
    print(f"Error: Key {e} not found")
    print("--- Stack Trace ---")
    traceback.print_exc()

# --- Output ---
# Error: Key 'b' not found
# --- Stack Trace ---
# Traceback (most recent call last):
#   File "example.py", line 13, in <module>
#     value = data["b"][0]
# KeyError: 'b'

try {
    JSON.parse("not valid json");
} catch (error) {
    // The error object
    console.log(`Name:    ${error.name}`);     // SyntaxError
    console.log(`Message: ${error.message}`);  // Unexpected token...
    console.log(`Stack:   ${error.stack}`);    // Full stack trace

    // error.stack includes the name, message, AND call locations
}

// --- All JS error types have: name, message, stack ---

try {
    null.toString();
} catch (error) {
    console.log(error.name);     // TypeError
    console.log(error.message);  // Cannot read properties of null
}

try {
    undeclaredVar;
} catch (error) {
    console.log(error.name);     // ReferenceError
    console.log(error.message);  // undeclaredVar is not defined
}

try
{
    int result = int.Parse("banana");
}
catch (FormatException e)
{
    // The exception object
    Console.WriteLine($"Type:    {e.GetType().Name}");   // FormatException
    Console.WriteLine($"Message: {e.Message}");          // Input string was...
    Console.WriteLine($"Source:  {e.Source}");            // System.Private.CoreLib
    Console.WriteLine($"Stack:\n{e.StackTrace}");        // Full stack trace
}

// --- InnerException: errors caused by other errors ---
try
{
    try
    {
        int.Parse("banana");
    }
    catch (FormatException inner)
    {
        // Wrap the original error with more context
        throw new InvalidOperationException("Config parsing failed", inner);
    }
}
catch (InvalidOperationException e)
{
    Console.WriteLine($"Outer: {e.Message}");  // Config parsing failed
    Console.WriteLine($"Inner: {e.InnerException?.Message}");
    // Inner: The input string 'banana' was not in a correct format.
}

# ❌ BAD: Silently swallowing errors
try:
    result = dangerous_operation()
except:
    pass  # Errors vanish — bugs become invisible!

# ✅ GOOD: At minimum, log the error
try:
    result = dangerous_operation()
except Exception as e:
    print(f"Error: {e}")  # Now you know something went wrong
    # Or: logging.error(f"Operation failed: {e}")

// ❌ BAD: Silently swallowing errors
try {
    result = dangerousOperation();
} catch (error) {
    // Nothing here — bugs become invisible!
}

// ✅ GOOD: At minimum, log the error
try {
    result = dangerousOperation();
} catch (error) {
    console.error("Operation failed:", error.message);
}

// ❌ BAD: Silently swallowing errors
try
{
    DangerousOperation();
}
catch { }  // Errors vanish!

// ✅ GOOD: At minimum, log the error
try
{
    DangerousOperation();
}
catch (Exception e)
{
    Console.Error.WriteLine($"Operation failed: {e.Message}");
}

# ❌ BAD: Catching everything hides real bugs
try:
    users = load_users()      # Might raise FileNotFoundError
    first = users[0]          # Might raise IndexError
    name = first.name         # Might raise AttributeError
    print(greet(name))        # Might raise TypeError
except:
    print("Something went wrong")  # But WHAT went wrong?!

# ✅ GOOD: Catch only what you expect
try:
    users = load_users()
except FileNotFoundError:
    print("Users file not found — using defaults")
    users = []

# Let unexpected errors (IndexError, AttributeError) crash
# so you can find and fix the real bug!

// ❌ BAD: Catching everything hides bugs
try {
    let users = loadUsers();
    let first = users[0];
    let name = first.name;
    console.log(greet(name));
} catch (error) {
    console.log("Something went wrong");  // But WHAT?!
}

// ✅ GOOD: Wrap only the risky part, handle specifically
let users;
try {
    users = loadUsers();  // Only wrap the part that might fail
} catch (error) {
    console.log("Could not load users — using defaults");
    users = [];
}

// Other bugs will throw naturally and you'll see them

// ❌ BAD: Catching the base Exception hides bugs
try
{
    var users = LoadUsers();
    var first = users[0];
    Console.WriteLine(Greet(first.Name));
}
catch (Exception)
{
    Console.WriteLine("Something went wrong");  // WHAT?!
}

// ✅ GOOD: Catch only what you expect
List<User> users;
try
{
    users = LoadUsers();
}
catch (FileNotFoundException)
{
    Console.WriteLine("Users file not found — using defaults");
    users = new List<User>();
}
// IndexOutOfRangeException, NullReferenceException etc. 
// will still crash — and that's GOOD because those are bugs!

# ❌ BAD: Using exceptions like if/else
def find_user(users, name):
    try:
        for user in users:
            if user.name == name:
                return user
        raise ValueError("Not found")  # Don't do this!
    except ValueError:
        return None

# ✅ GOOD: Just use normal control flow
def find_user(users, name):
    for user in users:
        if user.name == name:
            return user
    return None  # Simple and clear

// ❌ BAD: Using exceptions like if/else
function findUser(users, name) {
    try {
        for (let user of users) {
            if (user.name === name) return user;
        }
        throw new Error("Not found");
    } catch (error) {
        return null;
    }
}

// ✅ GOOD: Just use normal control flow
function findUser(users, name) {
    return users.find(u => u.name === name) || null;
}

// ❌ BAD: Using exceptions like if/else
static User? FindUser(List<User> users, string name)
{
    try
    {
        foreach (var user in users)
            if (user.Name == name) return user;
        throw new Exception("Not found");
    }
    catch { return null; }
}

// ✅ GOOD: Just use normal control flow
static User? FindUser(List<User> users, string name)
{
    return users.FirstOrDefault(u => u.Name == name);
}

import random
import time

def unreliable_service():
    """Simulates a service that fails 60% of the time"""
    if random.random() < 0.6:
        raise ConnectionError("Server unavailable")
    return {"status": "ok", "data": [1, 2, 3]}

def fetch_with_retry(max_attempts=3, delay=1):
    for attempt in range(1, max_attempts + 1):
        try:
            result = unreliable_service()
            print(f"✅ Success on attempt {attempt}!")
            return result
        except ConnectionError as e:
            print(f"❌ Attempt {attempt} failed: {e}")
            if attempt < max_attempts:
                print(f"   Retrying in {delay} second(s)...")
                time.sleep(delay)
            else:
                print("💀 All attempts failed!")
                return None

# Run it
data = fetch_with_retry()
if data:
    print(f"Got data: {data}")
else:
    print("Could not reach the service")

function unreliableService() {
    if (Math.random() < 0.6) {
        throw new Error("Server unavailable");
    }
    return { status: "ok", data: [1, 2, 3] };
}

function fetchWithRetry(maxAttempts = 3, delay = 1000) {
    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
        try {
            let result = unreliableService();
            console.log(`✅ Success on attempt ${attempt}!`);
            return result;
        } catch (error) {
            console.log(`❌ Attempt ${attempt} failed: ${error.message}`);
            if (attempt < maxAttempts) {
                console.log(`   Retrying...`);
                // In real code, you'd use async/await with a delay
            } else {
                console.log("💀 All attempts failed!");
                return null;
            }
        }
    }
}

let data = fetchWithRetry();
if (data) {
    console.log("Got data:", data);
} else {
    console.log("Could not reach the service");
}

static Random rng = new();

static Dictionary<string, object> UnreliableService()
{
    if (rng.NextDouble() < 0.6)
        throw new HttpRequestException("Server unavailable");
    return new() { ["status"] = "ok", ["data"] = new[] { 1, 2, 3 } };
}

static Dictionary<string, object>? FetchWithRetry(int maxAttempts = 3, int delayMs = 1000)
{
    for (int attempt = 1; attempt <= maxAttempts; attempt++)
    {
        try
        {
            var result = UnreliableService();
            Console.WriteLine($"✅ Success on attempt {attempt}!");
            return result;
        }
        catch (HttpRequestException e)
        {
            Console.WriteLine($"❌ Attempt {attempt} failed: {e.Message}");
            if (attempt < maxAttempts)
            {
                Console.WriteLine($"   Retrying in {delayMs}ms...");
                Thread.Sleep(delayMs);
            }
            else
            {
                Console.WriteLine("💀 All attempts failed!");
                return null;
            }
        }
    }
    return null;
}

var data = FetchWithRetry();
Console.WriteLine(data != null ? "Got data!" : "Could not reach the service");