////////////////////////////////////////////////////////////////////////////////
/// DISCLAIMER
///
/// Copyright 2014-2016 ArangoDB GmbH, Cologne, Germany
/// Copyright 2004-2014 triAGENS GmbH, Cologne, Germany
///
/// Licensed under the Apache License, Version 2.0 (the "License");
/// you may not use this file except in compliance with the License.
/// You may obtain a copy of the License at
///
///     http://www.apache.org/licenses/LICENSE-2.0
///
/// Unless required by applicable law or agreed to in writing, software
/// distributed under the License is distributed on an "AS IS" BASIS,
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
/// See the License for the specific language governing permissions and
/// limitations under the License.
///
/// Copyright holder is ArangoDB GmbH, Cologne, Germany
///
/// @author Max Neunhoeffer
////////////////////////////////////////////////////////////////////////////////

#ifndef ARANGOD_AQL_EXECUTION_NODE_H
#define ARANGOD_AQL_EXECUTION_NODE_H 1

#include "Basics/Common.h"
#include "Aql/types.h"
#include "Aql/Expression.h"
#include "Aql/Variable.h"
#include "Aql/WalkerWorker.h"
#include "Basics/JsonHelper.h"
#include "Basics/json-utilities.h"
#include "VocBase/voc-types.h"
#include "VocBase/vocbase.h"

namespace arangodb {
namespace velocypack {
class Builder;
}

namespace aql {
class Ast;
struct Collection;
class ExecutionBlock;
class TraversalBlock;
class ExecutionPlan;
struct Index;
class RedundantCalculationsReplacer;

/// @brief pairs, consisting of variable and sort direction
/// (true = ascending | false = descending)
typedef std::vector<std::pair<Variable const*, bool>> SortElementVector;

/// @brief class ExecutionNode, abstract base class of all execution Nodes
class ExecutionNode {
  /// @brief node type
  friend class ExecutionBlock;
  friend class TraversalBlock;

 public:
  enum NodeType : int {
    ILLEGAL = 0,
    SINGLETON = 1,
    ENUMERATE_COLLECTION = 2,
    // INDEX_RANGE          =  3, // not used anymore
    ENUMERATE_LIST = 4,
    FILTER = 5,
    LIMIT = 6,
    CALCULATION = 7,
    SUBQUERY = 8,
    SORT = 9,
    COLLECT = 10,
    SCATTER = 11,
    GATHER = 12,
    REMOTE = 13,
    INSERT = 14,
    REMOVE = 15,
    REPLACE = 16,
    UPDATE = 17,
    RETURN = 18,
    NORESULTS = 19,
    DISTRIBUTE = 20,
    UPSERT = 21,
    TRAVERSAL = 22,
    INDEX = 23,
    SHORTEST_PATH = 24
  };

  ExecutionNode() = delete;
  ExecutionNode(ExecutionNode const&) = delete;
  ExecutionNode& operator=(ExecutionNode const&) = delete;

  /// @brief constructor using an id
  ExecutionNode(ExecutionPlan* plan, size_t id)
      : _id(id),
        _estimatedCost(0.0),
        _estimatedNrItems(0),
        _estimatedCostSet(false),
        _depth(0),
        _varUsageValid(false),
        _plan(plan) {}

  /// @brief constructor using a JSON struct
  ExecutionNode(ExecutionPlan* plan, arangodb::basics::Json const& json);

  /// @brief destructor, free dependencies;
  virtual ~ExecutionNode() {}

 public:
  /// @brief factory from json.
  static ExecutionNode* fromJsonFactory(ExecutionPlan* plan,
                                        arangodb::basics::Json const& json);

  /// @brief return the node's id
  inline size_t id() const { return _id; }

  /// @brief return the type of the node
  virtual NodeType getType() const = 0;

  /// @brief return the type name of the node
  std::string const& getTypeString() const;

  /// @brief checks whether we know a type of this kind; throws exception if
  /// not.
  static void validateType(int type);

  /// @brief add a dependency
  void addDependency(ExecutionNode* ep) {
    _dependencies.emplace_back(ep);
    ep->_parents.emplace_back(this);
  }

  /// @brief add a parent
  void addParent(ExecutionNode* ep) {
    ep->_dependencies.emplace_back(this);
    _parents.emplace_back(ep);
  }

  /// @brief get all dependencies
  std::vector<ExecutionNode*> getDependencies() const { return _dependencies; }

  /// @brief returns the first dependency, or a nullptr if none present
  ExecutionNode* getFirstDependency() const {
    if (_dependencies.empty()) {
      return nullptr;
    }
    return _dependencies[0];
  }

  /// @brief whether or not the node has a dependency
  bool hasDependency() const { return (_dependencies.size() == 1); }

