plum

import std/Option
import std/Bool
import std/Str
import std/Number

enum Point =
  | Point(x: Int, y: Int)

enum Named(ToStr) =
  | Named(name: Str)

  fun toStr(self) -> Str =
    self.name

enum Box[T] =
  | Box(value: T)

trait Shape =
  area() -> Float
  perimeter() -> Float

# Named distinctly from the real `Comparable`/`Ord` traits `libs/std/str.plum`
# claims to (but never actually implements — see its own header comment) —
# both are now genuinely reachable in the SAME merged program (`str.plum` is
# an always-implicit prelude, see `plum-core::loader::loadAndMerge`), and
# `checkTraitConformance` matches purely by bare trait name, so reusing
# "Comparable" here would make ITS unrelated demo declaration the thing that
# suddenly enforces (and fails) `Str`'s own long-standing, deliberately
# unenforced claim.
trait DemoComparable[T: Ord] =
  compareTo(other: T) -> Int

enum Color =
  | Red
  | Green
  | Blue

# A bare enum variant name can be used directly as a type: `v: Red` means
# "a `Color` value that is specifically the `Red` variant".
fun stringifyColor(v: Red) -> Str =
  "Red"

fun makeIntBox() -> Box =
  Box(value: 5)

fun makeStrBox() -> Box =
  Box(value: "x")

# ---- record-shaped and sum-type enum regression tests ----

enum Cat =
  | Cat(name: Str, age: Int)

  fun getAge() -> Int =
    self.age

enum Dog =
  | Dog(name: Str, age: Int)

  fun getAge(self) -> Int =
    self.age

enum Pair =
  | Pair(a: Int, b: Int)

enum Wrapper =
  | Wrapper(inner: Pair, tag: Int)

enum LoopBox =
  | LoopBox(v: Int)

fun sumLoopBoxes() -> Int =
  total := 0
  for i := range 5
    b := LoopBox(v: i)
    total = total + b.v
  return total

enum Step(n: Int) =
  | ReadMin(10)
  | ReadMax(20)

  fun toNumber(self) -> Int =
    self.n

fun stepToNumber(s: Step) -> Int =
  match s
    ReadMin => 1
    ReadMax => 2

fun unwrapOptionOr(o: Option[Int], default: Int) -> Int =
  match o
    Some(v) =>
      return v
    None =>
      return default

enum ShapeKind =
  | Rect(Int, Int)
  | Circle(Int)

fun area(s: ShapeKind) -> Int =
  match s
    Rect(w, h) =>
      return w * h
    Circle(r) =>
      return r * r

enum Vec2 =
  | Vec2(x: Int, y: Int)

enum ShapeWithFields =
  | CircleField(radius: Int)
  | SquareField(side: Int)

fun numberKind(n: Number) -> Str =
  n.kind()

enum OptionBox =
  | OptionBox(value: Option[Int])

  fun unwrap(default: Int) -> Int =
    match self.value
      Some(v) =>
        return v
      None =>
        return default

test "class field and method run correctly"
  c := Cat(name: "x", age: 7)
  assert c.getAge() == 7

test "nested method declaration runs correctly"
  d := Dog(name: "x", age: 7)
  assert d.getAge() == 7

test "nested class call runs correctly"
  w := Wrapper(inner: Pair(a: 11, b: 22), tag: 99)
  assert w.inner.b == 22

test "repeated class call in a loop does not alias"
  # Regression test: class instances are bump-allocated at *runtime* (via a
  # mutable wasm global), not at a compile-time-fixed address — otherwise
  # every iteration's `LoopBox(...)` would alias the same memory and this
  # would sum to 5*4=20 instead of 0+1+2+3+4=10.
  assert sumLoopBoxes() == 10

test "enum discriminant value field access runs correctly for each variant"
  assert ReadMin.toNumber() * 100 + ReadMax.toNumber() == 1020

test "enum discriminant value matches by variant name correctly"
  assert stepToNumber(ReadMin) * 10 + stepToNumber(ReadMax) == 12

test "payload variant construction compiles and runs"
  assert unwrapOptionOr(Some(7), 0) == 7

test "multi field variant construction compiles and runs"
  assert area(Rect(3, 4)) == 12

test "single-variant named-payload enum field access works like a class"
  # `Vec2` has exactly one variant, so its fields unambiguously describe
  # every `Vec2` value — `.x`/`.y` resolve directly, no `match` needed,
  # for both named and positional construction.
  named := Vec2(x: 1, y: 2)
  positional := Vec2(3, 4)
  assert named.x == 1
  assert named.y == 2
  assert positional.x == 3
  assert positional.y == 4

test "named-payload field access on a multi-variant enum value works via a checked downcast"
  # Unlike `Vec2` above, `ShapeWithFields` has more than one variant — `.field`
  # here isn't statically provable to always succeed the way it is on a
  # single-variant enum. It's still allowed because `radius`/`side` each
  # belong to exactly one variant (no ambiguity) — codegen compiles it as a
  # ref.cast down to that one variant's own struct, which would trap at
  # runtime if the value were ever the OTHER variant instead.
  c := CircleField(radius: 5)
  s := SquareField(side: 9)
  assert c.radius == 5
  assert s.side == 9

test "enum variant used directly as a type checks and runs correctly"
  assert stringifyColor(Red) == "Red"

test "a bare Int/Float value flows into a Number-typed param with no wrapper syntax"
  assert numberKind(5) == "Int"
  assert numberKind(2.5) == "Float"

test "a bare Int/Float value dispatches a method defined only on Number, via fallback"
  # `.kind()` isn't defined on `Int`/`Float` themselves — dispatch falls back
  # to `Number`, the enum that bare-wraps them, boxing `self` first.
  assert {5}.kind() == "Int"
  assert {2.5}.kind() == "Float"

test "enum class field construct and destructure runs correctly"
  b := OptionBox(value: Some(42))
  assert b.unwrap(0) == 42

test "class field mutation and spread update run correctly"
  p := Point(x: 1, y: 2)
  p.x = 10
  assert p.x == 10
  assert p.y == 2
  p2 := Point(..p, x: 100)
  assert p2.x == 100
  assert p2.y == 2
  # the spread source is untouched by the update it fed
  assert p.x == 10

test "single-variant named-payload enum field mutation and spread update run correctly"
  v := Vec2(x: 1, y: 2)
  v.x = 10
  assert v.x == 10
  assert v.y == 2
  v2 := Vec2(..v, x: 100)
  assert v2.x == 100
  assert v2.y == 2
  assert v.x == 10

test "multi-variant enum field mutation and spread update run correctly"
  # Same checked-downcast idiom `.field` reads already use on a
  # multi-variant enum's uniquely-owned field name (see the test above
  # about `ShapeWithFields`) — traps at runtime if the value is ever the
  # OTHER variant, no static proof required.
  c := CircleField(radius: 5)
  c.radius = 9
  assert c.radius == 9
  c2 := CircleField(..c, radius: 50)
  assert c2.radius == 50
  assert c.radius == 9

test "gc type registry produces a well formed type section alongside bump allocator codegen"
  # Task 1 Step 5 of the wasm-gc migration plan: the wasm-gc type registry
  # emits a well-formed type section — a struct type per class, a
  # supertype+subtypes set per enum, and a shared Str array type — even
  # though the rest of a compiled module uses a different representation.
  # This proves the still-untouched bump-allocator codegen actually runs
  # correctly alongside it, not just that it compiles.
  c := Cat(name: "x", age: 7)
  assert c.getAge() == 7