// Comprehensive exception throwing and catching tests
// Tests throw/catch from various contexts: operators, functions, lambdas,
// methods, [] operator, nested scopes, and with various value types.

// ============================================================
// Section 1: Throwing and catching different value types
// ============================================================

// Throw int
try {
  throw(42)
}
catch(e) {
  assert_equal(42, e)
}

// Throw string
try {
  throw("error message")
}
catch(e) {
  assert_equal("error message", e)
}

// Throw double
try {
  throw(3.14)
}
catch(e) {
  assert_equal(3.14, e)
}

// Throw bool
try {
  throw(true)
}
catch(e) {
  assert_equal(true, e)
}

// Throw a Vector (via named variable to preserve mutability)
auto thrown_vec = [1, 2, 3]
try {
  throw(thrown_vec)
}
catch(e) {
  assert_equal(3, e.size())
  assert_equal(1, e[0])
  assert_equal(2, e[1])
  assert_equal(3, e[2])
}

// Throw a Map (via named variable to preserve mutability)
auto thrown_map = ["key": 42]
try {
  throw(thrown_map)
}
catch(e) {
  assert_equal(42, e["key"])
}

// ============================================================
// Section 2: Typed catch blocks
// ============================================================

// Typed catch matching int
auto typed_result = 0
try {
  throw(10)
}
catch(int e) {
  typed_result = e + 1
}
assert_equal(11, typed_result)

// Typed catch matching string
typed_result = 0
try {
  throw("hello")
}
catch(string e) {
  typed_result = 1
}
assert_equal(1, typed_result)

// Typed catch mismatch falls through to untyped
typed_result = 0
try {
  throw(42)
}
catch(string e) {
  typed_result = 1
}
catch(e) {
  typed_result = 2
}
assert_equal(2, typed_result)

// Multiple typed catches - first match wins
typed_result = 0
try {
  throw("test")
}
catch(int e) {
  typed_result = 1
}
catch(string e) {
  typed_result = 2
}
catch(e) {
  typed_result = 3
}
assert_equal(2, typed_result)

// Typed catch with int, multiple typed blocks, none match except untyped
typed_result = 0
try {
  throw(3.14)
}
catch(int e) {
  typed_result = 1
}
catch(string e) {
  typed_result = 2
}
catch(e) {
  typed_result = 3
}
assert_equal(3, typed_result)

// ============================================================
// Section 3: Catch-all (no variable) catch block
// ============================================================

auto catch_all_reached = false
try {
  throw(99)
}
catch {
  catch_all_reached = true
}
assert_true(catch_all_reached)

// ============================================================
// Section 4: Finally block semantics
// ============================================================

// Finally runs after exception
auto finally_ran = false
try {
  throw(1)
}
catch(e) {
  // caught
}
finally {
  finally_ran = true
}
assert_true(finally_ran)

// Finally runs without exception
finally_ran = false
try {
  auto x = 1
}
catch(e) {
  // not reached
}
finally {
  finally_ran = true
}
assert_true(finally_ran)

// Finally runs even with typed catch that matches
finally_ran = false
try {
  throw(42)
}
catch(int e) {
  assert_equal(42, e)
}
finally {
  finally_ran = true
}
assert_true(finally_ran)

// Finally runs when typed catch does NOT match (exception not caught)
finally_ran = false
auto outer_caught = false
try {
  try {
    throw(42)
  }
  catch(string e) {
    // wrong type, won't match
  }
  finally {
    finally_ran = true
  }
}
catch(e) {
  outer_caught = true
}
assert_true(finally_ran)
assert_true(outer_caught)

// ============================================================
// Section 5: Throwing from functions
// ============================================================

def throwing_function() {
  throw("from function")
}

try {
  throwing_function()
}
catch(e) {
  assert_equal("from function", e)
}

// Throwing from nested function calls
def inner_throw() {
  throw("inner")
}

def outer_call() {
  inner_throw()
}

try {
  outer_call()
}
catch(e) {
  assert_equal("inner", e)
}

