package gudusoft.gsqlparser.nodes;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.ESqlClause;
import gudusoft.gsqlparser.TBaseType;
import gudusoft.gsqlparser.TCustomSqlStatement;
import gudusoft.gsqlparser.TSourceToken;
import gudusoft.gsqlparser.sqlenv.TSQLEnv;

import java.util.ArrayList;
import java.util.Collections;

/*
* Date: 2010-2-3
* Time: 11:13:19
*/
public class TResultColumnList extends TParseTreeNodeList <TResultColumn>{

    private ArrayList<TResultColumn> sortedResultColumns = null;

    private boolean isSorted = false;

    public ArrayList<TResultColumn> getSortedColumns(){
        if (isSorted) return sortedResultColumns;
        if (sortedResultColumns == null){
            sortedResultColumns = new ArrayList<>();
        }
        for(int i=0;i<size();i++){
            TResultColumn rc = getResultColumn(i);
            sortedResultColumns.add(rc);
        }
        Collections.sort(sortedResultColumns);
        isSorted = true;
        return sortedResultColumns;
    }

    public TResultColumnList()
        {
        }


    public void removeResultColumn(int index){
            this.removeItem(index);
    }

    public TParseTreeNode removeItem(int index){
        TSourceToken st=null ;
        if ((index<0)||(index>size())) return null;

        if (TParseTreeNode.doubleLinkedTokenListToString){
           // getResultColumn(index).removeTokens();

        }else {
            if (size() > 1){
                if (index != size() - 1){
                    st = getResultColumn(index).getEndToken().searchToken(",",1);
                }else{
                    st = getResultColumn(index).getStartToken().searchToken(",",-1);
                }
            }
            getResultColumn(index).removeAllMyTokensFromTokenList(st);
        }


        return super.removeItem(index);
    }

    /**
     * Used to add a result column manually when re-construct a select list
     * There must exist at least one column in column list in order to this function.
     * @param ptext
     */
    public void addResultColumn(String ptext){
        if (size() == 0) return;

        TResultColumn column = new TResultColumn();
        column.setGsqlparser(this.getGsqlparser());
        column.setString(","+ptext);

        TResultColumn last_column = getResultColumn(size()-1);
        TSourceToken last_token = last_column.getEndToken();

        column.addAllMyTokensToTokenList(last_token.container, last_token.posinlist + 1);

        for(int i=0;i<last_token.getNodesEndWithThisToken().size();i++){
            TParseTreeNode node = last_token.getNodesEndWithThisToken().get(i);
            if (!(node instanceof TResultColumn)){
                // change all end token of parse tree node except the last result column
                node.setEndToken(column.getEndToken());
            }
        }

    }

    /**
         * Add a ResultColumn  to the list
         *
         * @param resultColumn  The ResultColumn to add to the list
         */

        public void addResultColumn(TResultColumn resultColumn)
        {
                /* Vectors are 0-based, ResultColumns are 1-based */
                // resultColumn.setVirtualColumnId(size() + 1);
                addElement(resultColumn);
        }

    /**
     * Get a ResultColumn from a column position (0-based) in the list
     *
     * @param position  The ResultColumn to get from the list (1-based)
     *
     * @return  the column at that position.
     */

    public TResultColumn getResultColumn(int position)
    {
        if (position < size())
        {
            return (TResultColumn)elementAt(position);
        }else{
        return null;
        }
    }

    void addParseTreeNode(Object arg1){
        addResultColumn((TResultColumn)arg1);
    }


    /**
     * In teradata, the whole result column can be null, so this result column
     * should be ingored when get start token in result column list.
     * @return
     */
    public TSourceToken getStartToken() {
        TSourceToken ret = null;
        for(int i=0;i<this.size();i++){
            ret = this.getResultColumn(i).getStartToken();
            if (ret != null){
                break;
            };
        }
        return ret;
    }

    public TSourceToken getEndToken() {
        TSourceToken ret = null;
        for(int i = this.size() -1; i >= 0; i--){
            ret = this.getResultColumn(i).getEndToken();
            if (ret != null){
                break;
            };
        }
        return ret;
    }

    public void doParse(TCustomSqlStatement psql, ESqlClause plocation){
        for(int i=0;i<size();i++){
            getResultColumn(i).doParse(psql,plocation);
        }
    }

    /**
     * Find the SELECT-list column alias that an unqualified reference elsewhere in the
     * same SELECT block binds to — a "lateral column alias" reference such as
     * Snowflake's {@code SELECT val*2 AS derived_col FROM t WHERE derived_col > 1}.
     *
     * <p>This is the SINGLE definition of that binding rule. Both consumers delegate
     * here so the two paths can never drift apart:</p>
     * <ul>
     *   <li><b>publish</b> — Phase 1 {@code TCustomSqlStatement.linkColumnToTable()},
     *       which sets {@code sourceColumn} and deliberately leaves
     *       {@code sourceTable} null;</li>
     *   <li><b>lookup</b> — resolver2
     *       {@code TSQLResolver2.handleSelectListAliasResolution()}.</li>
     * </ul>
     * <p>Fixing one and not the other yields a reference whose {@code sourceColumn}
     * is the alias while its {@code sourceTable} is a FROM-clause table that has no
     * such column — a wrong answer with nothing to flag it (MantisBT 4659).</p>
     *
     * <p>The rule is vendor-gated twice: the dialect must support lateral column
     * aliases at all ({@link TBaseType#isSupportLateralColumn}), and it must not
     * forbid referencing a SELECT-list alias outside ORDER BY
     * ({@link TSQLEnv#isAliasReferenceForbidden}). Oracle, MySQL, PostgreSQL,
     * BigQuery and friends forbid it, so for them such a name is NOT an alias
     * reference and this returns null.</p>
     *
     * <p>The reference must also appear textually AFTER the alias it binds to. That
     * ordering rule is what keeps a column inside the alias's own defining
     * expression ({@code CAST(id AS DECIMAL) AS id}) bound to the real table column
     * rather than to the alias being defined.</p>
     *
     * @param vendor    the dialect of the enclosing statement
     * @param reference an unqualified column reference from the same SELECT block
     * @return the defining {@link TResultColumn}, or {@code null} when this is not a
     *         lateral column alias reference
     */
    public TResultColumn findLateralAliasDefinition(EDbVendor vendor, TObjectName reference){
        if ((vendor == null) || (reference == null)) return null;
        if (!TBaseType.isSupportLateralColumn(vendor)) return null;
        Boolean forbidden = TSQLEnv.isAliasReferenceForbidden.get(vendor);
        if ((forbidden == null) || forbidden.booleanValue()) return null;
        if (reference.isQualified()) return null;
        if (reference.getStartToken() == null) return null;

        for(int i=0;i<size();i++){
            TResultColumn resultColumn = getResultColumn(i);
            if (resultColumn == null) continue;
            if (!resultColumn.isMatchedUsingAlias(reference)) continue;
            TAliasClause alias = resultColumn.getAliasClause();
            if ((alias == null) || (alias.getStartToken() == null)) continue;
            // only a BACKWARD reference binds to the alias
            if (reference.getStartToken().posinlist > alias.getStartToken().posinlist){
                return resultColumn;
            }
        }
        return null;
    }

    public void accept(TParseTreeVisitor v){
        v.preVisit(this);
        v.postVisit(this);
    }
//
    public void acceptChildren(TParseTreeVisitor v){
        v.preVisit(this);
        for(int i=0;i<this.size();i++){
            this.getResultColumn(i).acceptChildren(v);
        }
        v.postVisit(this);
    }

}