  /// @brief add the node dependencies to a vector
  void addDependencies(std::vector<ExecutionNode*>& result) const {
    for (auto const& it : _dependencies) {
      result.emplace_back(it);
    }
  }

  /// @brief get all parents
  std::vector<ExecutionNode*> getParents() const { return _parents; }

  /// @brief whether or not the node has a parent
  bool hasParent() const { return (_parents.size() == 1); }

  /// @brief returns the first parent, or a nullptr if none present
  ExecutionNode* getFirstParent() const {
    if (_parents.empty()) {
      return nullptr;
    }
    return _parents[0];
  }

  /// @brief add the node parents to a vector
  void addParents(std::vector<ExecutionNode*>& result) const {
    for (auto const& it : _parents) {
      result.emplace_back(it);
    }
  }

  /// @brief get the node and its dependencies as a vector
  std::vector<ExecutionNode*> getDependencyChain(bool includeSelf) {
    std::vector<ExecutionNode*> result;

    auto current = this;
    while (current != nullptr) {
      if (includeSelf || current != this) {
        result.emplace_back(current);
      }
      if (! current->hasDependency()) {
        break;
      }
      current = current->getFirstDependency();
    }

    return result;
  }

  /// @brief inspect one index; only skiplist indices which match attrs in
  /// sequence.
  /// returns a a qualification how good they match;
  ///      match->index==nullptr means no match at all.
  enum MatchType {
    FORWARD_MATCH,
    REVERSE_MATCH,
    NOT_COVERED_IDX,
    NOT_COVERED_ATTR,
    NO_MATCH
  };

  struct IndexMatch {
    IndexMatch() : index(nullptr), doesMatch(false), reverse(false) {}

    Index const* index;  // The index concerned; if null, this is a nonmatch.
    std::vector<MatchType> matches;  // qualification of the attrs match quality
    bool doesMatch;                  // do all criteria match?
    bool reverse;                    // reverse index scan required
  };

  typedef std::vector<std::pair<std::string, bool>> IndexMatchVec;

  /// @brief make a new node the (only) parent of the node
  void setParent(ExecutionNode* p) {
    _parents.clear();
    _parents.emplace_back(p);
  }

  /// @brief replace a dependency, returns true if the pointer was found and
  /// replaced, please note that this does not delete oldNode!
  bool replaceDependency(ExecutionNode* oldNode, ExecutionNode* newNode) {
    auto it = _dependencies.begin();

    while (it != _dependencies.end()) {
      if (*it == oldNode) {
        *it = newNode;
        try {
          newNode->_parents.emplace_back(this);
        } catch (...) {
          *it = oldNode;  // roll back
          return false;
        }
        try {
          for (auto it2 = oldNode->_parents.begin();
               it2 != oldNode->_parents.end(); ++it2) {
            if (*it2 == this) {
              oldNode->_parents.erase(it2);
              break;
            }
          }
        } catch (...) {
          // If this happens, we ignore that the _parents of oldNode
          // are not set correctly
        }
        return true;
      }

      ++it;
    }
    return false;
  }

  /// @brief remove a dependency, returns true if the pointer was found and
  /// removed, please note that this does not delete ep!
  bool removeDependency(ExecutionNode* ep) {
    bool ok = false;
    for (auto it = _dependencies.begin(); it != _dependencies.end(); ++it) {
      if (*it == ep) {
        try {
          it = _dependencies.erase(it);
        } catch (...) {
          return false;
        }
        ok = true;
        break;
      }
    }

    if (!ok) {
      return false;
    }

    // Now remove us as a parent of the old dependency as well:
    for (auto it = ep->_parents.begin(); it != ep->_parents.end(); ++it) {
      if (*it == this) {
        try {
          ep->_parents.erase(it);
        } catch (...) {
        }
        return true;
      }
    }

    return false;
  }

  /// @brief remove all dependencies for the given node
  void removeDependencies() {
    for (auto& x : _dependencies) {
      for (auto it = x->_parents.begin(); it != x->_parents.end(); ++it) {
        if (*it == this) {
          try {
            x->_parents.erase(it);
          } catch (...) {
          }
          break;
        }
      }
    }
    _dependencies.clear();
  }

  /// @brief clone execution Node recursively, this makes the class abstract
  virtual ExecutionNode* clone(ExecutionPlan* plan, bool withDependencies,
                               bool withProperties) const = 0;

  /// @brief execution Node clone utility to be called by derives
  void cloneHelper(ExecutionNode* Other, ExecutionPlan* plan,
                   bool withDependencies, bool withProperties) const;

  /// @brief helper for cloning, use virtual clone methods for dependencies
  void cloneDependencies(ExecutionPlan* plan, ExecutionNode* theClone,
                         bool withProperties) const;