// Function that throws conditionally
def conditional_throw(should_throw) {
  if (should_throw) {
    throw("conditional")
  }
  return "no throw"
}

assert_equal("no throw", conditional_throw(false))

try {
  conditional_throw(true)
}
catch(e) {
  assert_equal("conditional", e)
}

// ============================================================
// Section 6: Throwing from lambdas
// ============================================================

auto throwing_lambda = fun() { throw("from lambda") }

try {
  throwing_lambda()
}
catch(e) {
  assert_equal("from lambda", e)
}

// Lambda that captures and throws
auto captured_val = "captured"
auto capture_lambda = fun[captured_val]() { throw(captured_val) }

try {
  capture_lambda()
}
catch(e) {
  assert_equal("captured", e)
}

// ============================================================
// Section 7: Throwing from binary operators
// ============================================================

// Define a type and an operator that throws
attr ThrowOnAdd::val
def ThrowOnAdd::ThrowOnAdd(v) { this.val = v }

def `+`(ThrowOnAdd x, ThrowOnAdd y) {
  throw("add not supported")
}

try {
  auto a = ThrowOnAdd(1)
  auto b = ThrowOnAdd(2)
  auto c = a + b
  assert_true(false) // should not reach here
}
catch(e) {
  assert_equal("add not supported", e)
}

// Operator that throws for specific values
def `-`(ThrowOnAdd x, ThrowOnAdd y) {
  if (x.val == y.val) {
    throw("cannot subtract equal values")
  }
  return ThrowOnAdd(x.val - y.val)
}

try {
  auto a = ThrowOnAdd(5)
  auto b = ThrowOnAdd(5)
  auto c = a - b
  assert_true(false)
}
catch(e) {
  assert_equal("cannot subtract equal values", e)
}

// Multiplication operator that throws (not pre-defined for Dynamic_Object)
def `*`(ThrowOnAdd x, ThrowOnAdd y) {
  throw("multiply not supported")
}

try {
  auto a = ThrowOnAdd(1)
  auto b = ThrowOnAdd(2)
  auto c = a * b
  assert_true(false)
}
catch(e) {
  assert_equal("multiply not supported", e)
}

// Subtraction works for non-equal values
auto sub_result = ThrowOnAdd(10) - ThrowOnAdd(3)
assert_equal(7, sub_result.val)

// ============================================================
// Section 8: Throwing from unary/prefix operators
// ============================================================

def `++`(ThrowOnAdd x) {
  throw("increment not supported")
}

try {
  auto a = ThrowOnAdd(1)
  ++a
  assert_true(false)
}
catch(e) {
  assert_equal("increment not supported", e)
}

// ============================================================
// Section 9: Throwing from [] operator
// ============================================================

attr ThrowOnIndex::data
def ThrowOnIndex::ThrowOnIndex() { this.data = [1, 2, 3] }

def `[]`(ThrowOnIndex obj, int idx) {
  if (idx < 0) {
    throw("negative index not allowed")
  }
  return obj.data[idx]
}

auto toi = ThrowOnIndex()
assert_equal(1, toi[0])
assert_equal(2, toi[1])

try {
  auto val = toi[-1]
  assert_true(false)
}
catch(e) {
  assert_equal("negative index not allowed", e)
}

// ============================================================
// Section 10: Throwing from member functions
// ============================================================

attr Validatable::value
def Validatable::Validatable(v) { this.value = v }

def Validatable::validate() {
  if (this.value < 0) {
    throw("validation failed: negative value")
  }
  return true
}

auto valid_obj = Validatable(10)
assert_true(valid_obj.validate())

auto invalid_obj = Validatable(-1)
try {
  invalid_obj.validate()
  assert_true(false)
}
catch(e) {
  assert_equal("validation failed: negative value", e)
}

// ============================================================
// Section 11: Nested try/catch
// ============================================================

