defmodule Tilly.BDD.NodeTest do
  use ExUnit.Case, async: true

  alias Tilly.BDD.Node

  describe "Smart Constructors" do
    test "mk_true/0 returns true" do
      assert Node.mk_true() == true
    end

    test "mk_false/0 returns false" do
      assert Node.mk_false() == false
    end

    test "mk_leaf/1 creates a leaf node" do
      assert Node.mk_leaf(:some_value) == {:leaf, :some_value}
      assert Node.mk_leaf(123) == {:leaf, 123}
    end

    test "mk_split/4 creates a split node" do
      assert Node.mk_split(:el, :p_id, :i_id, :n_id) == {:split, :el, :p_id, :i_id, :n_id}
    end
  end

  describe "Predicates" do
    setup do
      %{
        true_node: Node.mk_true(),
        false_node: Node.mk_false(),
        leaf_node: Node.mk_leaf("data"),
        split_node: Node.mk_split(1, 2, 3, 4)
      }
    end

    test "is_true?/1", %{true_node: t, false_node: f, leaf_node: l, split_node: s} do
      assert Node.is_true?(t) == true
      assert Node.is_true?(f) == false
      assert Node.is_true?(l) == false
      assert Node.is_true?(s) == false
    end

    test "is_false?/1", %{true_node: t, false_node: f, leaf_node: l, split_node: s} do
      assert Node.is_false?(f) == true
      assert Node.is_false?(t) == false
      assert Node.is_false?(l) == false
      assert Node.is_false?(s) == false
    end

    test "is_leaf?/1", %{true_node: t, false_node: f, leaf_node: l, split_node: s} do
      assert Node.is_leaf?(l) == true
      assert Node.is_leaf?(t) == false
      assert Node.is_leaf?(f) == false
      assert Node.is_leaf?(s) == false
    end

    test "is_split?/1", %{true_node: t, false_node: f, leaf_node: l, split_node: s} do
      assert Node.is_split?(s) == true
      assert Node.is_split?(t) == false
      assert Node.is_split?(f) == false
      assert Node.is_split?(l) == false
    end
  end

  describe "Accessors" do
    setup do
      %{
        leaf_node: Node.mk_leaf("leaf_data"),
        split_node: Node.mk_split(:elem_id, :pos_child, :ign_child, :neg_child)
      }
    end

    test "value/1 for leaf node", %{leaf_node: l} do
      assert Node.value(l) == "leaf_data"
    end

    test "value/1 raises for non-leaf node" do
      assert_raise ArgumentError, ~r/Not a leaf node/, fn -> Node.value(Node.mk_true()) end

      assert_raise ArgumentError, ~r/Not a leaf node/, fn ->
        Node.value(Node.mk_split(1, 2, 3, 4))
      end
    end

    test "element/1 for split node", %{split_node: s} do
      assert Node.element(s) == :elem_id
    end

    test "element/1 raises for non-split node" do
      assert_raise ArgumentError, ~r/Not a split node/, fn -> Node.element(Node.mk_true()) end
      assert_raise ArgumentError, ~r/Not a split node/, fn -> Node.element(Node.mk_leaf(1)) end
    end

    test "positive_child/1 for split node", %{split_node: s} do
      assert Node.positive_child(s) == :pos_child
    end

    test "positive_child/1 raises for non-split node" do
      assert_raise ArgumentError, ~r/Not a split node/, fn ->
        Node.positive_child(Node.mk_leaf(1))
      end
    end

    test "ignore_child/1 for split node", %{split_node: s} do
      assert Node.ignore_child(s) == :ign_child
    end

    test "ignore_child/1 raises for non-split node" do
      assert_raise ArgumentError, ~r/Not a split node/, fn ->
        Node.ignore_child(Node.mk_leaf(1))
      end
    end

    test "negative_child/1 for split node", %{split_node: s} do
      assert Node.negative_child(s) == :neg_child
    end

    test "negative_child/1 raises for non-split node" do
      assert_raise ArgumentError, ~r/Not a split node/, fn ->
        Node.negative_child(Node.mk_leaf(1))
      end
    end
  end
end