  /// @brief convert to a string, basically for debugging purposes
  virtual void appendAsString(std::string& st, int indent = 0);

  /// @brief invalidate the cost estimation for the node and its dependencies
  void invalidateCost();

  /// @brief estimate the cost of the node . . .
  double getCost(size_t& nrItems) const {
    if (!_estimatedCostSet) {
      _estimatedCost = estimateCost(_estimatedNrItems);
      nrItems = _estimatedNrItems;
      _estimatedCostSet = true;
      TRI_ASSERT(_estimatedCost >= 0.0);
    } else {
      nrItems = _estimatedNrItems;
    }
    return _estimatedCost;
  }

  /// @brief this actually estimates the costs as well as the number of items
  /// coming out of the node
  virtual double estimateCost(size_t& nrItems) const = 0;

  /// @brief walk a complete execution plan recursively
  bool walk(WalkerWorker<ExecutionNode>* worker);

  /// @brief toVelocyPack, export an ExecutionNode to VelocyPack
  void toVelocyPack(arangodb::velocypack::Builder&, bool, bool = false) const;

  /// @brief toVelocyPack
  virtual void toVelocyPackHelper(arangodb::velocypack::Builder&,
                                  bool) const = 0;

  /// @brief getVariablesUsedHere, returning a vector
  virtual std::vector<Variable const*> getVariablesUsedHere() const {
    return std::vector<Variable const*>();
  }

  /// @brief getVariablesUsedHere, modifying the set in-place
  virtual void getVariablesUsedHere(
      std::unordered_set<Variable const*>&) const {
    // do nothing!
  }

  /// @brief getVariablesSetHere
  virtual std::vector<Variable const*> getVariablesSetHere() const {
    return std::vector<Variable const*>();
  }

  /// @brief getVariableIdsUsedHere
  std::unordered_set<VariableId> getVariableIdsUsedHere() const {
    auto v(getVariablesUsedHere());

    std::unordered_set<VariableId> ids;
    ids.reserve(v.size());

    for (auto& it : v) {
      ids.emplace(it->id);
    }
    return ids;
  }

  /// @brief setVarsUsedLater
  void setVarsUsedLater(std::unordered_set<Variable const*>& v) {
    _varsUsedLater = v;
  }

  /// @brief getVarsUsedLater, this returns the set of variables that will be
  /// used later than this node, i.e. in the repeated parents.
  std::unordered_set<Variable const*> const& getVarsUsedLater() const {
    TRI_ASSERT(_varUsageValid);
    return _varsUsedLater;
  }

  /// @brief setVarsValid
  void setVarsValid(std::unordered_set<Variable const*>& v) { _varsValid = v; }

  /// @brief getVarsValid, this returns the set of variables that is valid
  /// for items leaving this node, this includes those that will be set here
  /// (see getVariablesSetHere).
  std::unordered_set<Variable const*> const& getVarsValid() const {
    TRI_ASSERT(_varUsageValid);
    return _varsValid;
  }

  /// @brief setVarUsageValid
  void setVarUsageValid() { _varUsageValid = true; }

  /// @brief invalidateVarUsage
  void invalidateVarUsage() {
    _varsUsedLater.clear();
    _varsValid.clear();
    _varUsageValid = false;
  }

  /// @brief can the node throw?
  virtual bool canThrow() { return false; }

  /// @brief whether or not the subquery is deterministic
  virtual bool isDeterministic() { return true; }

  /// @brief whether or not the node is a data modification node
  virtual bool isModificationNode() const {
    // derived classes can change this
    return false;
  }

  /// @brief static analysis, walker class and information collector
  struct VarInfo {
    unsigned int depth;
    RegisterId registerId;

    VarInfo() = delete;
    VarInfo(int depth, RegisterId registerId)
        : depth(depth), registerId(registerId) {
      TRI_ASSERT(registerId < MaxRegisterId);
    }
  };

  struct RegisterPlan final : public WalkerWorker<ExecutionNode> {
    // The following are collected for global usage in the ExecutionBlock,
    // although they are stored here in the node:

    // map VariableIds to their depth and registerId:
    std::unordered_map<VariableId, VarInfo> varInfo;

    // number of variables in the frame of the current depth:
    std::vector<RegisterId> nrRegsHere;

    // number of variables in this and all outer frames together,
    // the entry with index i here is always the sum of all values
    // in nrRegsHere from index 0 to i (inclusively) and the two
    // have the same length:
    std::vector<RegisterId> nrRegs;

    // We collect the subquery nodes to deal with them at the end:
    std::vector<ExecutionNode*> subQueryNodes;

    // Local for the walk:
    unsigned int depth;
    unsigned int totalNrRegs;