auto inner_caught = false
auto outer_caught_val = 0
try {
  try {
    throw(1)
  }
  catch(e) {
    inner_caught = true
    throw(e + 10)
  }
}
catch(e) {
  outer_caught_val = e
}
assert_true(inner_caught)
assert_equal(11, outer_caught_val)

// Deeply nested try/catch
auto depth = 0
try {
  try {
    try {
      throw("deep")
    }
    catch(e) {
      depth = 1
      throw(e + "er")
    }
  }
  catch(e) {
    depth = 2
    throw(e + "est")
  }
}
catch(e) {
  depth = 3
  assert_equal("deeperest", e)
}
assert_equal(3, depth)

// ============================================================
// Section 12: Rethrow from catch block
// ============================================================

auto rethrow_caught = false
try {
  try {
    throw("rethrown")
  }
  catch(e) {
    throw(e)
  }
}
catch(e) {
  rethrow_caught = true
  assert_equal("rethrown", e)
}
assert_true(rethrow_caught)

// ============================================================
// Section 13: Exception in for loop
// ============================================================

auto loop_exception_val = 0
try {
  for (auto i = 0; i < 10; ++i) {
    if (i == 5) {
      throw(i)
    }
  }
}
catch(e) {
  loop_exception_val = e
}
assert_equal(5, loop_exception_val)

// ============================================================
// Section 14: Exception in while loop
// ============================================================

auto while_exc_val = 0
auto counter = 0
try {
  while (true) {
    ++counter
    if (counter == 3) {
      throw(counter)
    }
  }
}
catch(e) {
  while_exc_val = e
}
assert_equal(3, while_exc_val)

// ============================================================
// Section 15: Exception preserves value through nested calls
// ============================================================

def deep_throw(val) {
  throw(val)
}

def middle_call(val) {
  deep_throw(val)
}

def top_call(val) {
  middle_call(val)
}

auto nested_map = ["key": "value"]
try {
  top_call(nested_map)
}
catch(e) {
  assert_equal("value", e["key"])
}

auto nested_vec = [10, 20, 30]
try {
  top_call(nested_vec)
}
catch(e) {
  assert_equal(3, e.size())
  assert_equal(20, e[1])
}

// ============================================================
// Section 16: Code after throw is not executed
// ============================================================

auto after_throw = false
try {
  throw(1)
  after_throw = true
}
catch(e) {
  // caught
}
assert_false(after_throw)

// ============================================================
// Section 17: Exception value is usable in catch block arithmetic
// ============================================================

auto catch_computed = 0
try {
  throw(1)
}
catch(e) {
  catch_computed = e + 100
}
assert_equal(101, catch_computed)

// ============================================================
// Section 18: No exception means catch is skipped
// ============================================================

auto catch_skipped = true
try {
  auto x = 42
}
catch(e) {
  catch_skipped = false
}
assert_true(catch_skipped)

// ============================================================
// Section 19: Exception from dynamic object method chaining
// ============================================================

attr Chain::val
def Chain::Chain(v) { this.val = v }

def Chain::add(n) {
  if (this.val + n > 100) {
    throw("overflow: " + to_string(this.val + n))
  }
  this.val = this.val + n
  return this
}

auto chain = Chain(50)
try {
  chain.add(30).add(30)
  assert_true(false)
}
catch(e) {
  assert_equal("overflow: 110", e)
}
assert_equal(80, chain.val)

// ============================================================
// Section 20: Exception thrown during map construction
// ============================================================

def exploding_value() {
  throw("boom during construction")
}

try {
  auto m = ["ok": 1, "bad": exploding_value()]
  assert_true(false)
}
catch(e) {
  assert_equal("boom during construction", e)
}

// ============================================================
// Section 21: Exception thrown during vector construction
// ============================================================

try {
  auto v = [1, 2, exploding_value(), 4]
  assert_true(false)
}
catch(e) {
  assert_equal("boom during construction", e)
}

// ============================================================
// Section 22: Exception in if-condition
// ============================================================

def exploding_condition() {
  throw("condition exploded")
}

