#ifndef UTIL_H_
#define UTIL_H_

#include <iostream>
#include <giac/config.h>
#include <giac/giac.h>

using namespace giac;
using namespace std;

/*
inline bool contains(gen g, gen s) {
  vecteur vars = lidnt(g);
  bool res = false;
  int k=0;
  while (k!=vars.size() && !res) {
    res = vars[k]==s;
    k++;
  }
  return res;
  }*/

inline vector<int> concat(vector<int> v, vector<int> w) {
  if (v.size()==0) {
    return w;
  }
  else {
    if (w.size()==0) {
      return v; 
    }
    else {
      bool done = false;
      while (!done) {
	done = ( v.size()==0 || w.size()==0 || (v[v.size()-1]!=-w[0]) );
	if (!done) {
	  v.pop_back();
	  w.erase(w.begin());
	}
      }
      v.insert(v.end(),w.begin(),w.end());
      return v;
    }
  }
}

inline vector<int> flipword(vector<int> v) {
  vector<int> w;
  unsigned n = v.size();
  for (unsigned k=0; k<n; k++) {
    w.push_back(v[n-k-1]);
  }
  return w;
}

inline vector<int> invertword(vector<int> v) {
  vector<int> w;
  unsigned n = v.size();
  for (unsigned k=0; k<n; k++) {
    w.push_back(-v[n-k-1]);
  }
  return w;
}

inline vector<int> conjugateword(vector<int> v, vector<int> w) {
  return concat(concat(v,w),invertword(v));
}

inline vector<int> shiftIndicesUp(vector<int> v) {
  vector<int> w;
  unsigned n = v.size();
  for (unsigned k=0; k<n; k++) {
    int j = v[k];
    int s;
    if (j>0) {
      s = 1;
    }
    else {
      s = -1;
      j = -j;
    }
    w.push_back(s*((j%3)+1));
  }
  return w; 
}

inline vector<int> shiftIndicesDown(vector<int> v) {
  vector<int> w;
  unsigned n = v.size();
  for (unsigned k=0; k<n; k++) {
    int j = v[k];
    int s;
    if (j>0) {
      s = 1;
    }
    else {
      s = -1;
      j = -j;
    }
    if (j>1) {
      w.push_back(s*(j-1));
    }
    else {
      w.push_back(s*3);
    }
  }
  return w; 
}

inline string convertword(vector<int> v) {
  string s = "";
  if (v.size()==0) {
    return s;
  }
  else {
    for (unsigned k=0; k<v.size()-1; k++) {
      stringstream ss;
      ss << v[k] ;
      s = s + ss.str() + ",";
    }
    stringstream ss;
    ss << v[v.size()-1] ;
    s = s + ss.str();
    return s;
  }
}

inline string convertwordgap(vector<int> v) {
  string s;
  unsigned n = v.size();
  for (unsigned k=0; k<n-1; k++) {
    stringstream ss;
    if (v[k]>0) {
      if (v[k]<4) {
	ss << v[k];
	s = s + "R" + ss.str() + "*";
      }
      else {
	if (v[k]==4) {
	  s = s + "P*";
	}
	else {
	  if (v[k]==5) {
	    s = s + "Q*";
	  }
	  else {
	    cerr << "Unidentified generator in word" << endl;
	    exit(1);
	  }
	}
      }
    }
    else {
      int o = -v[k];
      if (o<4) {
	ss << o;
	s = s + "R" + ss.str() + "^-1*";
      }
      else {
	if (o==4) {
	  s = s + "P^-1*";
	}
	else {
	  if (o==5) {
	    s = s + "Q^-1*";
	  }
	  else {
	    cerr << "Unidentified generator in word" << endl;
	    exit(1);
	  }
	}
      }
    }
  }
  if (n>0) {
    stringstream ss;
    if (v[n-1]>0) {
      if (v[n-1]<4) {
	ss << v[n-1];
	s = s + "R" + ss.str();
      }
      else {
	if (v[n-1]==4) {
	  s = s + "P";
	}
	else {
	  if (v[n-1]==5) {
	    s = s + "Q";
	  }
	  else {
	    cerr << "Unidentified generator in word" << endl;
	    exit(1);
	  }
	}
      }
    }
    else {
      int o = -v[n-1];
      if (o<4) {
	ss << o;
	s = s + "R" + ss.str() + "^-1";
      }
      else {
	if (o==4) {
	  s = s + "P^-1";
	}
	else {
	  if (o==5) {
	    s = s + "Q^-1";
	  }
	  else {
	    cerr << "Unidentified generator in word" << endl;
	    exit(1);
	  }
	}
      }
    }
  }
  return s;
}

