#include "parser.h"
#include <stack>
Parser::Parser(std::vector<Token>& tokens)
{
  Tokens = tokens;
  Pos = 0;
}

Token Parser::GetToken()
{
  std:: cerr << "GetToken " << std::endl;
  return Tokens[Pos++];
}

Tree::~Tree()
{
  std::cerr <<'!' << Value.Value << std::endl;
  for (size_t pos = 0; pos < Children.size(); ++pos)
    delete Children[pos];
}

Tree::Tree(Token token)
{
  Value = token;
}

int priority (Token token)
{
  string value = token.Value;
  if (value == "+" || value == "-")
    return 2;

  if (value == "*" || value == "/")
    return 1;

  if (value == ")")
    return 0;

  return -1;
}

Tree* Parser::MakeTree(Token token)
{
  std:: cerr << "MakeTree " << token.Value << std::endl;
  Tree* tree = new Tree(token);
  return tree;
}

void Tree::AddChild(Tree* child)
{
  std:: cerr << "AddChild " << std::endl;
  Children.push_back(child);
}

void Tree:: Print(int tab)
{
  for (int i = 0; i < tab; ++i)
    std::cout << ' ';
  std::cout << '<' << Value.Value << '>' << std::endl;
  for (size_t child = 0; child < Children.size(); child++)
    Children[child]->Print(tab + 1);
}

Tree* Parser::GetExpression()
{
  std::cout << "GetExpression" << std::endl;
  std::stack <Tree*> lexeme;
  std::stack <Token> operation;
  std::vector<Token> temp;
  TokenType type = Tokens[Pos].Type;
  while (isExpr(type))
  {
    if (type == tNUM || type == tIDENT)
    {
      lexeme.push(MakeTree(Tokens[Pos]));
      if (Tokens[Pos + 1].Type == tIDENT)
        break;
      type = Tokens[++Pos].Type;
      continue;
    }

    if (operation.size() == 0)
    {
      operation.push(Tokens[Pos]);
      type = Tokens[++Pos].Type;
      continue;
    }

    Token op_1 = Tokens[Pos], op_2 = operation.top();
    while (priority(op_1) <= priority(op_2) && op_1.Type != tOBRACKET) // Если можно вытолкнуть
    {
      Tree* lex_1 = lexeme.top();
      lexeme.pop();
      Tree* lex_2 = lexeme.top();
      lexeme.pop();
      Tree* expr = MakeTree(op_2);
      operation.pop();
      expr->AddChild(lex_2);
      expr->AddChild(lex_1);
      lexeme.push(expr);
      op_2 = operation.top();
    } // то выталкиваем
    operation.push(op_1);
    if (Tokens[Pos + 1].Type == tIDENT && type == tOBRACKET)
      break;
    type == Tokens[++Pos].Type;
  }
  //Token op = operation.top();
  //while (operation.top().Type != tOBRACKET)
  //{
    //Tree* lex_1 = lexeme.top();
   // lexeme.pop();
   //\/ Tree* lex_2 = lexeme.top();
    //lexeme.pop();
      //   Tree* expr = MakeTree(op);
        // expr->AddChild(lex_2);
        // expr->AddChild(lex_1);
       //  operation.pop();
         //lexeme.push(expr);
      //}
      //operation.pop();

      //if (Tokens[Pos + 1].Type == tIDENT)
        //break;

//    if (type == tBOP)
  //  {
    //  Token op_1 = Tokens[Pos];
     // if (operation.size() && priority(op_1) <= priority(operation.top()))
      //{
        // Tree* lex_1 = lexeme.top();
        // lexeme.pop();
        // Tree* lex_2 = lexeme.top();
        // lexeme.pop();
        // Tree* expr = MakeTree(op_1);
        // expr->AddChild(lex_2);
        // expr->AddChild(lex_1);
        //Tree* expr = MakeTree(op_1);
        //expr->AddChild(lexeme.top());
        //lexeme.pop();
        //expr->AddChild(lexeme.top());
        //lexeme.pop();
        //lexeme.push(expr);
      //} else
       // operation.push(op_1);
     //}
    //}
   // type = Tokens[++Pos].Type;
  //}
  return lexeme.top();
}

Tree* Parser::GetDeclaration(Token token)
{
  std:: cerr << "GetDeclaration " << Pos << std::endl;
  Tree* declaration =  new Tree(token);
  declaration->AddChild(MakeTree(GetToken()));
  GetToken();
  declaration->AddChild(GetExpression());
  return declaration;
}

Tree* Parser::GetAssignment(Token token)
{
  std:: cerr << "GetAssignment " << Pos << std::endl;
  Tree* assignment = new Tree(GetToken());
  assignment->AddChild(MakeTree(token));
  assignment->AddChild(GetExpression());
  return assignment;
}

Tree* Parser::GetBinaryExpression()
{
  std:: cerr << "GetBinaryExpression " << Pos << std::endl;
  Tree* expression = GetExpression();
  Tree* binexp = MakeTree(GetToken());
  binexp->AddChild(expression);
  binexp->AddChild(GetExpression());
  return binexp;
}

Tree* Parser::GetIfWhile(Token token)
{
  std:: cerr << "GetIfWhile " << Pos << std::endl;
  Tree* ifwhile = MakeTree(token);
  ifwhile->AddChild(GetBinaryExpression());
  ifwhile->AddChild(GetBlock());
  return ifwhile;
}

Tree* Parser:: GetUnOperandTree(Token token)
{
  std:: cerr << "GetUnOperandTree " << Pos << std::endl;
  Tree* tree = MakeTree(token);
  tree->AddChild(GetExpression());
  return tree;
}

Tree* Parser:: GetBlock()
{
  std:: cerr << "GetBlock " << Pos << std::endl;
  Token t = GetToken();
  Tree* block = new Tree(t);
  while (t.Type != tEND)
  {
    t = GetToken();

    if (t.Type == tDECL)
      block->AddChild(GetDeclaration(t));

    if (t.Type == tIFWHILE)
      block->AddChild(GetIfWhile(t));

    if (t.Type == tIDENT)
      block->AddChild(GetAssignment(t));

    if  (t.Type == tREAD || t.Type == tPRINT)
      block->AddChild(GetUnOperandTree(t));

  }
  block->AddChild(MakeTree(t));
  return block;
}