#ifndef STATE

#define STATE

#include <glr/glrSymbolTable.h>
#include <glr/glrGrammar.h>

#include <map>
#include <vector>

using namespace std;

//typedef enum { none, active, both } queFlagType;

/**
 *
 * Class <tt>glrState</tt> is the base class for classes which represent state of the automat. On the other side, it represents one row of the glr
 * table. <tt>glrState</tt> class is never used directly. Instead of it, the parser uses <tt>glrState</tt> -- derived classes
 * which adds some other essential properties.
 *
 */
class glrState {
  private:
    int number;
  public:

//    queFlagType queFlag;
    
//    bool reducesFlag;

    /**
     *
     * The <tt>crossEdges</tt> field is used to store edges whitch runs from any vertex associated with any
     * active state to the vertex associated with this state.
     *
     */
    vector<pair<glrNode*, glrState*> > crossEdges;

    /**
     *
     * Field <tt>reduces</tt> is the vector of pointers to the grammar rules which can be used to make the reductions
     * from this state and concurrently which are not the epsilon rules and which have nonterminal on the end of the right side.
     *
     */
    vector<const class glrRule*> reduces;

    /**
     *
     * Field <tt>epsReduces</tt> is vector of pointers to grammar rules which can be used to make reductions
     * from this state and which are the epsilon rules (their right side is empty).
     *
     */
    vector<const class glrRule*> epsReduces;

    /**
     *
     * Field <tt>reduces</tt> is vector of pointers to the grammar rules which can be used to make the reductions
     * from this state and which are not the epsilon rules and which have the preterminal on the end of the right side.
     *
     */
    vector<const class glrRule*> termReduces;

    /**
     *
     * If this state is active --- this means, that on the top of the graph stack is its state vertex --- the field
     * <tt>stack</tt> points to this state vertex.
     *
     */
    class glrStateVertex *stack;

    /**
     *
     * The field <tt>futureStack</tt> is used temporarly in the 
     * <tt>glrParser::makeReductions</tt> and the <tt>glrParser::parse()</tt> functions.
     *
     */
    class glrStateVertex *futureStack;

    /**
     *
     * The field <tt>adtionalStack</tt> is used temporarly during 
     * <tt>glrParser::makeAditionalReductions</tt>.
     *
     */
//    class glrStateVertex *aditionalStack;

    /**
     *
     * If the state is active, this field says in which phase are reductions in regard of the state vertex stored in
     * the <tt>stack</tt> field. It can be one of this values: <tt>glrRedDone</tt>, <tt>glrRedMaking</tt>, <tt>glrRedWaiting</tt>, 
     * <tt>glrRedNotNeed</tt>.
     *
     */
//    glrReducesState reducesState;

    /**
     *
     * Functon <tt>getNumber()</tt> returns the number of this state.
     *
     */
    const int &getNumber() const { return number; }

    // bool crossInProgress;

    /**
     *
     * Constructor. <tt>numberA</tt> is the number of new state.
     *
     */
    glrState(const int &numberA) {
      number=numberA;
      // reducesState=glrRedNotNeed;
      stack=(glrStateVertex*)NULL;
      futureStack=(glrStateVertex*)NULL;
      // aditionalStack=NULL;
      // crossInProgress=false;
      //queFlag = none;
      //reducesFlag = false;
    }
};

/**
 *
 * Class <tt>glrMapState</tt> is the alternative implementation of the state of automat (the row of glr table). You can make the
 * parser to use it by specifying it as the second argument to the <tt>glrParser</tt> template.
 * This is the first implementation I used, but I found that it is about few slower then
 * <tt>glrVectorState</tt> which I use now. On the other side, memory requiments may be lower if this class is used
 * witch grammar with lots of symbols.
 *
 */
class glrMapState : public glrState {
  private:
    map<glrSymbolTable::glrSymbol,glrMapState*> gotos;
    map<glrSymbolTable::glrSymbol,glrMapState*> shifts;
  public:
    
    /**
     *
     * Constructor. <tt>numberA</tt> is the number of the state and <tt>symbols</tt> is the parser's
     * table of symbols.
     *
     */
    glrMapState(const int &numberA,const glrSymbolTable &symbols) : glrState(numberA) {};
    
    /**
     *
     * Function <tt>gotos_find</tt> returns the state where the parser can make
     * transition over symbol <tt>symbol</tt>. If there is not such transition
     * it returns <tt>NULL</tt>. The guaranted complexity
     * is logarithmic according to number of transitions stored.
     *
     */
    glrMapState* gotos_find(const glrSymbolTable::glrSymbol &symbol) const {
      const map<glrSymbolTable::glrSymbol,glrMapState*>::const_iterator &i=gotos.find(symbol);
      return (i!=gotos.end())?(i->second):((glrMapState*)NULL);
    }

    /**
     *
     * Function <tt>shifts_find</tt> returns the state where the parser
     * can make shift over the symbol <tt>symbol</tt>. If there is not such shift
     * from this state it returns <tt>NULL</tt>.
     * The guaranted complexity is logarithmic according to the number of shifts stored.
     *
     */
    glrMapState* shifts_find(const glrSymbolTable::glrSymbol &symbol) const {
      const map<glrSymbolTable::glrSymbol,glrMapState*>::const_iterator &i=shifts.find(symbol);
      return (i!=shifts.end())?(i->second):((glrMapState*)NULL);
    }

