package gudusoft.gsqlparser.nodes;

import gudusoft.gsqlparser.*;
import gudusoft.gsqlparser.sqlenv.TSQLTable;
import gudusoft.gsqlparser.visitors.TColumnNameVisitor;

import java.util.ArrayList;

/**
*  use the PIVOT and UNPIVOT relational operators to change a table-valued expression into another table. 
*/

public class TPivotClause extends TNodeWithAliasClause implements IRelation {


    ArrayList<TAttributeNode> relationAttributes = new ArrayList<>();
    @Override
    public ArrayList<TAttributeNode> getAttributes(){
        return relationAttributes;
    }

    @Override
    public int size(){
        return relationAttributes.size();
    }

    @Override
    public String getRelationName(){
        return displayName;
    };

    private String displayName;
    public String getDisplayName(){
        return displayName;
    }
    public void initAttributes(){
        displayName = "";
        ArrayList<String> columns = new ArrayList<>();

        switch (getType()) {
            case pivot:
                displayName = TTable.PIVOT_CLAUSE_ALIAS;
                if (pivotInClause.getItems() != null){
                    for(TResultColumn resultColumn: pivotInClause.getItems()){
                        columns.add(resultColumn.getDisplayName());
                    }
                }
                break;
            case unpivot:
                displayName = TTable.UNPIVOT_CLAUSE_ALIAS;
                break;
        }


        if (getAliasClause() != null){
            displayName = getAliasClause().getAliasName().toString();
            if (getAliasClause().getColumns() != null){
                columns.clear();
                for(TObjectName column:getAliasClause().getColumns()){

                    columns.add(column.toString());
                }
            }
        }

        for(String c:columns){
            TAttributeNode node = new TAttributeNode(displayName+"."+c,pivotTable);
            //relationAttributes.add(node);
            TAttributeNode.addNodeToList(node,relationAttributes);
        }

    }


    public final static int pivot = 1;
    public final static int unpivot = 2;

    private int type = pivot;

    public TTable getPivotTable() {
        return pivotTable;
    }

    private TTable pivotTable = null;


//    private TAliasClause aliasClause = null;
//
//    @Override
//    public TAliasClause getAliasClause() {
//        return aliasClause;
//    }
//
//    @Override
//    public void setAliasClause(TAliasClause aliasClause) {
//
//        this.aliasClause = aliasClause;
//    }

    private TPivotInClause pivotInClause;

    public TPivotInClause getPivotInClause() {
        return pivotInClause;
    }

    private TUnpivotInClause unpivotInClause;

    public TUnpivotInClause getUnpivotInClause() {
        return unpivotInClause;
    }

    private TResultColumnList aggregation_function_list;
    /**
     * @deprecated since 1.7.1.1
     */
    private TResultColumnList in_result_list;

    private TObjectNameList pivotColumnList;

    public TObjectNameList getPivotColumnList() {
        return pivotColumnList;
    }

    /**
     * @deprecated since 1.7.1.1, use {@link #getPivotInClause} instead
     * @return result column list
     */
    public TResultColumnList getIn_result_list() {
        return in_result_list;
    }

    public TResultColumnList getAggregation_function_list() {

        return aggregation_function_list;
    }

    public void setType(int type) {
        this.type = type;
    }

    public int getType() {

        return type;
    }

    private TFunctionCall aggregation_function = null;
    /**
     * @deprecated since 1.7.1.1, use  {@link #valueColumnList} instead
     */
    private TObjectName valueColumn = null;
    private TObjectNameList valueColumnList = null;

    public TObjectNameList getValueColumnList() {
        return valueColumnList;
    }

    /**
     * @deprecated since 1.7.1.1, use {@link #getPivotColumnList} instead.
     */
    private TObjectName pivotColumn = null;
    private TObjectNameList columnList = null;

    /**
     *
     * @return Is a system or user-defined aggregate function that accepts one or more inputs. 
     */
    public TFunctionCall getAggregation_function() {
        return aggregation_function;
    }