   private:
    // This is used to tell all nodes and share a pointer to ourselves
    std::shared_ptr<RegisterPlan>* me;

   public:
    RegisterPlan() : depth(0), totalNrRegs(0), me(nullptr) {
      nrRegsHere.emplace_back(0);
      nrRegs.emplace_back(0);
    };

    void clear();

    void setSharedPtr(std::shared_ptr<RegisterPlan>* shared) { me = shared; }

    // Copy constructor used for a subquery:
    RegisterPlan(RegisterPlan const& v, unsigned int newdepth);
    ~RegisterPlan(){};

    virtual bool enterSubquery(ExecutionNode*, ExecutionNode*) override final {
      return false;  // do not walk into subquery
    }

    virtual void after(ExecutionNode* eb) override final;

    RegisterPlan* clone(ExecutionPlan* otherPlan, ExecutionPlan* plan);
  };

  /// @brief static analysis
  void planRegisters(ExecutionNode* super = nullptr);

  /// @brief get RegisterPlan
  RegisterPlan const* getRegisterPlan() const {
    TRI_ASSERT(_registerPlan.get() != nullptr);
    return _registerPlan.get();
  }

  /// @brief get depth
  int getDepth() const { return _depth; }
  
  /// @brief get registers to clear
  std::unordered_set<RegisterId> const& getRegsToClear() const {
    return _regsToClear;
  }

  /// @brief check if a variable will be used later
  bool isVarUsedLater(Variable const* variable) const {
    return (_varsUsedLater.find(variable) != _varsUsedLater.end());
  }

  /// @brief whether or not the node is in an inner loop
  bool isInInnerLoop() const { return getLoop() != nullptr; }

  /// @brief get the surrounding loop
  ExecutionNode const* getLoop() const;

 protected:
  /// @brief factory for (optional) variables from json.
  static Variable* varFromJson(Ast* ast, arangodb::basics::Json const& base,
                               char const* variableName, bool optional = false);

  /// @brief factory for sort Elements from json.
  static void getSortElements(SortElementVector& elements, ExecutionPlan* plan,
                              arangodb::basics::Json const& oneNode,
                              char const* which);

  /// @brief toVelocyPackHelper, for a generic node
  void toVelocyPackHelperGeneric(arangodb::velocypack::Builder&, bool) const;

  /// @brief set regs to be deleted
  void setRegsToClear(std::unordered_set<RegisterId> const& toClear) {
    _regsToClear = toClear;
  }

 protected:
  /// @brief node id
  size_t const _id;

  /// @brief our dependent nodes
  std::vector<ExecutionNode*> _dependencies;

  /// @brief our parent nodes
  std::vector<ExecutionNode*> _parents;

  /// @brief _estimatedCost = 0 if uninitialized and otherwise stores the result
  /// of estimateCost(), the bool indicates if the cost has been set, it starts
  /// out as false, _estimatedNrItems is the estimated number of items coming
  /// out of this node.
  double mutable _estimatedCost;

  size_t mutable _estimatedNrItems;

  bool mutable _estimatedCostSet;

  /// @brief _varsUsedLater and _varsValid, the former contains those
  /// variables that are still needed further down in the chain. The
  /// latter contains the variables that are set from the dependent nodes
  /// when an item comes into the current node. Both are only valid if
  /// _varUsageValid is true. Use ExecutionPlan::findVarUsage to set
  /// this.
  std::unordered_set<Variable const*> _varsUsedLater;

  std::unordered_set<Variable const*> _varsValid;

  /// @brief depth of the current frame, will be filled in by planRegisters
  int _depth;

  /// @brief whether or not _varsUsedLater and _varsValid are actually valid
  bool _varUsageValid;

  /// @brief _plan, the ExecutionPlan object
  ExecutionPlan* _plan;

  /// @brief info about variables, filled in by planRegisters
  std::shared_ptr<RegisterPlan> _registerPlan;

  /// @brief the following contains the registers which should be cleared
  /// just before this node hands on results. This is computed during
  /// the static analysis for each node using the variable usage in the plan.
  std::unordered_set<RegisterId> _regsToClear;

 public:
  /// @brief NodeType to string mapping
  static std::unordered_map<int, std::string const> const TypeNames;

  /// @brief maximum register id that can be assigned.
  /// this is used for assertions
  static RegisterId const MaxRegisterId;
};

/// @brief class SingletonNode
class SingletonNode : public ExecutionNode {
  friend class ExecutionBlock;
  friend class SingletonBlock;

  /// @brief constructor with an id
 public:
  SingletonNode(ExecutionPlan* plan, size_t id) : ExecutionNode(plan, id) {}

  SingletonNode(ExecutionPlan*, arangodb::basics::Json const& base);

