plum

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

enum Color =
  | Red
  | Green
  | Blue

fun describeNumber(n: Int) -> Str =
  match n
    0 => "zero"
    1 => "one"
    _ => "many"

fun describeBool(b: Bool) -> Int =
  match b
    True => 1
    False => 0

fun bindExample(n: Int) -> Int =
  match n
    x => x

fun describeColor(c: Color) -> Str =
  match c
    Red => "red"
    Green => "green"
    Blue => "blue"

# A dedicated, non-generic "maybe an Int" — as opposed to the real, generic
# `Option[T]` (`import std/option` above, used elsewhere in this file):
# constructing a bare payload-free variant (`Absent` here, `None` for a real
# generic enum) outside of a `match` pattern can't be disambiguated between
# multiple concrete instantiations of ITS enum from that expression alone
# (see the README's Generics section) — and since this file's forced-in
# stdlib prelude (`plum-core::loader::loadAndMerge`) uses `Option` at several
# OTHER concrete types internally, a bare `None` here genuinely IS
# ambiguous. `IntOpt` sidesteps that entirely by only ever having ONE
# possible instantiation to begin with.
enum IntOpt =
  | Present(Int)
  | Absent

fun describeOption(opt: IntOpt) -> Int =
  match opt
    Present(v) => v
    Absent => 0

fun main() -> Int =
  describeOption(Present(5))

# ---- pattern matching regression tests ----

enum Nested =
  | Wrap(IntOpt)
  | Empty

fun unwrapNested(n: Nested) -> Int =
  match n
    Wrap(Present(v)) => v
    Wrap(Absent) => -1
    Empty => 0

enum GenericOption[T] =
  | GSome(T)
  | GNone

enum GenericBox[T] =
  | GFull(T)
  | GEmpty

fun unwrapGenericBox(b: GenericBox) -> Int =
  match b
    GFull(GSome(v)) => v
    GFull(GNone) => -1
    GEmpty => 0

enum RecOption =
  | RSome(RecOption)
  | RNone

fun unwrapTwice(o: RecOption) -> Int =
  match o
    RSome(RSome(RNone)) => 1
    RSome(RNone) => 2
    RNone => 3
    _ => 0

fun classifyForWildcardTest(a: Int) -> Int =
  match a
    1 => 100
    2 => 200
    _ => 0

fun colorCode(c: Color) -> Int =
  match c
    Red => 1
    Green => 2
    Blue => 3

fun isSome(o: Option) -> Int =
  match o
    Some(_) => 1
    None => 0

# Mirrors libs/std/bool.plum's `and`/`or`: `match a, b` against two Bool
# subjects, each case naming a tag pattern per position.
fun and(a: Bool, b: Bool) -> Bool =
  match a, b
    True, True => True
    True, False => False
    False, True => False
    False, False => False

fun andOrCheck() -> Int =
  x := and(True, True)
  y := and(True, False)
  match x, y
    True, False => 1
    _, _ => 0

fun classifyTwoInts(a: Int, b: Int) -> Int =
  match a, b
    1, 1 => 100
    1, 2 => 200
    _, _ => 0

fun combine(a: Int, b: Int) -> Int =
  match a, b
    0, y => y
    x, 0 => x
    x, y => x + y

fun bothOptions(a: Option, b: Option) -> Int =
  match a, b
    Some(x), Some(y) => x + y
    _, _ => 0

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

  fun sum(self) -> Int =
    match self
      Point(x, y) => x + y

  fun classify(self) -> Str =
    match self
      Point(0, 0) => "origin"
      Point(x, 0) => "on x axis"
      Point(_, _) => "elsewhere"

enum Shape =
  | Circle(Point)
  | Square(Point)

  fun measure(self) -> Int =
    match self
      Circle(Point(x, y)) => x + y
      Square(Point(x, y)) => x * y

# Named payload fields (`Ring(radius: Int)`) alongside the
# unnamed-positional-payload form (`Circle(Point)` above) — lets a
# multi-field variant like `Rect` name each field instead of leaving them as
# anonymous positional types. Pattern matching is unaffected either way
# (still positional, by declaration order — `Rect(w, h)`, not `Rect(w:, h:)`).
enum Figure =
  | Ring(radius: Int)
  | Rect(w: Int, h: Int)

  fun area(self) -> Int =
    match self
      Ring(radius) => radius * radius
      Rect(w, h) => w * h

test "match example computes correctly"
  assert main() == 5

test "nested constructor pattern matches and binds runs correctly"
  assert unwrapNested(Wrap(Present(5))) == 5

test "nested constructor pattern mismatch falls through to next case runs correctly"
  assert unwrapNested(Wrap(Absent)) == -1

test "nested constructor pattern against a specialized generic enum runs correctly"
  assert unwrapGenericBox(GFull(GSome(7))) == 7

test "doubly nested constructor pattern runs correctly"
  assert unwrapTwice(RSome(RSome(RNone))) == 1

test "match int and wildcard run correctly"
  assert classifyForWildcardTest(2) == 200

test "match bool variant pattern runs correctly"
  assert describeBool(False) == 0

test "non bool bare tag pattern runs correctly"
  assert colorCode(Green) == 2

test "constructor pattern wildcard field runs correctly"
  assert isSome(Some(99)) == 1

test "constructor pattern does not misfire on payload free sibling"
  assert describeOption(Absent) == 0

test "multi subject match with enum tags runs correctly"
  assert andOrCheck() == 1

test "multi subject match falls through to next case when only first position matches"
  # The first case's position-0 pattern (`1`) matches, but position-1 (`1`)
  # doesn't (b is 2) — codegen must fall through to the *next case* (trying
  # its own position 0 again), not just "move on" within the first case.
  assert classifyTwoInts(1, 2) == 200

test "multi subject match with binding and wildcard runs correctly"
  assert combine(3, 4) == 7

test "multi subject match with generic enum variant runs correctly"
  assert bothOptions(Some(3), Some(4)) == 7

test "match destructures a plain class the same way it destructures an enum variant"
  assert Point(x: 3, y: 4).sum() == 7

test "match on a plain class supports literal/wildcard sub-patterns and case fallthrough"
  assert Point(x: 0, y: 0).classify() == "origin"
  assert Point(x: 5, y: 0).classify() == "on x axis"
  assert Point(x: 5, y: 5).classify() == "elsewhere"

test "a plain class nested inside an enum variant pattern destructures correctly"
  assert Circle(Point(x: 3, y: 4)).measure() == 7
  assert Square(Point(x: 3, y: 4)).measure() == 12

test "named-payload enum variant constructs via named args and destructures by position"
  assert Ring(radius: 5).area() == 25
  assert Rect(w: 3, h: 4).area() == 12

test "named-payload enum variant still supports positional construction too"
  assert Ring(5).area() == 25
  assert Rect(3, 4).area() == 12