inline void shift(vector<int> &w) {
  int z = w[0];
  w.erase(w.begin());
  w.push_back(z);
}

inline void substituteword(vector<int> vl, vector<int> vs, vector<int> &w) {
  // find occurrences of vl=vlong in w, and replace them by vs=vshort
  int ws = w.size()-1;
  int vls = vl.size()-1;
  if (vls>-1 && ws>-1) {
    bool foundfirst = false;
    int k=-1;
    while (!foundfirst && k<ws) {
      k++;
      foundfirst = vl[0]==w[k];
    }
    if (foundfirst) {
      bool foundall = k+vls<w.size();
      unsigned l = 1;
      while (foundall && l<=vls) {
	foundall = vl[l]==w[k+l];
	l++;
      }
      if (foundall) {
	vector<int> w1;
	for (unsigned m=0; m<k; m++) {
	  w1.push_back(w[m]);
	}
	vector<int> w2;
	for (unsigned m=k+vls+1; m<=ws; m++) {
	  w2.push_back(w[m]);
	}
	//	cout << "Concat " << w1 << ", " << vs << ", " << w2 << endl;
	w = concat(concat(w1,vs),w2);
      }
    }
  }
}

inline void simplifyword(vector<int> &w, vector<int> rel) {
  if (w.size()>0) {
    unsigned n = rel.size();
    unsigned no2 = n/2;
    unsigned k = 0;
    while (k<n) {
      unsigned l=n;
      while (l>no2) {
	vector<int> w1, w2;
	for (unsigned u=0; u<l; u++) {
	  w1.push_back(rel[u]);
	}
	for (unsigned u=n-1; u>=l; u--) {
	  w2.push_back(-rel[u]);
	}
	substituteword(w1,w2,w);
	l--;
      }
      shift(rel);
      k++;
    }
  }
}

inline void simplifyword2(vector<int> &w, vector<int> rel) {
  bool done = false;
  while (!done && w.size()>0) {
    unsigned savelength = w.size();
    simplifyword(w,rel);
    done = w.size()==savelength;
  }
}

inline vector<int> intersect(vector<vector<int> > li) {
  vector<int> res;
  if (li.size()>0) {
    for (unsigned k=0; k<li[0].size(); k++) {
      bool iscommon = true;
      unsigned l=1;
      while (iscommon && l<li.size()) {
	iscommon = find(li[l].begin(),li[l].end(),li[0][k])!=li[l].end();
	l++;
      }
      if (iscommon) {
	res.push_back(li[0][k]);
      }
    }      
  }
  return res;
}

inline vector<int> intersect(vector<int> v, vector<int> w) {
  vector<int> res;
  for (unsigned k=0; k<v.size(); k++) {
    if (find(w.begin(),w.end(),v[k])!=w.end()) {
      res.push_back(v[k]);
    }
  }
  return res;
}

inline vector<int> findConjugatingWord(vector<int> v) {
  vector<int> res;
  if (v.size()%2==0) {
    cerr << "Word of even length, I don't know how to write it as a conjugation!" << endl;
    exit(1);
  }
  else {
    int n = (v.size()-1)/2;
    for (int j=0; j<n; j++) {
      res.push_back(v[j]);
    }
    return res;
  }  
}




#endif /* UTIL_H_ */