  /// @brief return the type of the node
  NodeType getType() const override final { return SINGLETON; }

  /// @brief export to VelocyPack
  void toVelocyPackHelper(arangodb::velocypack::Builder&,
                          bool) const override final;

  /// @brief clone ExecutionNode recursively
  ExecutionNode* clone(ExecutionPlan* plan, bool withDependencies,
                       bool withProperties) const override final {
    auto c = new SingletonNode(plan, _id);

    cloneHelper(c, plan, withDependencies, withProperties);

    return static_cast<ExecutionNode*>(c);
  }

  /// @brief the cost of a singleton is 1
  double estimateCost(size_t&) const override final;
};

/// @brief class EnumerateCollectionNode
class EnumerateCollectionNode : public ExecutionNode {
  friend class ExecutionNode;
  friend class ExecutionBlock;
  friend class EnumerateCollectionBlock;

  /// @brief constructor with a vocbase and a collection name
 public:
  EnumerateCollectionNode(ExecutionPlan* plan, size_t id,
                          TRI_vocbase_t* vocbase, Collection* collection,
                          Variable const* outVariable, bool random)
      : ExecutionNode(plan, id),
        _vocbase(vocbase),
        _collection(collection),
        _outVariable(outVariable),
        _random(random) {
    TRI_ASSERT(_vocbase != nullptr);
    TRI_ASSERT(_collection != nullptr);
    TRI_ASSERT(_outVariable != nullptr);
  }

  EnumerateCollectionNode(ExecutionPlan* plan,
                          arangodb::basics::Json const& base);

  /// @brief return the type of the node
  NodeType getType() const override final { return ENUMERATE_COLLECTION; }

  /// @brief export to VelocyPack
  void toVelocyPackHelper(arangodb::velocypack::Builder&,
                          bool) const override final;

  /// @brief clone ExecutionNode recursively
  ExecutionNode* clone(ExecutionPlan* plan, bool withDependencies,
                       bool withProperties) const override final;

  /// @brief the cost of an enumerate collection node is a multiple of the cost
  /// of
  /// its unique dependency
  double estimateCost(size_t&) const override final;

  /// @brief getVariablesSetHere
  std::vector<Variable const*> getVariablesSetHere() const override final {
    return std::vector<Variable const*>{_outVariable};
  }
  
  /// @brief the node is only non-deterministic if it uses a random sort order
  bool isDeterministic() override final { return !_random; }

  /// @brief enable random iteration of documents in collection
  void setRandom() { _random = true; }

  /// @brief return the database
  TRI_vocbase_t* vocbase() const { return _vocbase; }

  /// @brief return the collection
  Collection const* collection() const { return _collection; }

  /// @brief return the out variable
  Variable const* outVariable() const { return _outVariable; }

 private:
  /// @brief the database
  TRI_vocbase_t* _vocbase;

  /// @brief collection
  Collection* _collection;

  /// @brief output variable
  Variable const* _outVariable;

  /// @brief whether or not we want random iteration
  bool _random;
};

/// @brief class EnumerateListNode
class EnumerateListNode : public ExecutionNode {
  friend class ExecutionNode;
  friend class ExecutionBlock;
  friend class EnumerateListBlock;
  friend class RedundantCalculationsReplacer;

 public:
  EnumerateListNode(ExecutionPlan* plan, size_t id, Variable const* inVariable,
                    Variable const* outVariable)
      : ExecutionNode(plan, id),
        _inVariable(inVariable),
        _outVariable(outVariable) {
    TRI_ASSERT(_inVariable != nullptr);
    TRI_ASSERT(_outVariable != nullptr);
  }

  EnumerateListNode(ExecutionPlan*, arangodb::basics::Json const& base);

  /// @brief return the type of the node
  NodeType getType() const override final { return ENUMERATE_LIST; }

  /// @brief export to VelocyPack
  void toVelocyPackHelper(arangodb::velocypack::Builder&,
                          bool) const override final;

  /// @brief clone ExecutionNode recursively
  ExecutionNode* clone(ExecutionPlan* plan, bool withDependencies,
                       bool withProperties) const override final;

  /// @brief the cost of an enumerate list node
  double estimateCost(size_t&) const override final;

  /// @brief getVariablesUsedHere, returning a vector
  std::vector<Variable const*> getVariablesUsedHere() const override final {
    return std::vector<Variable const*>{_inVariable};
  }

  /// @brief getVariablesUsedHere, modifying the set in-place
  void getVariablesUsedHere(
      std::unordered_set<Variable const*>& vars) const override final {
    vars.emplace(_inVariable);
  }

  /// @brief getVariablesSetHere
  std::vector<Variable const*> getVariablesSetHere() const override final {
    return std::vector<Variable const*>{_outVariable};
  }