try {
  if (exploding_condition()) {
    assert_true(false)
  }
}
catch(e) {
  assert_equal("condition exploded", e)
}

// ============================================================
// Section 23: Multiple catch blocks - only first matching runs
// ============================================================

auto catch_count = 0
try {
  throw(42)
}
catch(int e) {
  ++catch_count
}
catch(e) {
  ++catch_count
}
assert_equal(1, catch_count)

// ============================================================
// Section 24: Throwing from within catch, with finally
// ============================================================

auto s24_finally = false
auto s24_outer = false
try {
  try {
    throw("original")
  }
  catch(e) {
    throw("replaced: " + e)
  }
  finally {
    s24_finally = true
  }
}
catch(e) {
  s24_outer = true
  assert_equal("replaced: original", e)
}
assert_true(s24_finally)
assert_true(s24_outer)

// ============================================================
// Section 25: Unhandled typed catch propagates exception
// ============================================================

auto s25_caught = false
try {
  try {
    throw(3.14)
  }
  catch(int e) {
    assert_true(false) // should not match double
  }
  catch(string e) {
    assert_true(false) // should not match double
  }
}
catch(e) {
  s25_caught = true
  assert_equal(3.14, e)
}
assert_true(s25_caught)

// ============================================================
// Section 26: Throw from range-based for
// ============================================================

auto s26_val = 0
try {
  for (x : [10, 20, 30, 40]) {
    if (x == 30) {
      throw(x)
    }
  }
}
catch(e) {
  s26_val = e
}
assert_equal(30, s26_val)

// ============================================================
// Section 27: Throw from eval
// ============================================================

try {
  eval("throw(\"from eval\")")
}
catch(e) {
  assert_equal("from eval", e)
}

// ============================================================
// Section 28: Exception from built-in operations (out of range)
// ============================================================

auto s28_caught = false
try {
  auto v = [1, 2, 3]
  auto x = v[10]
}
catch(e) {
  s28_caught = true
}
assert_true(s28_caught)

// ============================================================
// Section 29: Throw zero and empty string (falsy values)
// ============================================================

try {
  throw(0)
}
catch(e) {
  assert_equal(0, e)
}

try {
  throw("")
}
catch(e) {
  assert_equal("", e)
}

// ============================================================
// Section 30: Throw from ternary-style inline_if
// ============================================================

def maybe_throw(do_it) {
  if (do_it) { throw("inline threw") } else { "ok" }
}

try {
  maybe_throw(true)
}
catch(e) {
  assert_equal("inline threw", e)
}
assert_equal("ok", maybe_throw(false))

// ============================================================
// Section 31: Verify catch variable scope isolation
// ============================================================

auto outer_e = "untouched"
try {
  throw("caught_value")
}
catch(e) {
  assert_equal("caught_value", e)
}
assert_equal("untouched", outer_e)

// ============================================================
// Section 32: Exception from recursive function
// ============================================================

def recursive_throw(n) {
  if (n == 0) {
    throw("bottom")
  }
  recursive_throw(n - 1)
}

try {
  recursive_throw(5)
}
catch(e) {
  assert_equal("bottom", e)
}

// ============================================================
// Section 33: Try/catch in a function body
// ============================================================

def safe_divide(a, b) {
  try {
    if (b == 0) {
      throw("division by zero")
    }
    return a / b
  }
  catch(e) {
    return e
  }
}

assert_equal(5, safe_divide(10, 2))
assert_equal("division by zero", safe_divide(10, 0))

// ============================================================
// Section 34: Throw from [] on a Map with missing key
// ============================================================

auto s34_caught = false
try {
  auto m = ["a": 1]
  auto x = m["nonexistent"]
}
catch(e) {
  s34_caught = true
}
assert_true(s34_caught)

// ============================================================
// Section 35: Arithmetic exception (divide by zero)
// ============================================================

auto s35_caught = false
try {
  auto x = 1 / 0
}
catch(e) {
  s35_caught = true
}
assert_true(s35_caught)