package gudusoft.gsqlparser.nodes;


import gudusoft.gsqlparser.ESqlClause;
import gudusoft.gsqlparser.TCustomSqlStatement;
import gudusoft.gsqlparser.TSourceToken;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.Vector;

/**
 * List of parse tree node.
 */
public class TParseTreeNodeList<T extends TParseTreeNode> extends TParseTreeNode implements Iterable<T> {

    public void addAll(TParseTreeNodeList sourceList){
        v.addAll(sourceList.v);
        modCount++;
    }
    public void clear(){
        v.clear();
        modCount++;
    }
    public void setListSeparatedByComma(boolean listSeparatedByComma) {
        this.listSeparatedByComma = listSeparatedByComma;
    }

    public boolean isListSeparatedByComma() {
        return listSeparatedByComma;
    }

    private boolean listSeparatedByComma = true;

    @Override
    public Iterator<T> iterator() {
        return new TParseTreeNodeList.NodeSetIterator();
    }

    private class NodeSetIterator implements Iterator {
        private int currentIndex = 0;

        @Override
        public boolean hasNext() {
           return (currentIndex < size())&&(size()>0);
        }

        @Override
        public T next() {
            return elementAt(currentIndex++);
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException();
        }
    }


    public void TParseTreeNodeList(){
    }


    protected int modCount = 0;

    private ArrayList<T> v = new ArrayList();

    public final int size()
    {
        return v.size();
    }

    public T elementAt(int index)
    {
        return  v.get(index);
    }

    public final void addElement(T ptn)
    {

        TParseTreeNode node = (TParseTreeNode)ptn;
        if ((node!=null)&&(!node.isTokensInChain())){
            if (this.size()>0){
                getElement(this.size()-1).appendNewNode(node,true);
            }else{

            }
        }

        v.add(ptn);
        modCount++;
    }

    public final void removeElementWithoutSyncTokens(int index)
    {
         v.remove(index);
         modCount++;
    }

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

    public final boolean removeElement(TParseTreeNode ptn)
    {
        boolean removed = v.remove(ptn);
        if (removed) modCount++;
        return removed;
    }

    final TParseTreeNode removeAndSyncTokens(int index)
    {
        if(TParseTreeNode.doubleLinkedTokenListToString){
            TParseTreeNode node = (TParseTreeNode) getElement(index);
            if (node.getNodeStatus() != ENodeStatus.nsRemoved){
                node.removeTokens();
            }
            v.remove(index);
            modCount++;
            // remove unnecessary comma if any
            if (this.size() != 0){
                TSourceToken lcPrevToken = null;
                if (this.getStartToken()!=null){
                    lcPrevToken = this.getStartToken().getPrevTokenInChain();
                }
                while (lcPrevToken != null){
                    if (lcPrevToken.tokencode == ','){
                        lcPrevToken.removeFromChain();
                        break;
                    }
                    if (lcPrevToken.issolidtoken()){
                        break;
                    }
                    lcPrevToken = lcPrevToken.getPrevTokenInChain();
                }

                TSourceToken lcNextToken = null;
                if (this.getEndToken() != null){
                    lcNextToken = this.getEndToken().getNextTokenInChain();
                }
                while (lcNextToken != null){
                    if (lcNextToken.tokencode == ','){
                        lcNextToken.updateNodeEndWithThisToken();
                        lcNextToken.removeFromChain();
                        break;
                    }
                    if (lcNextToken.issolidtoken()){
                        break;
                    }
                    lcNextToken = lcNextToken.getNextTokenInChain();
                }
                lcNextToken = null;
                if (this.getStartToken() != null){
                    lcNextToken = this.getStartToken().getNextTokenInChain();
                }
                boolean foundComma = false;
                while (lcNextToken != null){
                    if (lcNextToken.tokencode == ','){
                        if (foundComma){
                            lcNextToken.removeFromChain();
                            break;
                        }else{
                            foundComma = true;
                        }
                    }else if (lcNextToken.issolidtoken()){
                        foundComma = false;
                    }
                    lcNextToken = lcNextToken.getNextTokenInChain();
                    if (lcNextToken == this.getEndToken()) break;
                }

            }

            return node;

//            if (index == 0){
//                // first element
//                if (size() > 1){
//                    TSourceToken st = node.getEndToken().searchToken(",",1);
//                    if (st != null){
//                        st.removeFromChain();
//                    }
//                }
//            }else{
//                // second or later token
//                TSourceToken st = node.getStartToken().searchToken(",",-1);
//                if (st != null){
//                    st.removeFromChain();
//                }
//            }
        }else {
            modCount++;
            return((TParseTreeNode) (v.remove(index)));
        }

    }

    public final int indexOf(TParseTreeNode ptn)
    {
        return v.indexOf(ptn);
    }

    final void setElementAt(T ptn, int index)
    {
        v.set(index,ptn);
        modCount++;
    }


    public final void insertElementAt(T ptn, int index)
    {
        TParseTreeNode node = (TParseTreeNode)ptn;
        if (!node.isTokensInChain()){
            if ((this.size()>0)&&(index < this.size())){
                getElement(index).insertNewNodeBeforeMe(node,true);
            }else{

            }
        }

        v.add(index,ptn);
        modCount++;
    }

    public void init(Object arg1)
    {
        addParseTreeNode(arg1);
    }

    public void init(Object arg1,Object arg2)
    {
        addParseTreeNode(arg1);
        addParseTreeNode(arg2);
    }

    public void init(Object arg1,Object arg2,Object arg3)
    {
        addParseTreeNode(arg1);
        addParseTreeNode(arg2);
        addParseTreeNode(arg3);
    }

    public void init(Object arg1,Object arg2,Object arg3,Object arg4)
    {
        addParseTreeNode(arg1);
        addParseTreeNode(arg2);
        addParseTreeNode(arg3);
        addParseTreeNode(arg4);
    }

    void addParseTreeNode(Object arg1){
        addElement((T)arg1);
    }

    public void addNode(Object arg1){
      addParseTreeNode((TParseTreeNode)arg1);  
    }


    public  TParseTreeNode getElement(int index){
        return elementAt(index);
    }
    /**
     * analyze this node
     */
    public void doParse(TCustomSqlStatement psql, ESqlClause plocation){
     for(int i=0; i<size();i++){
         if (elementAt(i) != null){
            elementAt(i).doParse(psql,plocation);
         }
     }
    }


    public TSourceToken getStartToken() {
        if (size() == 0){
            return null;
        }else{
            return elementAt(0).getStartToken();
        }
    }

    public TSourceToken getEndToken() {
        if (size() == 0){
            return null;
        }else{
            return elementAt(size()-1).getEndToken();
        }
    }

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

    public void acceptChildren(TParseTreeVisitor v){
        v.preVisit(this);
        for(int i=0; i<size();i++){
            if (elementAt(i) != null){
                elementAt(i).acceptChildren(v);
            }
        }
        v.postVisit(this);
    }

    public TParseTreeNode removeItem(int index){
        return removeAndSyncTokens(index);
    }
}