/*
 Copyright 2019 Alain Dargelas
 
 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.
 */

/* 
 * File:   ParseUtils.cpp
 * Author: alain
 * 
 * Created on March 16, 2017, 10:23 PM
 */

#include "antlr4-runtime.h"
using namespace antlr4;
#include<vector>
#include "ParseUtils.h"

using namespace SURELOG;

ParseUtils::ParseUtils () { }

ParseUtils::ParseUtils (const ParseUtils& orig) { }

ParseUtils::~ParseUtils () { }

std::pair<int,int> ParseUtils::getLineColumn(tree::TerminalNode* node){
     Token* token = node->getSymbol();
     int lineNb = token->getLine ();
     int columnNb = token->getCharPositionInLine();
     return std::make_pair(lineNb, columnNb);
}

std::pair<int, int> ParseUtils::getLineColumn (CommonTokenStream* stream, ParserRuleContext* context)
{
  const misc::Interval sourceInterval = ((ParserRuleContext*) context)->getSourceInterval ();
  Token* firstToken = stream->get (sourceInterval.a);
  int lineNb = firstToken->getLine ();
  int columnNb = firstToken->getCharPositionInLine();
  return std::make_pair(lineNb, columnNb);
}

std::vector<tree::ParseTree*> ParseUtils::getTopTokenList (tree::ParseTree* tree)
{
  std::vector<tree::ParseTree*> tokens;
  for (unsigned int i = 0; i < tree->children.size (); i++)
    {
      // Get the i-th child node of `parent`.
      tree::ParseTree* child = tree->children[i];
      tokens.push_back (child);
    }
  return tokens;
}


void ParseUtils::tokenizeAtComma(std::vector<std::string>& actualArgs, const std::vector<tree::ParseTree*>& tokens)
{
  bool notEmpty = false;
  std::vector<std::string> tmpArgs;
  unsigned int topIndex = 0;
  for (std::vector<tree::ParseTree*>::const_iterator itr = tokens.begin (); itr != tokens.end (); itr++)
    {
      std::string s = (*itr)->getText ();
      if (s == ",")
        {
          tmpArgs.push_back (",");
          topIndex++;
        }
      else if (s == " ")
        {
          if (topIndex > 0)
            {
              if (tmpArgs[topIndex - 1] != ",")
                tmpArgs[topIndex - 1] += " ";
            }
        }
      else
        {
          if ((topIndex == 0) || (tmpArgs[topIndex - 1] == ","))
            {
              tmpArgs.push_back (s);
              topIndex++;
            }
          else
            tmpArgs[topIndex - 1] += s;
        }
    }


  for (unsigned int j = 0; j < tmpArgs.size (); j++)
    {
      std::string s = tmpArgs[j];
      if (s != ",")
        {
          for (unsigned int i = 0; i < s.size (); i++)
            {
              if (s[i] != ' ')
                {
                  notEmpty = true;
                  break;
                }
            }
        }
      bool lastToken = (j == (tmpArgs.size () - 1));
      if ((s != ",") && notEmpty)
        {
          actualArgs.push_back (s);
        }
      else if ((s == ",") && (!notEmpty))
        {
          actualArgs.push_back ("");
          notEmpty = false;
          if (lastToken)
            actualArgs.push_back ("");
        }
      else if (lastToken)
        {
          actualArgs.push_back ("");
        }
      else if (s == ",")
        {
          notEmpty = false;
        }
    }
}

/**
   * Retrieves all Tokens from the {@code tree} in an in-order sequence.
   *
   * @param tree
   *         the parse tee to get all tokens from.
   *
   * @return all Tokens from the {@code tree} in an in-order sequence.
   */
  
  std::vector<Token*> ParseUtils::getFlatTokenList (tree::ParseTree* tree)
  {
    std::vector<Token*> tokens;
    inOrderTraversal (tokens, tree);
    return tokens;
  }

    /**
   * Makes an in-order traversal over {@code parent} (recursively) collecting
   * all Tokens of the terminal nodes it encounters.
   *
   * @param tokens
   *         the list of tokens.
   * @param parent
   *         the current parent node to inspect for terminal nodes.
   */
  
  
  void ParseUtils::inOrderTraversal (std::vector<Token*>& tokens, tree::ParseTree* parent)
  {

    // Iterate over all child nodes of `parent`.
    for (unsigned int i = 0; i < parent->children.size (); i++)
      {

        // Get the i-th child node of `parent`.
        tree::ParseTree* child = parent->children[i];
        tree::TerminalNode* node = dynamic_cast<tree::TerminalNode*> (child);
        if (node)
          {
            // We found a leaf/terminal, add its Token to our list.
            tokens.push_back (node->getSymbol ());
          }
        else
          {
            // No leaf/terminal node, recursively call this method.
            inOrderTraversal (tokens, child);
          }
      }
  }