/* ----------------------------------------------------------------------------

 * GTSAM Copyright 2010, Georgia Tech Research Corporation, 
 * Atlanta, Georgia 30332-0415
 * All Rights Reserved
 * Authors: Frank Dellaert, et al. (see THANKS for the full author list)

 * See LICENSE for the license information

 * -------------------------------------------------------------------------- */

/**
 * @file testMethod.cpp
 * @brief Unit test for GlobalFunction class
 * @author Frank Dellaert
 * @date Nov 12, 2014
 **/

#include <wrap/GlobalFunction.h>
#include <CppUnitLite/TestHarness.h>
#include <iostream>

using namespace std;
using namespace wrap;

//******************************************************************************
// Constructor
TEST( GlobalFunction, Constructor ) {
  GlobalFunction f;
}

/* ************************************************************************* */
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-variable"
#endif
#include <boost/lambda/bind.hpp>
#include <boost/lambda/lambda.hpp>
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif

namespace bl = boost::lambda;
// http://boost-spirit.com/distrib/spirit_1_8_2/libs/spirit/doc/grammar.html
struct GlobalFunctionGrammar: public classic::grammar<GlobalFunctionGrammar> {

  GlobalFunctions& global_functions_; ///< successful parse will be placed in here

  /// Construct type grammar and specify where result is placed
  GlobalFunctionGrammar(GlobalFunctions& global_functions) :
      global_functions_(global_functions) {
  }

  /// Definition of type grammar
  template<typename ScannerT>
  struct definition: BasicRules<ScannerT> {

//    using BasicRules<ScannerT>::name_p;
//    using BasicRules<ScannerT>::className_p;
    using BasicRules<ScannerT>::comments_p;

    ArgumentList args;
    ArgumentListGrammar argumentList_g;

    ReturnValue retVal0, retVal;
    ReturnValueGrammar returnValue_g;

    Qualified globalFunction;

    classic::rule<ScannerT> globalFunctionName_p, global_function_p;

    definition(GlobalFunctionGrammar const& self) :
        argumentList_g(args), returnValue_g(retVal) {

      using namespace classic;
      bool verbose = false; // TODO

      globalFunctionName_p = lexeme_d[(upper_p | lower_p) >> *(alnum_p | '_')];

      // parse a global function
      global_function_p = (returnValue_g
          >> globalFunctionName_p[assign_a(globalFunction.name_)]
          >> argumentList_g >> ';' >> *comments_p) //
          [bl::bind(&GlobalFunction::addOverload,
              bl::var(self.global_functions_)[bl::var(globalFunction.name_)],
              bl::var(globalFunction), bl::var(args), bl::var(retVal),
              boost::none, verbose)] //
          [assign_a(retVal, retVal0)][clear_a(globalFunction)][clear_a(args)];

    }

    classic::rule<ScannerT> const& start() const {
      return global_function_p;
    }

  };
};
// GlobalFunctionGrammar

//******************************************************************************
TEST( GlobalFunction, Grammar ) {

  using classic::space_p;

  // Create type grammar that will place result in actual
  GlobalFunctions actual;
  GlobalFunctionGrammar g(actual);

  // a class type with namespaces
  EXPECT(parse("Vector aGlobalFunction();", g, space_p).full);
  EXPECT(parse("Vector overloadedGlobalFunction(int a);", g, space_p).full);
  EXPECT(parse("Vector overloadedGlobalFunction(int a, double b);", g, space_p).full);
}

//******************************************************************************
int main() {
  TestResult tr;
  return TestRegistry::runAllTests(tr);
}
//******************************************************************************