#include "syn_tree.hpp"
#include <map>


SynTree::~SynTree() {

}

int Constant::interpret(map<string, int> &p) const {
  return _v;
}

int Variable::interpret(map<string, int> &p) const {
  return p[_s];
}

string Variable::getName() const {
  return _s;
}

InnerTree::InnerTree(SynTree* a) {
  _nodes.resize(0);
  _nodes.push_back(a);
}

InnerTree::InnerTree(SynTree* a, SynTree* b) {
  _nodes.resize(0);
  _nodes.push_back(a);
  _nodes.push_back(b);
}

InnerTree::InnerTree(SynTree* a, SynTree* b, SynTree* c) {
  _nodes.resize(0);
  _nodes.push_back(a);
  _nodes.push_back(b);
  _nodes.push_back(c);
}

InnerTree::InnerTree(vector<SynTree*> a) {
  _nodes = a;
}

InnerTree::~InnerTree() {
  for (unsigned i = 0; i < _nodes.size(); i++)
    delete _nodes[i];
}

int Add::interpret(map<string, int> &p) const {
  return _nodes[0]->interpret(p) + _nodes[1]->interpret(p);
}

int Sub::interpret(map<string, int> &p) const {
  return _nodes[0]->interpret(p) - _nodes[1]->interpret(p);
}

int Mul::interpret(map<string, int> &p) const {
  return _nodes[0]->interpret(p) * _nodes[1]->interpret(p);
}

int Div::interpret(map<string, int> &p) const {
  return _nodes[0]->interpret(p) / _nodes[1]->interpret(p);
}

int Greater::interpret(map<string, int> &p) const {
  return _nodes[0]->interpret(p) > _nodes[1]->interpret(p);
}

int Less::interpret(map<string, int> &p) const {
  return _nodes[0]->interpret(p) < _nodes[1]->interpret(p);
}

int Eq::interpret(map<string, int> &p) const {
  return _nodes[0]->interpret(p) == _nodes[1]->interpret(p);
}

int Assign::interpret(map<string, int> &p) const {
  return p[((Variable*)_nodes[0])->getName()] = _nodes[1]->interpret(p);
}

int Print::interpret(map<string, int> &p) const {
  cout << _nodes[0]->interpret(p) << endl;
  return 0;
}

int Seq::interpret(map<string, int> &p) const {
  for(unsigned i = 0; i < _nodes.size(); i++)
    _nodes[i]->interpret(p);
  return 0;
}

extern map<string, Fja*> tablica;
int PozivFje::interpret(map<string, int> &p) const {
  vector<int> v;
  for (unsigned i = 0; i < _nodes.size(); i++)
    v.push_back(_nodes[i]->interpret(p));
  map<string, Fja*>::iterator tmp = tablica.find(_name);
  if (tmp == tablica.end())
    throw "Poziv fje koja nije definisana";
  return tmp->second->pozovi(v);
}

int Upitnik::interpret(map<string, int> &p) const {
  return _nodes[0]->interpret(p) ? _nodes[1]->interpret(p) : _nodes[2]->interpret(p);
}

Fja::~Fja() {
  delete _code;
}

int Fja::pozovi(vector<int> a) {
  if (a.size() != _args.size())
    throw "Poziv fje sa neodgovarajucim brojem argumenata";
  map<string, int> tablica;
  for (unsigned i = 0; i < a.size(); i++)
    tablica[_args[i]] = a[i];

  _code->interpret(tablica);
  return tablica[_res];
}