    /**
     *
     * @return     In the PIVOT clause, lists the values in the pivot_column that will become the column names of the output table. The list cannot specify any column names that already exist in the input table_source that is being pivoted.
     *  In the UNPIVOT clause, lists the columns in table_source that will be narrowed into a single pivot_column.
     */
    public TObjectNameList getColumnList() {
        return columnList;
    }

    /**
     * @deprecated since 1.7.1.1 , use {@link #getPivotColumnList} instead.
     * @return Is the pivot column of the PIVOT operator. 
     */
    public TObjectName getPivotColumn() {
        return pivotColumn;
    }

    /**
     * @deprecated  since 1.7.1.1, use {@link #getValueColumnList} instead.
     * @return  Is the value column of the PIVOT operator.
     * When used with UNPIVOT, value_column cannot be the name of an existing column in the input table_source.
     */
    public TObjectName getValueColumn() {
        return valueColumn;
    }

    public void init(Object arg1,Object arg2){
        if (arg1 instanceof TFunctionCall){
            aggregation_function = (TFunctionCall)arg1; // pivot clause, sql server
        }else if (arg1 instanceof TResultColumnList){
            aggregation_function_list = (TResultColumnList)arg1; // pivot clause, oracle
        }else if (arg1 instanceof TObjectNameList){
           valueColumnList = (TObjectNameList)arg1; // unpivot clause
        }else if (arg1 instanceof TObjectName){
            valueColumn = (TObjectName)arg1;
        }

        if (arg2 instanceof TObjectName){
            pivotColumn = (TObjectName)arg2;
        }else if (arg2 instanceof TObjectNameList){
            pivotColumnList = (TObjectNameList)arg2;
        }
    }

    public void init(Object arg1,Object arg2,Object arg3){
        init(arg1,arg2);
        if (arg3 instanceof TUnpivotInClause){
            unpivotInClause = (TUnpivotInClause)arg3;
        } else if (arg3 instanceof TPivotInClause){
            pivotInClause = (TPivotInClause)arg3;
        }
//        else if (arg3 instanceof TResultColumnList){
//            in_result_list = (TResultColumnList)arg3;
//        } else if (arg3 instanceof TObjectNameList){
//            pivotColumnList = (TObjectNameList)arg3;
//        }
    }

