#include "reg_izrazi.hpp"
#include <map>
using namespace std;

RegEx::~RegEx() {

}

string Char::basic() const {
  char tmp[2];
  tmp[0] = _c;
  tmp[1] = '\0';
  return string(tmp);
}

RegEx* Char::copy() const {
  return new Char(*this);
}

int Char::maxlen() const {
  return 1;
}

string Char::minstr() const {
  return this->basic();
}

BinOp::~BinOp() {
  delete _left;
  delete _right;
}

string Concat::basic() const {
  return string("(") + _left->basic() + string(")(") + _right->basic() + string(")");
}

int Concat::maxlen() const {
  int l = _left->maxlen();
  int r = _right->maxlen();
  return (l < 0 || r < 0) ? -1 : l + r;
}

RegEx* Concat::copy() const {
  return new Concat(_left->copy(), _right->copy());
}

string Concat::minstr() const {
  return _left->minstr() + _right->minstr();
}

string Disj::basic() const {
  return string("(") + _left->basic() + string(")|(") + _right->basic() + string(")");
}

RegEx* Disj::copy() const {
  return new Disj(_left->copy(), _right->copy());
}

int Disj::maxlen() const {
  int l = _left->maxlen();
  int r = _right->maxlen();
  return (l < 0 || r < 0) ? -1 : max(l, r);
}

string Disj::minstr() const {
  string l = _left->minstr();
  string r = _right->minstr();
  if (l.size() < r.size())
    return l;
  else
    return r;
}

UnOp::~UnOp() {
  delete _r;
}

string Iter::basic() const {
  return string("(") + _r->basic() + string(")*");
}

string Iter::minstr() const {
  return string("");
}

RegEx* Iter::copy() const {
  return new Iter(_r->copy());
}

int Iter::maxlen() const {
  return -1;
}

string Plus::basic() const {
  return string("(") + _r->basic() + string(")*(") + _r->basic() + string(")");
}

RegEx* Plus::copy() const {
  return new Plus(_r->copy());
}

int Plus::maxlen() const {
  return -1;
}

string Plus::minstr() const {
  return _r->minstr();
}

string CharClass::basic() const {
  string tmp;
  for (unsigned i = 0; i < _s.size(); i++) {
    tmp += _s[i];
    if (i != _s.size() - 1)
      tmp += "|";
  }
  return tmp;
}

RegEx* CharClass::copy() const {
  return new CharClass(*this);
}

int CharClass::maxlen() const {
  return 1;
}

string CharClass::minstr() const {
  char tmp[2];
  tmp[0] = _s[0];
  tmp[1] = '\0';
  return string(tmp);
}

string QuestionMark::basic() const {
  return string("(") + _r->basic() + string(")|()");
}

RegEx* QuestionMark::copy() const {
  return new QuestionMark(_r->copy());
}

int QuestionMark::maxlen() const {
  return _r->maxlen();
}

string QuestionMark::minstr() const {
  return string("");
}

string IterN::basic() const {
  string tmp;
  for (int i = 0; i < _n; i++)
    tmp += string("(") + _r->basic() + string(")");
  return tmp;
}

RegEx* IterN::copy() const {
  return new IterN(_r->copy(), _n);
}

int IterN::maxlen() const {
  return _n * _r->maxlen();
}

string IterN::minstr() const {
  string tmp;
  for (int i = 0; i < _n; i++)
    tmp += _r->minstr();
  return tmp;
}

extern map<char, RegEx*> definicije;
extern void yyerror(string s);

string Definition::basic() const {
  map<char, RegEx*>::iterator tmp = definicije.find(_c);
  if (tmp == definicije.end())
    yyerror("Ne postoji definicija " + _c);
  return tmp->second->basic();
}

RegEx* Definition::copy() const {
  return new Definition(*this);
}

int Definition::maxlen() const {
  map<char, RegEx*>::iterator tmp = definicije.find(_c);
  if (tmp == definicije.end())
    yyerror("Ne postoji definicija " + _c);
  return tmp->second->maxlen();  
}

string Definition::minstr() const {
  map<char, RegEx*>::iterator tmp = definicije.find(_c);
  if (tmp == definicije.end())
    yyerror("Ne postoji definicija " + _c);
  return tmp->second->minstr();    
}