    /**
     *
     * Function <tt>gotos_insert</tt> inserts the transition to <tt>state</tt> over symbol <tt>symbol</tt>
     * to the row of the goto table.
     *
     */
    void gotos_insert(const glrSymbolTable::glrSymbol &symbol,glrMapState* const& state){
      gotos.insert(pair<glrSymbolTable::glrSymbol,glrMapState*>(symbol,state));
    }

    /** 
     *
     * Function <tt>shifts_insert</tt> inserts the shift to the <tt>state</tt> over symbol
     * <tt>symbol</tt> to the row of the glr table.
     *
     */
    void shifts_insert(const glrSymbolTable::glrSymbol &symbol,glrMapState* const& state){
      shifts.insert(pair<glrSymbolTable::glrSymbol,glrMapState*>(symbol,state));
    }

    /**
     *
     * Function <tt>print</tt> prints the state (row of glr table) in the form
     * in which the parser can read it from the file. <tt>symbols</tt> is parser's
     * table of symbols and the <tt>output</tt> is where to print.
     *
     */
    void print(const glrSymbolTable &symbols,ostream &output) const {
      output << "|State| " << getNumber() << endl;
      for(map<glrSymbolTable::glrSymbol,glrMapState*>::const_iterator i=gotos.begin();i!=gotos.end();++i)
        output << "\t\t" << symbols.getStringFromSymbol(i->first) << " " << i->second->getNumber() << endl;
      for(map<glrSymbolTable::glrSymbol,glrMapState*>::const_iterator i=shifts.begin();i!=shifts.end();++i)
        output << "\t\t" << symbols.getStringFromSymbol(i->first) << " " << i->second->getNumber() << endl;
      for(vector<const class glrRule*>::const_iterator i=reduces.begin();i!=reduces.end();++i)
        output << "\t\t__reduce " << (*i)->getNumber() << endl;
      for(vector<const class glrRule*>::const_iterator i=epsReduces.begin();i!=epsReduces.end();++i)
        output << "\t\t__reduce " << (*i)->getNumber() << endl;
      for(vector<const class glrRule*>::const_iterator i=termReduces.begin();i!=termReduces.end();++i)
        output << "\t\t__reduce " << (*i)->getNumber() << endl;
    }
};


/**
 *
 * Class <tt>glrVectorState</tt> is the parser's default class to storing the state (one row of the glr table).
 *
 */
class glrVectorState : public glrState {
  private:
    vector<glrVectorState*> transitions;
  public:

    /**
     *
     * Constructor. <tt>numberA</tt> is the number of the state and <tt>symbols</tt> is the parser's
     * table of symbols.
     *
     */
    glrVectorState(const int &numberA,const glrSymbolTable &symbols) : glrState(numberA) {
      transitions.resize(symbols.size());
      for(int i=0;i<symbols.size();++i){
        transitions[i]=(glrVectorState*)NULL;
      }
    }
    
    /**
     *
     * Function <tt>gotos_find</tt> returns the state where the parser can make
     * transition over the symbol <tt>symbol</tt>. If there is not such transition
     * it returns <tt>NULL</tt>. The guaranted complexity
     * is constant.
     *
     */
    glrVectorState* const &gotos_find(const glrSymbolTable::glrSymbol &symbol) const { return transitions[(int)symbol]; }
    
    /**
     *
     * Function <tt>shifts_find</tt> returns the state where the parser
     * can make shift over the symbol <tt>symbol</tt>. If there is not such shift
     * from this state it returns <tt>NULL</tt>.
     * The guaranted complexity is constant.
     *
     */
    glrVectorState* const &shifts_find(const glrSymbolTable::glrSymbol &symbol) const { return transitions[(int)symbol]; }
    
    /**
     *
     * Function <tt>gotos_insert</tt> inserts the transition to <tt>state</tt> over <tt>symbol</tt>
     * to the row of the goto table.
     *
     */
    void gotos_insert(const glrSymbolTable::glrSymbol &symbol,glrVectorState* const& state){ transitions[(int)symbol]=state; }

    /** 
     *
     * Function <tt>shifts_insert</tt> inserts the shift to <tt>state</tt> over symbol
     * <tt>symbol</tt> to the row of the glr table.
     *
     */
    void shifts_insert(const glrSymbolTable::glrSymbol &symbol,glrVectorState* const& state){ transitions[(int)symbol]=state; }
    
    /**
     *
     * Function <tt>print</tt> prints the state (row of the glr table) in the form
     * in which the parser can read it from the file. <tt>symbols</tt> is parser's
     * table of symbols and <tt>output</tt> is where to print.
     *
     */
    void print(const glrSymbolTable &symbols,ostream &output) const {
      output << "|State| " << getNumber() << endl;
      for(int i=0;i<transitions.size();++i)
        if(transitions[i]!=NULL)output << "\t\t" << symbols.getStringFromSymbol((glrSymbolTable::glrSymbol)i) << " " << transitions[i]->getNumber() << endl;
      for(vector<const class glrRule*>::const_iterator i=reduces.begin();i!=reduces.end();++i)
        output << "\t\t__reduce " << (*i)->getNumber() << endl;
      for(vector<const class glrRule*>::const_iterator i=epsReduces.begin();i!=epsReduces.end();++i)
        output << "\t\t__reduce " << (*i)->getNumber() << endl;
      for(vector<const class glrRule*>::const_iterator i=termReduces.begin();i!=termReduces.end();++i)
        output << "\t\t__reduce " << (*i)->getNumber() << endl;
    }
};

#endif