  /// @brief return in variable
  Variable const* inVariable() const { return _inVariable; }

  /// @brief return out variable
  Variable const* outVariable() const { return _outVariable; }

 private:
  /// @brief input variable to read from
  Variable const* _inVariable;

  /// @brief output variable to write to
  Variable const* _outVariable;
};

/// @brief class LimitNode
class LimitNode : public ExecutionNode {
  friend class ExecutionBlock;
  friend class LimitBlock;

  /// @brief constructors for various arguments, always with offset and limit
 public:
  LimitNode(ExecutionPlan* plan, size_t id, size_t offset, size_t limit)
      : ExecutionNode(plan, id),
        _offset(offset),
        _limit(limit),
        _fullCount(false) {}

  LimitNode(ExecutionPlan* plan, size_t id, size_t limit)
      : ExecutionNode(plan, id), _offset(0), _limit(limit), _fullCount(false) {}

  LimitNode(ExecutionPlan*, arangodb::basics::Json const& base);

  /// @brief return the type of the node
  NodeType getType() const override final { return LIMIT; }

  /// @brief export to VelocyPack
  void toVelocyPackHelper(arangodb::velocypack::Builder&,
                          bool) const override final;

  /// @brief clone ExecutionNode recursively
  ExecutionNode* clone(ExecutionPlan* plan, bool withDependencies,
                       bool withProperties) const override final {
    auto c = new LimitNode(plan, _id, _offset, _limit);

    if (_fullCount) {
      c->setFullCount();
    }

    cloneHelper(c, plan, withDependencies, withProperties);

    return static_cast<ExecutionNode*>(c);
  }

  /// @brief estimateCost
  double estimateCost(size_t&) const override final;

  /// @brief tell the node to fully count what it will limit
  void setFullCount() { _fullCount = true; }

  /// @brief return the offset value
  size_t offset() const { return _offset; }

  /// @brief return the limit value
  size_t limit() const { return _limit; }

 private:
  /// @brief the offset
  size_t _offset;

  /// @brief the limit
  size_t _limit;

  /// @brief whether or not the node should fully count what it limits
  bool _fullCount;
};

/// @brief class CalculationNode
class CalculationNode : public ExecutionNode {
  friend class ExecutionNode;
  friend class ExecutionBlock;
  friend class CalculationBlock;
  friend class RedundantCalculationsReplacer;

 public:
  CalculationNode(ExecutionPlan* plan, size_t id, Expression* expr,
                  Variable const* conditionVariable,
                  Variable const* outVariable)
      : ExecutionNode(plan, id),
        _conditionVariable(conditionVariable),
        _outVariable(outVariable),
        _expression(expr),
        _canRemoveIfThrows(false) {
    TRI_ASSERT(_expression != nullptr);
    TRI_ASSERT(_outVariable != nullptr);
  }

  CalculationNode(ExecutionPlan* plan, size_t id, Expression* expr,
                  Variable const* outVariable)
      : CalculationNode(plan, id, expr, nullptr, outVariable) {}

  CalculationNode(ExecutionPlan*, arangodb::basics::Json const& base);

  ~CalculationNode() { delete _expression; }

  /// @brief return the type of the node
  NodeType getType() const override final { return CALCULATION; }

  /// @brief export to VelocyPack
  void toVelocyPackHelper(arangodb::velocypack::Builder&,
                          bool) const override final;

  /// @brief clone ExecutionNode recursively
  ExecutionNode* clone(ExecutionPlan* plan, bool withDependencies,
                       bool withProperties) const override final;

  /// @brief return out variable
  Variable const* outVariable() const { return _outVariable; }

  /// @brief return the expression
  Expression* expression() const { return _expression; }

  /// @brief allow removal of this calculation even if it can throw
  /// this can only happen if the optimizer added a clone of this expression
  /// elsewhere, and if the clone will stand in
  bool canRemoveIfThrows() const { return _canRemoveIfThrows; }

  /// @brief allow removal of this calculation even if it can throw
  /// this can only happen if the optimizer added a clone of this expression
  /// elsewhere, and if the clone will stand in
  void canRemoveIfThrows(bool value) { _canRemoveIfThrows = value; }

  /// @brief estimateCost
  double estimateCost(size_t&) const override final;

  /// @brief getVariablesUsedHere, returning a vector
  std::vector<Variable const*> getVariablesUsedHere() const override final {
    std::unordered_set<Variable const*> vars;
    _expression->variables(vars);

    std::vector<Variable const*> v;
    v.reserve(vars.size());

    for (auto const& vv : vars) {
      v.emplace_back(vv);
    }

    if (_conditionVariable != nullptr) {
      v.emplace_back(_conditionVariable);
    }

    return v;
  }

