/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
 * Use of this file is governed by the BSD 3-clause license that
 * can be found in the LICENSE.txt file in the project root.
 */

#include "tree/Trees.h"
#include "misc/Interval.h"
#include "Parser.h"
#include "atn/ATN.h"
#include "atn/ATNState.h"
#include "tree/ParseTreeVisitor.h"

#include "RuleContext.h"

using namespace antlr4;
using namespace antlr4::atn;
using namespace antlr4::tree;

RuleContext::RuleContext() : ParseTree(ParseTreeType::RULE) {
  InitializeInstanceFields();
}

RuleContext::RuleContext(RuleContext *parent_, size_t invokingState_) : ParseTree(ParseTreeType::RULE) {
  InitializeInstanceFields();
  this->parent = parent_;
  this->invokingState = invokingState_;
}

int RuleContext::depth() {
  int n = 1;
  RuleContext *p = this;
  while (true) {
    if (p->parent == nullptr)
      break;
    p = static_cast<RuleContext *>(p->parent);
    n++;
  }
  return n;
}

bool RuleContext::isEmpty() {
  return invokingState == ATNState::INVALID_STATE_NUMBER;
}

misc::Interval RuleContext::getSourceInterval() {
  return misc::Interval::INVALID;
}

std::string RuleContext::getText() {
  if (children.empty()) {
    return "";
  }

  std::stringstream ss;
  for (size_t i = 0; i < children.size(); i++) {
    ParseTree *tree = children[i];
    if (tree != nullptr)
      ss << tree->getText();
  }

  return ss.str();
}

size_t RuleContext::getRuleIndex() const {
  return INVALID_INDEX;
}

size_t RuleContext::getAltNumber() const {
  return atn::ATN::INVALID_ALT_NUMBER;
}

void RuleContext::setAltNumber(size_t /*altNumber*/) {
}

std::any RuleContext::accept(tree::ParseTreeVisitor *visitor) {
  return visitor->visitChildren(this);
}

std::string RuleContext::toStringTree(Parser *recog, bool pretty) {
  return tree::Trees::toStringTree(this, recog, pretty);
}

std::string RuleContext::toStringTree(std::vector<std::string> &ruleNames, bool pretty) {
  return tree::Trees::toStringTree(this, ruleNames, pretty);
}

std::string RuleContext::toStringTree(bool pretty) {
  return toStringTree(nullptr, pretty);
}


std::string RuleContext::toString(const std::vector<std::string> &ruleNames) {
  return toString(ruleNames, nullptr);
}


std::string RuleContext::toString(const std::vector<std::string> &ruleNames, RuleContext *stop) {
  std::stringstream ss;

  RuleContext *currentParent = this;
  ss << "[";
  while (currentParent != stop) {
    if (ruleNames.empty()) {
      if (!currentParent->isEmpty()) {
        ss << currentParent->invokingState;
      }
    } else {
      size_t ruleIndex = currentParent->getRuleIndex();

      std::string ruleName = (ruleIndex < ruleNames.size()) ? ruleNames[ruleIndex] : std::to_string(ruleIndex);
      ss << ruleName;
    }

    if (currentParent->parent == nullptr) // No parent anymore.
      break;
    currentParent = static_cast<RuleContext *>(currentParent->parent);
    if (!ruleNames.empty() || !currentParent->isEmpty()) {
      ss << " ";
    }
  }

  ss << "]";

  return ss.str();
}

std::string RuleContext::toString() {
  return toString(nullptr);
}

std::string RuleContext::toString(Recognizer *recog) {
  return toString(recog, &ParserRuleContext::EMPTY);
}

std::string RuleContext::toString(Recognizer *recog, RuleContext *stop) {
  if (recog == nullptr)
    return toString(std::vector<std::string>(), stop); // Don't use an initializer {} here or we end up calling ourselve recursivly.
  return toString(recog->getRuleNames(), stop);
}

void RuleContext::InitializeInstanceFields() {
  invokingState = INVALID_INDEX;
}