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

SynTree::~SynTree() {

}

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

int Variable::interpret(map<string, int> &proms) const {
  return proms[_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> &proms) const {
  return _nodes[0]->interpret(proms) + _nodes[1]->interpret(proms);
}

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

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

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

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

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

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

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

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

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

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

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

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

int Fja::pozovi(vector<int> a) {
  map<string, int> tablica;
  if (a.size() != _args.size())
    throw "Fja je pozvana sa neodgovarajucim brojem argumenata";
  for (unsigned i = 0; i < _args.size(); i++)
    tablica[_args[i]] = a[i];
  _code->interpret(tablica);
  return tablica[_res];
}