    public void doParse(TCustomSqlStatement psql, ESqlClause plocation){
        TSQLTable sqlTable = null;
        boolean addColumnFromAlias = false;

        if (getAliasClause() != null){
            getAliasClause().doParse(psql,plocation);

            pivotTable = new TTable();

            pivotTable.setTableName(getAliasClause().getAliasName());
            pivotTable.setTableType(ETableSource.pivoted_table);
            pivotTable.setEffectType(ETableEffectType.tetPivot);
            psql.getTables().addTable(pivotTable);

            pivotTable.setSourceTableOfPivot(psql.getTables().getTable(0));

            if (psql.getSqlEnv() != null) {
                sqlTable = psql.getSqlEnv().addTable(pivotTable.getFullName(), true);
            }
            if (getAliasClause().getColumns()!=null){
                addColumnFromAlias = true;
                for(TObjectName column:getAliasClause().getColumns()){
                    pivotTable.getLinkedColumns().addObjectName(column);
                    column.setSourceTable(pivotTable);
                }

                if (sqlTable != null){
                    for(TObjectName column:getAliasClause().getColumns()){
                        sqlTable.addColumn(column.toString());
                    }
                }
            }
        }else { // alias is not specified

            pivotTable = new TTable();
            if (getType() == pivot){
                pivotTable.setTableName(TObjectName.createObjectName (psql.dbvendor, EDbObjectType.column_alias,new TSourceToken("pivot_alias")));
            }else{
                pivotTable.setTableName(TObjectName.createObjectName (psql.dbvendor,EDbObjectType.column_alias,new TSourceToken("unpivot_alias")));
            }


            pivotTable.setTableType(ETableSource.pivoted_table);
            pivotTable.setEffectType(ETableEffectType.tetPivot);
            psql.getTables().addTable(pivotTable);

            pivotTable.setSourceTableOfPivot(psql.getTables().getTable(0));

            if (psql.getSqlEnv() != null) {
                sqlTable = psql.getSqlEnv().addTable(pivotTable.getFullName(), true);
            }
        }

        switch (getType()){
            case pivot:
                if (aggregation_function_list != null){
                    TColumnNameVisitor objectNameVisitor = new TColumnNameVisitor();
                    aggregation_function_list.acceptChildren(objectNameVisitor);
                    for(TObjectName objectName:objectNameVisitor.getObjectNames()){
                        pivotTable.getSourceTableOfPivot().getLinkedColumns().addObjectName(objectName);
                        objectName.setSourceTable(pivotTable.getSourceTableOfPivot());
                    }
                    aggregation_function_list.doParse(psql,plocation);
                }else if (aggregation_function != null){
                    TColumnNameVisitor objectNameVisitor = new TColumnNameVisitor();
                    aggregation_function.getArgs().acceptChildren(objectNameVisitor);
                    for(TObjectName objectName:objectNameVisitor.getObjectNames()){
                        pivotTable.getSourceTableOfPivot().getLinkedColumns().addObjectName(objectName);
                        objectName.setSourceTable(pivotTable.getSourceTableOfPivot());
                    }

                    aggregation_function.doParse(psql,plocation);
                };

                if (pivotColumnList != null){
                    for(TObjectName objectName:pivotColumnList){
                        pivotTable.getSourceTableOfPivot().getLinkedColumns().addObjectName(objectName);
                        objectName.setSourceTable(pivotTable.getSourceTableOfPivot());
                    }
                }
                pivotInClause.doParse(psql,plocation);
                if (!addColumnFromAlias){
                    pivotInClause.linkColumnToTable(pivotTable, sqlTable);
                }

                break;
            case unpivot:
                //valueColumnList.
                if (pivotTable!=null){
                    if (valueColumnList != null){
                        for(TObjectName objectName: valueColumnList){
                            pivotTable.getLinkedColumns().addObjectName(objectName);
                            objectName.setSourceTable(pivotTable);
                            if (sqlTable != null){
                                sqlTable.addColumn(objectName.toString());
                            }
                        }
                    }

                    if (pivotColumnList!=null){
                        for(TObjectName objectName: pivotColumnList){
                            pivotTable.getLinkedColumns().addObjectName(objectName);
                            objectName.setSourceTable(pivotTable);
                            if (sqlTable != null){
                                sqlTable.addColumn(objectName.toString());
                            }
                        }
                    }
                }
                unpivotInClause.doParse(psql,plocation);
                unpivotInClause.linkColumnToPivotSourceTable(pivotTable.getSourceTableOfPivot());
                break;
        }
    }

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

    public void acceptChildren(TParseTreeVisitor v){
        v.preVisit(this);
      //  pivotTable.acceptChildren(v);
        switch (getType()){
            case pivot:
                if (aggregation_function_list != null){
                    aggregation_function_list.acceptChildren(v);
                }else if (aggregation_function != null){
                    aggregation_function.acceptChildren(v);
                }
                pivotColumnList.acceptChildren(v);
                if (pivotInClause != null){
                    pivotInClause.acceptChildren(v);
                }
                break;
            case unpivot:
                valueColumnList.acceptChildren(v);
                pivotColumnList.acceptChildren(v);
                unpivotInClause.acceptChildren(v);
                break;
        }


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

    public void setPivotInClause(TPivotInClause pivotInClause) {
        this.pivotInClause = pivotInClause;
    }

    public void setUnpivotInClause(TUnpivotInClause unpivotInClause) {
        this.unpivotInClause = unpivotInClause;
    }

    public void setAggregation_function_list(TResultColumnList aggregation_function_list) {
        this.aggregation_function_list = aggregation_function_list;
    }

    public void setPivotColumnList(TObjectNameList pivotColumnList) {
        this.pivotColumnList = pivotColumnList;
    }

    public void setAggregation_function(TFunctionCall aggregation_function) {
        this.aggregation_function = aggregation_function;
    }

    public void setValueColumnList(TObjectNameList valueColumnList) {
        this.valueColumnList = valueColumnList;
    }

    public void setColumnList(TObjectNameList columnList) {
        this.columnList = columnList;
    }
}