#pragma once

#ifndef TGRAMMAR_INCLUDED

#define TGRAMMAR_INCLUDED

#include <memory></memory>

// TnzCore includes

#include "tcommon.h"

// TnzBase includes

#include "ttokenizer.h"

#undef DVAPI

#undef DVVAR

#ifdef TNZBASE_EXPORTS

#define DVAPI DV_EXPORT_API

#define DVVAR DV_EXPORT_VAR

#else

#define DVAPI DV_IMPORT_API

#define DVVAR DV_IMPORT_VAR

#endif

//==============================================

//    Forward declarations

class TDoubleParam;

class TUnit;

namespace TSyntax {

class Token;

class Calculator;

}  // namespace TSyntax

//==============================================

//-------------------------------------------------------------------

// Calculator & calculator nodes

//-------------------------------------------------------------------

namespace TSyntax {

class DVAPI CalculatorNodeVisitor {

public:

  CalculatorNodeVisitor() {}

  virtual ~CalculatorNodeVisitor() {}

};

//-------------------------------------------------------------------

class DVAPI CalculatorNode {

  Calculator *m_calculator;

public:

  CalculatorNode(Calculator *calculator) : m_calculator(calculator) {}

  virtual ~CalculatorNode() {}

  Calculator *getCalculator() const { return m_calculator; }

  enum { T, FRAME, RFRAME };

  virtual double compute(double vars[3]) const = 0;

  virtual void accept(CalculatorNodeVisitor &visitor) = 0;

  virtual bool hasReference() const { return false; }

private:

  // Non-copyable

  CalculatorNode(const CalculatorNode &);

  CalculatorNode &operator=(const CalculatorNode &);

};

//-------------------------------------------------------------------

class DVAPI Calculator {

  CalculatorNode *m_rootNode;  //!< (owned) Root calculator node

  TDoubleParam *m_param;  //!< (not owned) Owner of the calculator object

  const TUnit *m_unit;    //!< (not owned)

public:

  Calculator();

  virtual ~Calculator();

  void setRootNode(CalculatorNode *node);

  double compute(double t, double frame, double rframe) {

    double vars[3];

    vars[0] = t, vars[1] = frame, vars[2] = rframe;

    return m_rootNode->compute(vars);

  }

  void accept(CalculatorNodeVisitor &visitor) { m_rootNode->accept(visitor); }

  typedef double Calculator::*Variable;

  void setOwnerParameter(TDoubleParam *param) { m_param = param; }

  TDoubleParam *getOwnerParameter() const { return m_param; }

  const TUnit *getUnit() const { return m_unit; }

  void setUnit(const TUnit *unit) { m_unit = unit; }

private:

  // not copyable

  Calculator(const Calculator &);

  Calculator &operator=(const Calculator &);

};

//-------------------------------------------------------------------

class DVAPI NumberNode final : public CalculatorNode {

  double m_value;

public:

  NumberNode(Calculator *calc, double value)

      : CalculatorNode(calc), m_value(value) {}

  double compute(double vars[3]) const override { return m_value; }

  void accept(CalculatorNodeVisitor &visitor) override {}

};

//-------------------------------------------------------------------

class DVAPI VariableNode final : public CalculatorNode {

  int m_varIdx;

public:

  VariableNode(Calculator *calc, int varIdx)

      : CalculatorNode(calc), m_varIdx(varIdx) {}

  double compute(double vars[3]) const override { return vars[m_varIdx]; }

  void accept(CalculatorNodeVisitor &visitor) override {}

};

//-------------------------------------------------------------------

// Pattern

//-------------------------------------------------------------------

enum TokenType {

  Unknown = 0,

  Number,

  Constant,

  Variable,

  Operator,

  Parenthesis,

  Function,

  Comma,

  UnexpectedToken = -100,

  Eos,

  Mismatch,

  InternalError = -200

};

//-------------------------------------------------------------------

class DVAPI Pattern {

  std::string m_description;

public:

  Pattern() {}

  virtual ~Pattern() {}

  virtual std::string getFirstKeyword() const { return ""; }

  virtual void getAcceptableKeywords(std::vector<std::string> &keywords) const {</std::string>

  }

  virtual int getPriority() const { return 0; }

  virtual bool expressionExpected(

      const std::vector<token> &previousTokens) const {</token>

    return false;

  }

  virtual bool matchToken(const std::vector<token> &previousTokens,</token>

                          const Token &token) const = 0;

  virtual bool isFinished(const std::vector<token> &previousTokens,</token>

                          const Token &token) const = 0;

  virtual bool isComplete(const std::vector<token> &previousTokens,</token>

                          const Token &token) const {

    return isFinished(previousTokens, token);

  }

  virtual TokenType getTokenType(

      const std::vector<token> &previousTokens,</token>

      const Token &token) const = 0;  // see also SyntaxToken in tparser.h

  virtual void createNode(Calculator *calc,

                          std::vector<calculatornode *=""> &stack,</calculatornode>

                          const std::vector<token> &tokens) const = 0;</token>

  std::string getDescription() const { return m_description; }

  void setDescription(std::string description) { m_description = description; }

  // helper methods

  CalculatorNode *popNode(std::vector<calculatornode *=""> &stack) const;</calculatornode>

};

//-------------------------------------------------------------------

class DVAPI Grammar {

  class Imp;

  std::unique_ptr<imp> m_imp;</imp>

public:

  Grammar();

  ~Grammar();

  void addPattern(Pattern *pattern);  // take ownership

  enum Position { ExpressionStart, ExpressionEnd };

  // note: returns a matching pattern (or 0 if no pattern matches)

  const Pattern *getPattern(Position position, const Token &token) const;

  // returns matching <keywords, comment=""></keywords,>

  typedef std::vector<std::pair<std::string, std::string="">> Suggestions;</std::pair<std::string,>

  void getSuggestions(Suggestions &suggetsions, Position position) const;

private:

  // not implemented

  Grammar(const Grammar &);

  Grammar &operator=(const Grammar &);

};

}  // namespace TSyntax

#endif  // TGRAMMAR_INCLUDED