// Basic enum class definition (default underlying type: int)
enum class Color { Red, Green, Blue }

// Access via :: syntax
auto r = Color::Red
auto g = Color::Green
auto b = Color::Blue

// Equality and inequality
assert_true(Color::Red == Color::Red)
assert_false(Color::Red == Color::Green)
assert_true(Color::Red != Color::Green)
assert_false(Color::Red != Color::Red)

// Constructor from valid underlying value
auto c = Color::Color(1)
assert_true(c == Color::Green)

// Constructor from invalid value throws
try {
  Color::Color(52)
  assert_true(false)
} catch(e) {
  // expected
}

// Strong typing: function with typed parameter
def takes_color(Color val) { val }
takes_color(Color::Red)
takes_color(Color::Green)
takes_color(Color::Color(2))

// Cannot pass int where Color is expected
try {
  takes_color(52)
  assert_true(false)
} catch(e) {
  // expected: dispatch error
}

// to_underlying accessor
assert_equal(0, Color::Red.to_underlying())
assert_equal(1, Color::Green.to_underlying())
assert_equal(2, Color::Blue.to_underlying())

// Enum class with explicit values
enum class Priority { Low = 10, Medium = 20, High = 30 }
assert_equal(10, Priority::Low.to_underlying())
assert_equal(20, Priority::Medium.to_underlying())
assert_equal(30, Priority::High.to_underlying())

auto p = Priority::Priority(20)
assert_true(p == Priority::Medium)

// Mixed auto and explicit values
enum class Status { Pending, Active = 5, Done }
assert_equal(0, Status::Pending.to_underlying())
assert_equal(5, Status::Active.to_underlying())
assert_equal(6, Status::Done.to_underlying())

// Switch on enum values
var result = ""
switch(Color::Green) {
  case (Color::Red) {
    result = "red"
    break
  }
  case (Color::Green) {
    result = "green"
    break
  }
  case (Color::Blue) {
    result = "blue"
    break
  }
}
assert_equal("green", result)

// Switch on enum with explicit values
var prio_result = ""
switch(Priority::High) {
  case (Priority::Low) {
    prio_result = "low"
    break
  }
  case (Priority::Medium) {
    prio_result = "medium"
    break
  }
  case (Priority::High) {
    prio_result = "high"
    break
  }
}
assert_equal("high", prio_result)

// Enum class with explicit underlying type
enum class Flags : char { Read = 1, Write = 2, Execute = 4 }
assert_equal(1, Flags::Read.to_underlying())
assert_equal(2, Flags::Write.to_underlying())
assert_equal(4, Flags::Execute.to_underlying())

auto f = Flags::Flags(2)
assert_true(f == Flags::Write)

// enum struct syntax (equivalent to enum class, like C++)
enum struct Direction { North, East, South, West }
assert_equal(0, Direction::North.to_underlying())
assert_equal(3, Direction::West.to_underlying())
assert_true(Direction::East != Direction::South)