  /// @brief getVariablesUsedHere, modifying the set in-place
  void getVariablesUsedHere(
      std::unordered_set<Variable const*>& vars) const override final {
    _expression->variables(vars);

    if (_conditionVariable != nullptr) {
      vars.emplace(_conditionVariable);
    }
  }

  /// @brief getVariablesSetHere
  virtual std::vector<Variable const*> getVariablesSetHere()
      const override final {
    return std::vector<Variable const*>{_outVariable};
  }

  /// @brief can the node throw?
  bool canThrow() override final { return _expression->canThrow(); }
  
  bool isDeterministic() override final { return _expression->isDeterministic(); }

 private:
  /// @brief an optional condition variable for the calculation
  Variable const* _conditionVariable;

  /// @brief output variable to write to
  Variable const* _outVariable;

  /// @brief we need to have an expression and where to write the result
  Expression* _expression;

  /// @brief allow removal of this calculation even if it can throw
  /// this can only happen if the optimizer added a clone of this expression
  /// elsewhere, and if the clone will stand in
  bool _canRemoveIfThrows;
};

/// @brief class SubqueryNode
class SubqueryNode : public ExecutionNode {
  friend class ExecutionNode;
  friend class ExecutionBlock;
  friend class SubqueryBlock;

 public:
  SubqueryNode(ExecutionPlan*, arangodb::basics::Json const& base);

  SubqueryNode(ExecutionPlan* plan, size_t id, ExecutionNode* subquery,
               Variable const* outVariable)
      : ExecutionNode(plan, id),
        _subquery(subquery),
        _outVariable(outVariable) {
    TRI_ASSERT(_subquery != nullptr);
    TRI_ASSERT(_outVariable != nullptr);
  }

  /// @brief return the type of the node
  NodeType getType() const override final { return SUBQUERY; }

  /// @brief return the out variable
  Variable const* outVariable() const { return _outVariable; }

  /// @brief export to VelocyPack
  void toVelocyPackHelper(arangodb::velocypack::Builder&,
                          bool) const override final;

  /// @brief clone ExecutionNode recursively
  ExecutionNode* clone(ExecutionPlan* plan, bool withDependencies,
                       bool withProperties) const override final;

  /// @brief whether or not the subquery is a data-modification operation
  bool isModificationQuery() const;

  /// @brief getter for subquery
  ExecutionNode* getSubquery() const { return _subquery; }

  /// @brief setter for subquery
  void setSubquery(ExecutionNode* subquery, bool forceOverwrite) {
    TRI_ASSERT(subquery != nullptr);
    TRI_ASSERT((forceOverwrite && _subquery != nullptr) ||
               (!forceOverwrite && _subquery == nullptr));
    _subquery = subquery;
  }

  /// @brief estimateCost
  double estimateCost(size_t&) const override final;

  /// @brief getVariablesUsedHere, returning a vector
  std::vector<Variable const*> getVariablesUsedHere() const override final;

  /// @brief getVariablesUsedHere, modifying the set in-place
  void getVariablesUsedHere(
      std::unordered_set<Variable const*>& vars) const override final;

  /// @brief getVariablesSetHere
  std::vector<Variable const*> getVariablesSetHere() const override final {
    return std::vector<Variable const*>{_outVariable};
  }

  /// @brief replace the out variable, so we can adjust the name.
  void replaceOutVariable(Variable const* var);

  /// @brief can the node throw? Note that this means that an exception can
  /// *originate* from this node. That is, this method does not need to
  /// return true just because a dependent node can throw an exception.
  bool canThrow() override final;
  
  bool isDeterministic() override final;

  bool isConst(); 

 private:
  /// @brief we need to have an expression and where to write the result
  ExecutionNode* _subquery;

  /// @brief variable to write to
  Variable const* _outVariable;
};

/// @brief class FilterNode
class FilterNode : public ExecutionNode {
  friend class ExecutionBlock;
  friend class FilterBlock;
  friend class RedundantCalculationsReplacer;

  /// @brief constructors for various arguments, always with offset and limit
 public:
  FilterNode(ExecutionPlan* plan, size_t id, Variable const* inVariable)
      : ExecutionNode(plan, id), _inVariable(inVariable) {
    TRI_ASSERT(_inVariable != nullptr);
  }

  FilterNode(ExecutionPlan*, arangodb::basics::Json const& base);

  /// @brief return the type of the node
  NodeType getType() const override final { return FILTER; }

  /// @brief export to VelocyPack
  void toVelocyPackHelper(arangodb::velocypack::Builder&,
                          bool) const override final;

  /// @brief clone ExecutionNode recursively
  ExecutionNode* clone(ExecutionPlan* plan, bool withDependencies,
                       bool withProperties) const override final;

