#include <catch2/catch.hpp>
#include "../src/Parser.hpp"
#include "../src/Lexer.hpp"

class ParserTest
{
public:
  explicit ParserTest() {}
  virtual ~ParserTest() {}

  void test_parse(std::string const& oracle, std::string const& source)
  {
    grino::Logger logger;
    grino::Lexer lexer {logger, "tests/parser"};
    grino::Parser parser {logger, lexer};

    auto root = parser.parse(source);
    REQUIRE(oracle == root->string());
  }

protected:
};

TEST_CASE_METHOD(ParserTest, "Parser_empty")
{
  test_parse("MODULE", "");
}

TEST_CASE_METHOD(ParserTest, "Parser_booleans")
{
  test_parse("MODULE(BOOL[true],BOOL[false])", "true false");
}

TEST_CASE_METHOD(ParserTest, "Parser_vardecl")
{
  test_parse("MODULE(VARDECL(IDENT[hello],BOOL[false]))",
             "($ hello false)");

  test_parse("MODULE(VARDECL(IDENT[hello],IDENT[world]))",
             "($ hello world)");
}

TEST_CASE_METHOD(ParserTest, "Parser_funcall")
{
  test_parse("MODULE(FUNCALL(IDENT[hello]))",
             "(hello)");

  test_parse("MODULE(FUNCALL(IDENT[f],BOOL[false],BOOL[true]))",
             "(f false true)");
}

TEST_CASE_METHOD(ParserTest, "Parser_integer")
{
  test_parse("MODULE(FUNCALL(IDENT[hello],INT[2],INT[34]))",
             "(hello 2 34)");
}

TEST_CASE_METHOD(ParserTest, "Parser_lambda")
{
  test_parse("MODULE(LAMBDA(PARAMS,BODY))",
             "(-> ())");

  test_parse("MODULE(LAMBDA(PARAMS(IDENT[x]),BODY))",
             "(-> (x))");

  test_parse("MODULE(LAMBDA(PARAMS(IDENT[x],IDENT[y]),BODY(IDENT[y])))",
             "(-> (x y) y)");

  test_parse("MODULE(FUNCALL(LAMBDA(PARAMS("
             "IDENT[x]"
             "),BODY("
             "IDENT[x]"
             ")),INT[4]))",
             "( (-> (x) x ) 4 )");

}

TEST_CASE_METHOD(ParserTest, "Parser_fundecl")
{
  test_parse("MODULE(VARDECL(IDENT[f],LAMBDA(PARAMS(IDENT[x]),"
             "BODY(FUNCALL(IDENT[+],IDENT[x],INT[1])))))",
             "($ (f x) (+ x 1))");
}