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 TSourceToken ALL= null;

    private boolean rollupModifier = false;
    private boolean cubeModifier = false;
    private boolean totalsModifier = false;
    private boolean allModifier = 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;
    }

    /**
     * Sets whether this GROUP BY clause uses the WITH TOTALS modifier.
     * <p>WITH TOTALS adds an extra row with totals to the result,
     * which is the sum across all values in the column.
     * <p>Applies to ClickHouse.
     *
     * @param totalsModifier true if WITH TOTALS is used, false otherwise
     */
    public void setTotalsModifier(boolean totalsModifier) {
        this.totalsModifier = totalsModifier;
    }

    /**
     * Returns whether this GROUP BY clause uses the WITH TOTALS modifier.
     * <p>WITH TOTALS adds an extra row with totals to the result.
     *
     * @return true if WITH TOTALS is used, false otherwise
     */
    public boolean isTotalsModifier() {
        return totalsModifier;
    }

    /**
     * Sets whether this GROUP BY clause uses the ALL modifier.
     * <p>GROUP BY ALL is a shorthand notation to add all SELECT-list expressions
     * not containing aggregate functions as group expressions.
     * <p>Applies to Databricks SQL Databricks Runtime 12.2 LTS and above.
     *
     * @param allModifier true if GROUP BY ALL is used, false otherwise
     */
    public void setAllModifier(boolean allModifier) {
        this.allModifier = allModifier;
    }

    /**
     * Returns whether this GROUP BY clause uses the ALL modifier.
     * <p>GROUP BY ALL automatically groups by all non-aggregate expressions
     * in the SELECT clause.
     *
     * @return true if GROUP BY ALL is used, false otherwise
     */
    public boolean isAllModifier() {
        return allModifier;
    }

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

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

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

    /**
     * Sets the ALL token for GROUP BY ALL syntax.
     *
     * @param ALL the ALL token
     */
    public void setALL(TSourceToken ALL) {
        this.ALL = ALL;
    }

    public TSourceToken getBY() {

        return BY;
    }

    public TSourceToken getGROUP() {
        return GROUP;
    }

    public TSourceToken getHAVING() {
        return HAVING;
    }

    /**
     * Gets the ALL token for GROUP BY ALL syntax.
     *
     * @return the ALL token, or null if GROUP BY ALL is not used
     */
    public TSourceToken getALL() {
        return ALL;
    }

    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;
    }
}