  /// @brief estimateCost
  double estimateCost(size_t&) const override final;

  /// @brief getVariablesUsedHere, returning a vector
  std::vector<Variable const*> getVariablesUsedHere() const override final {
    return std::vector<Variable const*>{_inVariable};
  }

  /// @brief getVariablesUsedHere, modifying the set in-place
  void getVariablesUsedHere(
      std::unordered_set<Variable const*>& vars) const override final {
    vars.emplace(_inVariable);
  }

 private:
  /// @brief input variable to read from
  Variable const* _inVariable;
};

/// @brief this is an auxilliary struct for processed sort criteria information
struct SortInformation {
  enum Match {
    unequal,                // criteria are unequal
    otherLessAccurate,      // leftmost sort criteria are equal, but other sort
                            // criteria are less accurate than ourselves
    ourselvesLessAccurate,  // leftmost sort criteria are equal, but our own
                            // sort criteria is less accurate than the other
    allEqual                // all criteria are equal
  };

  std::vector<std::tuple<ExecutionNode const*, std::string, bool>> criteria;
  bool isValid = true;
  bool isDeterministic = true;
  bool isComplex = false;
  bool canThrow = false;

  Match isCoveredBy(SortInformation const& other) {
    if (!isValid || !other.isValid) {
      return unequal;
    }

    if (isComplex || other.isComplex) {
      return unequal;
    }

    size_t const n = criteria.size();
    for (size_t i = 0; i < n; ++i) {
      if (other.criteria.size() <= i) {
        return otherLessAccurate;
      }

      auto ours = criteria[i];
      auto theirs = other.criteria[i];

      if (std::get<2>(ours) != std::get<2>(theirs)) {
        // sort order is different
        return unequal;
      }

      if (std::get<1>(ours) != std::get<1>(theirs)) {
        // sort criterion is different
        return unequal;
      }
    }

    if (other.criteria.size() > n) {
      return ourselvesLessAccurate;
    }

    return allEqual;
  }
};

/// @brief class ReturnNode
class ReturnNode : public ExecutionNode {
  friend class ExecutionBlock;
  friend class ReturnBlock;
  friend class RedundantCalculationsReplacer;

  /// @brief constructors for various arguments, always with offset and limit
 public:
  ReturnNode(ExecutionPlan* plan, size_t id, Variable const* inVariable)
      : ExecutionNode(plan, id), _inVariable(inVariable) {
    TRI_ASSERT(_inVariable != nullptr);
  }

  ReturnNode(ExecutionPlan*, arangodb::basics::Json const& base);

  /// @brief return the type of the node
  NodeType getType() const override final { return RETURN; }

  /// @brief export to VelocyPack
  void toVelocyPackHelper(arangodb::velocypack::Builder&,
                          bool) const override final;

  /// @brief clone ExecutionNode recursively
  ExecutionNode* clone(ExecutionPlan* plan, bool withDependencies,
                       bool withProperties) const override final;

  /// @brief estimateCost
  double estimateCost(size_t&) const override final;

  /// @brief getVariablesUsedHere, returning a vector
  std::vector<Variable const*> getVariablesUsedHere() const override final {
    return std::vector<Variable const*>{_inVariable};
  }

  /// @brief getVariablesUsedHere, modifying the set in-place
  void getVariablesUsedHere(
      std::unordered_set<Variable const*>& vars) const override final {
    vars.emplace(_inVariable);
  }

  Variable const* inVariable() const { return _inVariable; }

 private:
  /// @brief we need to know the offset and limit
  Variable const* _inVariable;
};

/// @brief class NoResultsNode
class NoResultsNode : public ExecutionNode {
  friend class ExecutionBlock;
  friend class NoResultsBlock;

  /// @brief constructor with an id
 public:
  NoResultsNode(ExecutionPlan* plan, size_t id) : ExecutionNode(plan, id) {}

  NoResultsNode(ExecutionPlan* plan, arangodb::basics::Json const& base)
      : ExecutionNode(plan, base) {}

  /// @brief return the type of the node
  NodeType getType() const override final { return NORESULTS; }

  /// @brief export to VelocyPack
  void toVelocyPackHelper(arangodb::velocypack::Builder&,
                          bool) const override final;


  /// @brief clone ExecutionNode recursively
  ExecutionNode* clone(ExecutionPlan* plan, bool withDependencies,
                       bool withProperties) const override final {
    auto c = new NoResultsNode(plan, _id);

    cloneHelper(c, plan, withDependencies, withProperties);

    return static_cast<ExecutionNode*>(c);
  }

  /// @brief the cost of a NoResults is 0
  double estimateCost(size_t&) const override final;
};

}  // namespace arangodb::aql
}  // namespace arangodb

#endif