package gudusoft.gsqlparser.nodes;

import gudusoft.gsqlparser.ESqlClause;
import gudusoft.gsqlparser.TCustomSqlStatement;
import gudusoft.gsqlparser.TSourceToken;
import gudusoft.gsqlparser.nodes.couchbase.TBinding;

/**
 * This class represents group by clause and having clause.
 * <p>
 * <p>Specify the GROUP BY clause if you want the database to group the selected rows based on
 * the value of expr(s) for each row and return a single row of summary information for each group.
 * <p>If this clause contains CUBE or ROLLUP extensions, then the database
 * produces superaggregate groupings in addition to the regular groupings.
 * <p>
 * <p>Use the HAVING clause to restrict the groups of returned rows to those groups for
 * which the specified condition is TRUE. If you omit this clause, then the database returns summary rows for all groups.
*/
public class TGroupBy extends TParseTreeNode {

    private TQualifyClause qualifyClause;

    public void setQualifyClause(TQualifyClause qualifyClause) {
        this.qualifyClause = qualifyClause;
    }

    public TQualifyClause getQualifyClause() {
        return qualifyClause;
    }

    private TPTNodeList<TBinding> bindings;

    public TPTNodeList<TBinding> getBindings() {
        return bindings;
    }

    private TGroupByItemList items = null;
    private TExpression havingClause = null;

    private TSourceToken GROUP= null;
    private TSourceToken BY= null;

    private boolean rollupModifier = false;
    private boolean cubeModifier = false;

    public void setCubeModifier(boolean cubeModifier) {
        this.cubeModifier = cubeModifier;
    }

    public boolean isCubeModifier() {
        return cubeModifier;
    }

    public void setRollupModifier(boolean rollupModifier) {
        this.rollupModifier = rollupModifier;
    }

    public boolean isRollupModifier() {

        return rollupModifier;
    }

    public void setBY(TSourceToken BY) {
        this.BY = BY;
    }

    public void setGROUP(TSourceToken GROUP) {
        this.GROUP = GROUP;
    }

    public void setHAVING(TSourceToken HAVING) {
        this.HAVING = HAVING;
    }

    public TSourceToken getBY() {

        return BY;
    }

    public TSourceToken getGROUP() {
        return GROUP;
    }

    public TSourceToken getHAVING() {
        return HAVING;
    }

    private TSourceToken HAVING= null;

    /**
     * Restrict the groups of returned rows to those groups for which the specified condition is TRUE.
     * <p>If you omit this clause, then the database returns summary rows for all groups.
     * @return
     */
    public TExpression getHavingClause() {
        return havingClause;
    }

    /**
     *
     * @return Items in group by clause, can be expr, rollup_cube_clause and grouping_sets_clause.
     * @see TExpression
     * @see TRollupCube
     * @see TGroupingSet
     */
    public TGroupByItemList getItems() {
        if (items == null){
            items = new TGroupByItemList();
        }
        return items;
    }

    public void setHavingClause(TExpression havingClause) {
        this.havingClause = havingClause;
        if ((this.getHAVING() != null)&&(this.havingClause == null)){
            this.getHAVING().removeFromChain();
        }
    }

    public void init(Object arg1){
        bindings = (TPTNodeList<TBinding>)arg1;
    }

    public void init(Object arg1,Object arg2)
    {
       if (arg1 != null){
           if (arg1 instanceof TGroupByItemList){
            items = (TGroupByItemList)arg1;
           }else if (arg1 instanceof TExpressionList){
               items = new TGroupByItemList();
               TExpressionList expressionList  = (TExpressionList)arg1;
               for(int i=0;i<expressionList.size();i++ ){
                   TGroupByItem item = new TGroupByItem();
                   item.setExpr(expressionList.getExpression(i));
                   item.setStartToken(expressionList.getExpression(i));
                   item.setEndToken(expressionList.getExpression(i));
                   items.addGroupByItem(item);
               }
           }
       }
       if (arg2 != null){
           havingClause = (TExpression)arg2;
       }
    }

    public void doParse(TCustomSqlStatement psql, ESqlClause plocation){
        if (items != null){
            items.doParse(psql,plocation);
        }
        if (havingClause != null){
            havingClause.doParse(psql,ESqlClause.having);
        }
    }

    public void setBindings(TPTNodeList<TBinding> bindings) {
        this.bindings = bindings;
    }

    public void accept(TParseTreeVisitor v){
        v.preVisit(this);
        v.postVisit(this);
    }

    public void acceptChildren(TParseTreeVisitor v){
        v.preVisit(this);
        if (this.getItems() != null){
            this.getItems().acceptChildren(v);
        }

        if (this.getHavingClause() != null){
            this.getHavingClause().acceptChildren(v);
        }
        v.postVisit(this);
    }

    public void setItems(TGroupByItemList items) {
        this.items = items;
    }
}