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

using namespace sp::fol;

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

  void test_parser(std::string const& oracle, std::string const& text)
  {
    Lexer lexer;
    lexer.scan(text);

    Parser parser;
    auto node = parser.parse(lexer.all());

    REQUIRE(oracle == node->string());
  }

protected:
};

TEST_CASE_METHOD(ParserTest, "Parser_var")
{
  test_parser("FORMULA(PRED[Pr](VAR[hello]))", " Pr(hello) ");
}

TEST_CASE_METHOD(ParserTest, "Parser_const")
{
  test_parser("FORMULA(PRED[Pr](CONST[WORLD]))", " Pr(WORLD) ");
}

TEST_CASE_METHOD(ParserTest, "Parser_func")
{
  test_parser("FORMULA(PRED[Pr](FUNC[father]))",
              " Pr(father()) ");

  test_parser("FORMULA(PRED[Pr](FUNC[mother](VAR[x])))",
              " Pr(mother(x)) ");

  test_parser("FORMULA(PRED[Pr](FUNC[brother](VAR[x],VAR[y])))",
              " Pr(brother(x, y)) ");

  test_parser("FORMULA(PRED[Pr]("
              "FUNC[sister](VAR[x],FUNC[mother](VAR[y],VAR[z]))))",
              " Pr(sister(x, mother(y, z))) ");

}

TEST_CASE_METHOD(ParserTest, "Parser_not")
{
  test_parser("FORMULA(NOT(PRED[Pr](VAR[x])))",
              " !Pr(x) ");
}


TEST_CASE_METHOD(ParserTest, "Parser_pred")
{
  test_parser("FORMULA(PRED[Happy](CONST[PIERRE]))",
              " Happy(PIERRE) ");

  test_parser("FORMULA(PRED[Sad](VAR[x],VAR[y]))",
              " Sad(x, y) ");
}

TEST_CASE_METHOD(ParserTest, "Parser_pred_'or'_'imp'_'and'")
{
  test_parser("FORMULA(AND("
              "PRED[Pr](VAR[x])"
              ",IMP("
              "PRED[Pr](VAR[y]),"
              "PRED[Pr](VAR[z]))))",
              "Pr(x) & Pr(y) -> Pr(z)");

  test_parser("FORMULA(OR("
              "PRED[Ab](VAR[x]),"
              "AND("
              "PRED[Cd](VAR[y]),"
              "PRED[Ef](CONST[Z]))))",
              " Ab(x) | Cd(y) & Ef(Z)");
}

TEST_CASE_METHOD(ParserTest, "Parser_group")
{
  test_parser("FORMULA(IMP(AND("
              "PRED[Pr](VAR[x]),"
              "PRED[Pr](VAR[y])),"
              "PRED[Pr](VAR[z])))",
              "(Pr(x) & Pr(y)) -> Pr(z)");
}