/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2011 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2011 Sun Microsystems, Inc.

 */

package org.netbeans.modules.plsql.lexer;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedList;

import java.util.List;

import java.util.Locale;

import java.util.Map;

import java.util.Observable;

import java.util.StringTokenizer;

import java.util.logging.Level;

import java.util.logging.Logger;

import javax.swing.SwingUtilities;

import javax.swing.event.DocumentEvent;

import javax.swing.event.DocumentListener;

import javax.swing.text.AbstractDocument;

import javax.swing.text.BadLocationException;

import javax.swing.text.Document;

import org.netbeans.api.lexer.Token;

import org.netbeans.api.lexer.TokenHierarchy;

import org.netbeans.api.lexer.TokenSequence;

import org.openide.ErrorManager;

import org.openide.util.RequestProcessor;

/**

 * Class that will maintain code blocks of the file.

 *

 * @author YaDhLK

 */

public class PlsqlBlockFactory extends Observable implements DocumentListener {

    private static final Logger LOG = Logger.getLogger(PlsqlBlockFactory.class.getName());

    private List<PlsqlBlock> blockHierarchy;

    private List<PlsqlBlock> customFoldBlocks;

    private List<PlsqlBlock> newBlocks;

    private List<PlsqlBlock> toBeRemoved;

    private List<PlsqlBlock> changedBlocks;

    private HashSet<Integer> unsuccessBlocks;

    private HashMap<String, String> definesMap;

    private TokenHierarchy tokenHierarchy;

    private int docStartOffset = 0;

    private int docEndOffset = 0;

    private int startParse = 0;

    private int endParse = 0;

    private int changedLength = 0;

    private boolean isDefineChanged = false;

    private static RequestProcessor.Task updateBlocksTask = null;

    private static final LinkedList<EventProperties> updateEvents = new LinkedList<EventProperties>();

    private static final int DEFAULT_WAIT_TIME = 500;

    private boolean saveInProgress = false;

    private boolean caseChangeInProgress = false;

    private static final String updateLock = "This is used to synchronize navigator updates";

    private static final RequestProcessor RP = new RequestProcessor(PlsqlBlockFactory.class);

    public PlsqlBlockFactory() {

        blockHierarchy = new ArrayList<PlsqlBlock>();

        tokenHierarchy = null;

        newBlocks = new ArrayList<PlsqlBlock>();

        toBeRemoved = new ArrayList<PlsqlBlock>();

        changedBlocks = new ArrayList<PlsqlBlock>();

        customFoldBlocks = new ArrayList<PlsqlBlock>();

        definesMap = new HashMap<String, String>();

        unsuccessBlocks = new HashSet<Integer>();

    }

    /**

     * Method used to reparse the whole document

     *

     * @param doc

     */

    public void reParse(Document doc) {

        clear();

        if (doc == null) {

            return;

        }

        docStartOffset = doc.getStartPosition().getOffset();

        docEndOffset = doc.getEndPosition().getOffset();

        startParse = docStartOffset;

        endParse = docEndOffset - 1;

        //clean block hierarchy

        blockHierarchy.clear();

        customFoldBlocks.clear();

        generateBlocks(doc);

    }

    /**

     * Return new blocks that were recognized by the latest change

     *

     * @return

     */

    public List<PlsqlBlock> getNewBlocks() {

        return newBlocks;

    }

    /**

     * Return the blocks who's offsets have changed

     *

     * @return

     */

    public List<PlsqlBlock> getChangedBlocks() {

        return changedBlocks;

    }

    /**

     * Return the custom fold blocks that are there

     *

     * @return

     */

    public List<PlsqlBlock> getCustomFolds() {

        return customFoldBlocks;

    }

    /**

     * Return block hierarchy

     *

     * @return

     */

    public List<PlsqlBlock> getBlockHierarchy() {

        return blockHierarchy;

    }

    /**

     * Method that will return the blocks that are removed

     *

     * @return

     */

    public List<PlsqlBlock> getRemovedBlocks() {

        return toBeRemoved;

    }

    /**

     * Check whether there are childrean of this fold here, if so add them

     *

     * @param block

     * @param immediateBlockHier

     */

    private void addImmediateChildren(PlsqlBlock block, List<PlsqlBlock> immediateBlockHier) {

        for (int i = immediateBlockHier.size() - 1; i >= 0; i--) {

            PlsqlBlock tmp = immediateBlockHier.get(i);

            if ((tmp.getStartOffset() > block.getStartOffset())

                    && (tmp.getEndOffset() < block.getEndOffset())) {

                if (checkExisting(tmp, newBlocks)) {

                    newBlocks.remove(tmp);

                } else {

                    removeBlock(block, immediateBlockHier);

                }

                block.addChild(tmp);

            }

        }

    }

    /**

     * Method that will look for custom start or end token based on the given type

     *

     * @param customEndToken

     * @param ts

     * @param immediateBlockHier

     * @param parent

     * @param type

     */

    private void checkCustom(Token<PlsqlTokenId> customToken, TokenSequence<PlsqlTokenId> ts, List<PlsqlBlock> immediateBlockHier, PlsqlBlock parent, String type) {

        Token<PlsqlTokenId> found = customToken;

        Token<PlsqlTokenId> token = customToken;

        if (type.equals("START")) {

            //We have to find the end fold token now

            ts.move(found.offset(tokenHierarchy));

            ts.moveNext();

            while (ts.moveNext()) {

                token = ts.token();

                String image = token.text().toString();

                PlsqlTokenId tokenID = token.id();

                if (tokenID == PlsqlTokenId.LINE_COMMENT) {

                    //only single comment line

                    if (image.toUpperCase(Locale.ENGLISH).contains("<FOLD>")) {

                        //We have come to another start

                        return;

                    } else if (image.toUpperCase(Locale.ENGLISH).contains("<END-FOLD>")) {

                        if (isTokenOk(token, immediateBlockHier, parent)) {

                            String name = found.text().toString();

                            int index = name.toUpperCase(Locale.ENGLISH).indexOf("<FOLD>");

                            name = name.substring(index + 7).trim();

                            if (ts.moveNext()) {

                                token = ts.token();

                                PlsqlBlock custom = new PlsqlBlock(found.offset(tokenHierarchy),

                                        token.offset(tokenHierarchy), name, "", PlsqlBlockType.CUSTOM_FOLD);

                                customFoldBlocks.add(custom);

                            }

                        }

                        //since we have found the other tag return

                        return;

                    }

                }

            }

        } else {

            ts.move(found.offset(tokenHierarchy));

            //We have to find the start fold token now

            while (ts.movePrevious()) {

                token = ts.token();

                String image = token.text().toString();

                PlsqlTokenId tokenID = token.id();

                if (tokenID == PlsqlTokenId.LINE_COMMENT) {

                    //only single comment line

                    if (image.toUpperCase(Locale.ENGLISH).contains("<FOLD>")) {

                        if (isTokenOk(token, immediateBlockHier, parent)) {

                            String name = image;

                            int index = name.toUpperCase(Locale.ENGLISH).indexOf("<FOLD>");

                            name = name.substring(index + 7).trim();

                            ts.move(found.offset(tokenHierarchy));

                            ts.moveNext();

                            if (ts.moveNext()) {

                                found = ts.token();

                                PlsqlBlock custom = new PlsqlBlock(token.offset(tokenHierarchy),

                                        found.offset(tokenHierarchy), name, "", PlsqlBlockType.CUSTOM_FOLD);

                                customFoldBlocks.add(custom);

                            }

                        }

                        //since we have found the other tag return

                        return;

                    } else if (image.toUpperCase(Locale.ENGLISH).contains("<END-FOLD>")) {

                        //We have come to another end

                        return;

                    }

                }

            }

        }

    }

    /**

     * Method that will check for a Java Source block

     *

     * @param tempToken

     * @param ts

     * @param immediateBlockHier

     * @return

     */

    private PlsqlBlock checkJavaSource(Token<PlsqlTokenId> tempToken, TokenSequence<PlsqlTokenId> ts) {

        Token<PlsqlTokenId> begin = tempToken;

        Token<PlsqlTokenId> tmp = tempToken;

        PlsqlBlock block = null;

        //Check whether the beginning is in a SQL Plus command

        if (sqlPlusLine(ts)) {

            return null;

        }

        while (ts.moveNext()) {

            tmp = ts.token();

            String image = tmp.text().toString();

            PlsqlTokenId tokenID = tmp.id();

            if ((!image.equals("/")) && (tmp.offset(tokenHierarchy) > endParse)) {

                break;

            }

            //We might have come to the end of the procedure/function declaration

            if ((tokenID == PlsqlTokenId.OPERATOR) && image.equals("/")) {

                //check whether previous Non white space token to the identifier is END

                int offset = ts.offset();

                if (checkForOnlyChar(ts, offset)) {

                    ts.move(offset);

                    ts.moveNext();

                    ts.moveNext();

                    block = new PlsqlBlock(begin.offset(tokenHierarchy), offset, "", "", PlsqlBlockType.JAVA_SOURCE);

                    checkPrefix(begin.offset(tokenHierarchy), ts, block);

                    break;

                }

            }

        }

        return block;

    }

    /**

     * Check whether this current token is the only token in this line

     *

     * @param ts

     * @param offset

     * @return

     */

    private boolean checkForOnlyChar(TokenSequence<PlsqlTokenId> ts, int offset) {

        boolean isStartOk = true;

        boolean isEndOk = true;

        ts.move(offset);

        Token<PlsqlTokenId> token = null;

        while (ts.movePrevious()) {

            token = ts.token();

            if (token.id() == PlsqlTokenId.WHITESPACE) {

                if (token.toString().contains("\n")) {

                    break;

                }

            } else if (token.id() == PlsqlTokenId.JAVA_SOUCE) {

                break;

            } else {

                isStartOk = false;

                break;

            }

        }

        ts.move(offset);

        ts.moveNext(); //current token

        while (ts.moveNext()) {

            token = ts.token();

            if (token.id() == PlsqlTokenId.WHITESPACE) {

                if (token.toString().contains("\n")) {

                    break;

                }

            } else {

                isEndOk = false;

                break;

            }

        }

        ts.move(offset);

        ts.moveNext();

        if (isStartOk && isEndOk) {

            return true;

        }

        return false;

    }

    /**

     * Method that will check for statement blocks other than the CURSOR and VIEW

     *

     * @param tempToken

     * @param ts

     * @param immediateBlockHier

     * @return

     */

    private PlsqlBlock checkStatementBlock(Token<PlsqlTokenId> current, TokenSequence<PlsqlTokenId> ts, List<PlsqlBlock> parentBlocks) {

        List<PlsqlBlock> lstChild = new ArrayList<PlsqlBlock>();

        PlsqlBlock block = null;

        //Check whether the beginning is in a SQL Plus command

        if (sqlPlusLine(ts)) {

            return null;

        }

        boolean moveNext = ts.moveNext();

        Token<PlsqlTokenId> token = ts.token();

        Token<PlsqlTokenId> stmtBegin = current;

        boolean getName = true;

        Token<PlsqlTokenId> customStartToken = null;

        String name = current.text().toString();

        while (moveNext) {

            String image = token.text().toString();

            PlsqlTokenId tokenID = token.id();

            if ((token != null) && (!image.equals(";")) && (!image.equals("/")) && (token.offset(tokenHierarchy) > endParse)) {

                break;

            }

            if (image.equals(";") || (image.equals("/") && checkForOnlyChar(ts, ts.offset()))) {

                block = new PlsqlBlock(stmtBegin.offset(tokenHierarchy), token.offset(tokenHierarchy), name.trim(), "", PlsqlBlockType.STATEMENT);

                checkPrefix(stmtBegin.offset(tokenHierarchy), ts, block);

                break;

            } else if (image.equalsIgnoreCase("CREATE")

                    || image.equalsIgnoreCase("DECLARE")

                    || image.equalsIgnoreCase("BEGIN")

                    || image.equalsIgnoreCase("WHEN")

                    || image.equalsIgnoreCase("THEN")

                    || image.equalsIgnoreCase("IF")

                    || image.equalsIgnoreCase("END")

                    || image.equalsIgnoreCase("ELSE")

                    || image.equalsIgnoreCase("LOOP")) {

                break;

            } else if (image.equalsIgnoreCase("CASE")) {

                int beforeOff = token.offset(tokenHierarchy);

                List children = checkCaseBlock(token, ts, lstChild, true);

                if (children == null || children.isEmpty()) {//If inner check seems to have failed need to continue this one

                    ts.move(beforeOff);

                    moveNext = ts.moveNext();

                } else {

                    for (int i = 0; i < children.size(); i++) {

                        PlsqlBlock child = (PlsqlBlock) children.get(i);

                        if (checkExisting(child, lstChild) == false) {

                            lstChild.add(child);

                        }

                    }

                }

            } else if (tokenID == PlsqlTokenId.LINE_COMMENT) {

                //only single comment line

                if (image.toUpperCase(Locale.ENGLISH).contains("<FOLD>")) {

                    customStartToken = token;

                } else if (image.toUpperCase(Locale.ENGLISH).contains("<END-FOLD>")) {

                    if (customStartToken != null) {

                        if (ts.moveNext()) {

                            token = ts.token();

                            PlsqlBlock custom = new PlsqlBlock(customStartToken.offset(tokenHierarchy),

                                    token.offset(tokenHierarchy), name, "", PlsqlBlockType.CUSTOM_FOLD);

                            customFoldBlocks.add(custom);

                        }

                        customStartToken = null;

                    }

                } else {

                    PlsqlBlock child = checkComment(token, ts);

                    if (child != null) {

                        if (checkExisting(child, lstChild) == false) {

                            lstChild.add(child);

                        }

                    }

                }

            } else if (tokenID == PlsqlTokenId.BLOCK_COMMENT) {

                int start = token.offset(tokenHierarchy);

                PlsqlBlock child = new PlsqlBlock(start,

                        start + token.length(), "BLOCK COMMENT", "", PlsqlBlockType.COMMENT);

                if (child != null) {

                    if (checkExisting(child, lstChild) == false) {

                        lstChild.add(child);

                    }

                }

            } else if (tokenID == PlsqlTokenId.WHITESPACE && image.contains("\n")) {

                getName = false;

            } else if (getName) {

                name = name + image;

            }

            moveNext = ts.moveNext();

            token = ts.token();

        }

        if (block != null) {

            //add children

            addChildren(block, lstChild, parentBlocks);

        }

        return block;

    }

    /**

     * Check whether the given token offset is included in any existing block

     *

     * @param token

     * @param immediateBlockHier

     * @param parent

     * @return

     */

    private boolean isTokenOk(Token<PlsqlTokenId> token, List<PlsqlBlock> immediateBlockHier, PlsqlBlock parent) {

        boolean isOk = true;

        int offset = token.offset(tokenHierarchy);

        for (int i = immediateBlockHier.size() - 1; i >= 0; i--) {

            PlsqlBlock block = immediateBlockHier.get(i);

            if ((block.getStartOffset() <= offset) && (block.getEndOffset() >= offset)) {

                isOk = false;

                break;

            }

        }

        if (isOk && parent != null) {

            if (!((parent.getStartOffset() <= offset) && (parent.getEndOffset() >= offset))) {

                isOk = false;

            }

        }

        return isOk;

    }

    /**

     * Method that will look for trigger blocks

     *

     * @param tempToken

     * @param ts

     * @param parentBlocks

     * @return

     */

    private PlsqlBlock checkTrigger(Token<PlsqlTokenId> tiggerToken, TokenSequence<PlsqlTokenId> ts, List<PlsqlBlock> parentBlocks) {

        Token<PlsqlTokenId> triggerBegin = tiggerToken;

        Token<PlsqlTokenId> tmp = tiggerToken;

        PlsqlBlock block = null;

        List<PlsqlBlock> lstChild = new ArrayList<PlsqlBlock>();

        String triggerName = "";

        boolean moveNext = false;

        //Check whether the beginning is in a SQL Plus command

        if (sqlPlusLine(ts)) {

            return null;

        }

        //Get procedure/function name which is the next non whitespace token

        moveNext = getNextNonWhitespace(ts, true);

        tmp = ts.token();

        if (moveNext == false) {

            return block;

        }

        triggerName = tmp.text().toString();

        triggerName = checkForOtherSchema(ts, triggerName);

        String alias = "";

        if (triggerName.indexOf('&') != -1) {

            alias = triggerName;

        }

        triggerName = getDefine(triggerName);

        Token<PlsqlTokenId> customStartToken = null;

        while (moveNext) {

            String image = tmp.text().toString();

            PlsqlTokenId tokenID = tmp.id();

            if ((tmp != null) && (!image.equals(";")) && (tmp.offset(tokenHierarchy) > endParse)) {

                break;

            }

            //We might have come to the end of the procedure/function declaration

            if ((tokenID == PlsqlTokenId.OPERATOR) && image.equals(";")) {

                //check whether previous Non white space token to the identifier is END

                int offset = ts.offset();

                getPreviousNonWhitespace(ts, true);

                Token<PlsqlTokenId> previousNWS = ts.token();

                String prevText = previousNWS.text().toString();

                getPreviousNonWhitespace(ts, true);

                previousNWS = ts.token();

                if (alias.equals("")) {

                    if ((prevText.equalsIgnoreCase(triggerName)

                            && previousNWS.text().toString().equalsIgnoreCase("END"))

                            || prevText.equalsIgnoreCase("END")) {

                        ts.move(offset);

                        moveNext = ts.moveNext();

                        moveNext = ts.moveNext();

                        block = new PlsqlBlock(triggerBegin.offset(tokenHierarchy),

                                ts.offset(), triggerName, alias, PlsqlBlockType.TRIGGER);

                        checkPrefix(triggerBegin.offset(tokenHierarchy), ts, block);

                        break;

                    }

                } else {

                    if ((prevText.equalsIgnoreCase(alias)

                            && previousNWS.text().toString().equalsIgnoreCase("END"))

                            || prevText.equalsIgnoreCase("END")) {

                        ts.move(offset);

                        moveNext = ts.moveNext();

                        moveNext = ts.moveNext();

                        block = new PlsqlBlock(triggerBegin.offset(tokenHierarchy),

                                ts.offset(), triggerName, alias, PlsqlBlockType.TRIGGER);

                        checkPrefix(triggerBegin.offset(tokenHierarchy), ts, block);

                        break;

                    }

                }

                ts.move(offset);

                moveNext = ts.moveNext();

            } else if (image.equalsIgnoreCase("TABLE")

                    || image.equalsIgnoreCase("INDEX")

                    || image.equalsIgnoreCase("SELECT")

                    || image.equalsIgnoreCase("UPDATE")

                    || image.equalsIgnoreCase("DELETE")

                    || image.equalsIgnoreCase("INSERT")

                    || image.equalsIgnoreCase("MERGE")

                    || image.equalsIgnoreCase("DROP")

                    || image.equalsIgnoreCase("SEQUENCE")) {

                if (!isNotBlockStart(tmp, ts)) {

                    int offset = tmp.offset(tokenHierarchy);

                    PlsqlBlock child = checkStatementBlock(tmp, ts, parentBlocks);

                    if (child == null) {//If inner check seems to have failed need to continue this one

                        ts.move(offset);

                        ts.moveNext();

                    } else {

                        if (checkExisting(child, lstChild) == false) {

                            lstChild.add(child);

                        }

                    }

                }

            } else if (image.equalsIgnoreCase("PROCEDURE")) {

                int beforeOff = tmp.offset(tokenHierarchy);

                PlsqlBlock child = checkMethod(tmp, ts, PlsqlBlockType.PROCEDURE_IMPL, lstChild);

                if (child == null) {//If inner check seems to have failed need to continue this one

                    ts.move(beforeOff);

                    ts.moveNext();

                } else {

                    if (checkExisting(child, lstChild) == false) {

                        lstChild.add(child);

                    }

                }

            } //Inner procedure

            else if (image.equalsIgnoreCase("FUNCTION")) {

                int beforeOff = tmp.offset(tokenHierarchy);

                PlsqlBlock child = checkMethod(tmp, ts, PlsqlBlockType.FUNCTION_IMPL, lstChild);

                if (child == null) {//If inner check seems to have failed need to continue this one

                    ts.move(beforeOff);

                    ts.moveNext();

                } else {

                    if (checkExisting(child, lstChild) == false) {

                        lstChild.add(child);

                    }

                }

            } else if (image.equalsIgnoreCase("CREATE")

                    || image.equalsIgnoreCase("/")

                    || image.equalsIgnoreCase("PACKAGE")) {

                break;

            } else if (tokenID == PlsqlTokenId.LINE_COMMENT) {

                //only single comment line

                if (image.toUpperCase(Locale.ENGLISH).contains("<FOLD>")) {

                    customStartToken = tmp;

                } else if (image.toUpperCase(Locale.ENGLISH).contains("<END-FOLD>")) {

                    if (customStartToken != null) {

                        String name = customStartToken.text().toString();

                        int index = name.toUpperCase(Locale.ENGLISH).indexOf("<FOLD>");

                        name = name.substring(index + 7).trim();

                        if (ts.moveNext()) {

                            tmp = ts.token();

                            PlsqlBlock custom = new PlsqlBlock(customStartToken.offset(tokenHierarchy),

                                    tmp.offset(tokenHierarchy), name, "", PlsqlBlockType.CUSTOM_FOLD);

                            customFoldBlocks.add(custom);

                        }

                        customStartToken = null;

                    }

                } else {

                    PlsqlBlock child = checkComment(tmp, ts);

                    if (child != null) {

                        if (checkExisting(child, lstChild) == false) {

                            lstChild.add(child);

                        }

                    }

                }

            } else if (tokenID == PlsqlTokenId.BLOCK_COMMENT) {

                int start = tmp.offset(tokenHierarchy);

                PlsqlBlock child = new PlsqlBlock(start,

                        start + tmp.length(), "BLOCK COMMENT", "", PlsqlBlockType.COMMENT);

                if (child != null) {

                    if (checkExisting(child, lstChild) == false) {

                        lstChild.add(child);

                    }

                }

            }

            moveNext = ts.moveNext();

            tmp = ts.token();

        }

        if (block != null) {

            //add children

            addChildren(block, lstChild, parentBlocks);

        }

        return block;

    }

    /**

     * Method that will check the prefix of the given block and change the block values accordingly

     *

     * @param startOffset

     * @param ts

     * @param begin

     */

    private void checkPrefix(int startOffset, TokenSequence<PlsqlTokenId> ts, PlsqlBlock block) {

        String prefix = "";

        int offset = ts.offset();

        ts.move(startOffset);

        ts.moveNext();

        Token<PlsqlTokenId> token = ts.token();

        int beginOffset = startOffset;

        while (ts.movePrevious()) {

            token = ts.token();

            String image = token.text().toString();

            if (image.contains("\n") || (token.id() != PlsqlTokenId.KEYWORD && token.id() != PlsqlTokenId.WHITESPACE)) {

                break;

            }

            prefix = token.text().toString() + prefix;

            if (token.id() != PlsqlTokenId.WHITESPACE) {

                beginOffset = ts.offset();

            }

        }

        ts.move(offset);

        ts.moveNext();

        block.setStartOffset(beginOffset);

        block.setPrefix(prefix);

    }

    /**

     * Check whether there is a block existing with the given offset as the start offset

     *

     * @param blockHierarchy

     * @param offset

     * @return

     */

    private boolean isBlockStartExisting(List<PlsqlBlock> blockHierarchy, int offset) {

        boolean isExisting = false;

        for (int i = blockHierarchy.size() - 1; i >= 0; i--) {

            PlsqlBlock tmp = blockHierarchy.get(i);

            if (tmp.getStartOffset() == offset) {

                isExisting = true;

                break;

            }

            if (!isExisting) {

                if (isBlockStartExisting(tmp.getChildBlocks(), offset)) {

                    isExisting = true;

                    break;

                }

            }

        }

        return isExisting;

    }

    private boolean isEqual(PlsqlBlock parent, PlsqlBlock block) {

        if ((parent == null) || (block == null)) {

            return false;

        }

        if ((parent.getStartOffset() == block.getStartOffset())

                || (parent.getEndOffset() == block.getEndOffset())

                || (parent.getName().equalsIgnoreCase(block.getName()))) {

            return true;

        }

        return false;

    }

    private String readLine(TokenSequence<PlsqlTokenId> ts, Token<PlsqlTokenId> token) {

        String line = token.toString();

        while (ts.moveNext()) {

            token = ts.token();

            if (token.id() == PlsqlTokenId.WHITESPACE && token.text().toString().contains("\n")) {

                ts.movePrevious();

                break;

            }

            line = line + token.toString();

        }

        return line;

    }

    /**

     * Method that will remove the begin block of this declare block if there

     *

     * @param declareBlock

     */

    private void removeChildBegin(PlsqlBlock declareBlock) {

        //can check from the root hierarchies since begin/declare cannot be child blocks

        for (int i = blockHierarchy.size() - 1; i >= 0; i--) {

            PlsqlBlock tmp = blockHierarchy.get(i);

            if ((tmp.getStartOffset() > declareBlock.getStartOffset())

                    && (tmp.getEndOffset() == declareBlock.getEndOffset())

                    && (tmp.getType() == PlsqlBlockType.BEGIN_END)) {

                blockHierarchy.remove(tmp);

            }

        }

    }

    /**

     * Change offsets of the blocks below the area

     *

     * @param blockHier

     * @param endParse

     * @param length

     */

    private void changeOffSet(List<PlsqlBlock> blockHier, int offset, int length, boolean add, boolean adjust) {

        int count = blockHier.size();

        int start = 0;

        int end = 0;

        for (int i = 0; i < count; i++) {

            PlsqlBlock temp = blockHier.get(i);

            start = temp.getStartOffset();

            end = temp.getEndOffset();

            if (temp.getStartOffset() >= offset) {

                if (temp.getPreviousStart() == -1) {

                    temp.setPreviousStart(start);

                }

                if (start + length < 0) {

                    temp.setStartOffset(0);

                } else {

                    temp.setStartOffset(start + length);

                    if (startParse == start && adjust) //changing offsets of toBeRemoved

                    {

                        startParse = start + length;

                    }

                }

                if (temp.getPreviousEnd() == -1) {

                    temp.setPreviousEnd(end);

                }

                if (end + length < 0) {

                    temp.setEndOffset(0);

                } else {

                    temp.setEndOffset(end + length);

                    if (endParse == end && adjust) //changing offsets of toBeRemoved

                    {

                        endParse = end + length;

                    }

                }

                if (add) {

                    addToChangedBlocks(temp);

                }

                changeOffSet(temp.getChildBlocks(), offset, length, add, adjust);

            } else if (temp.getEndOffset() >= offset) {

                if (temp.getPreviousEnd() == -1) {

                    temp.setPreviousEnd(end);

                }

                if (end + length < 0) {

                    temp.setEndOffset(0);

                } else {

                    temp.setEndOffset(end + length);

                    if (endParse == end && adjust) //changing offsets of toBeRemoved

                    {

                        endParse = end + length;

                    }

                }

                if (add) {

                    addToChangedBlocks(temp);

                }

                changeOffSet(temp.getChildBlocks(), offset, length, add, adjust);

            }

        }

    }

    /**

     * Method that will check whether there are DEFINE statements in the affected area

     *

     * @param doc

     * @param startOffset

     * @param endOffset

     */

    private void checkAffected(Document doc, int startOffset, int endOffset) throws BadLocationException {

        int length = endOffset - startOffset;

        String changedText = doc.getText(startOffset, length);

        if ((changedText.toUpperCase(Locale.ENGLISH).indexOf("DEFINE ") != -1)

                || (changedText.toUpperCase(Locale.ENGLISH).indexOf("DEFIN ") != -1)

                || (changedText.toUpperCase(Locale.ENGLISH).indexOf("DEFI ") != -1)

                || (changedText.toUpperCase(Locale.ENGLISH).indexOf("DEF ") != -1)) {

            isDefineChanged = true;

        }

    }

    /**

     * Method that will make CURSOR blocks

     *

     * @param tempToken

     * @param ts

     * @param parentBlocks

     * @return

     */

    private PlsqlBlock checkCursor(Token<PlsqlTokenId> current, TokenSequence<PlsqlTokenId> ts, List<PlsqlBlock> parentBlocks) {

        Token<PlsqlTokenId> cursorBegin = current;

        Token<PlsqlTokenId> tmp = current;

        Token<PlsqlTokenId> cursorEnd = null;

        PlsqlBlock block = null;

        List<PlsqlBlock> lstChild = new ArrayList<PlsqlBlock>();

        boolean moveNext = false;

        //Check whether the beginning is in a SQL Plus command

        if (sqlPlusLine(ts)) {

            return null;

        }

        //Get next token which is the name

        int offset = ts.offset();

        moveNext = getNextNonWhitespace(ts, false);

        tmp = ts.token();

        if (moveNext == false) {

            ts.move(offset);

            ts.moveNext();

            return block;

        }

        String cursorName = tmp.text().toString();

        String alias = "";

        if (cursorName.indexOf('&') != -1) {

            alias = cursorName;

        }

        cursorName = getDefine(cursorName);

        //Next token has to be IS or ( if not leave

        moveNext = getNextNonWhitespace(ts, false);

        tmp = ts.token();

        boolean isFound = false;

        boolean parameter = false;

        Token<PlsqlTokenId> customStartToken = null;

        while (moveNext) {

            PlsqlTokenId tokenID = tmp.id();

            String image = tmp.text().toString();

            if ((tmp != null) && (!image.equals(";")) && (tmp.offset(tokenHierarchy) > endParse)) {

                break;

            }

            //When we have come up to ';' stop

            if ((tokenID == PlsqlTokenId.OPERATOR) && (image.equals(";"))) {

                if (isFound) {

                    if (ts.moveNext()) {

                        tmp = ts.token();

                    }

                    cursorEnd = tmp;

                    break;

                } else {

                    ts.move(offset);

                    ts.moveNext();

                    return null;

                }

            } else if ((tokenID == PlsqlTokenId.LPAREN) && (!isFound)) {

                parameter = true;

            } else if ((tokenID == PlsqlTokenId.RPAREN) && (!isFound)) {

                parameter = false;

            } else if (tokenID == PlsqlTokenId.KEYWORD) {

                if (image.equalsIgnoreCase("IS")) {

                    isFound = true;

                } else if ((!parameter) && //If this keyword is a parameter inside cursor ignore

                        ((image.equalsIgnoreCase("SUBTYPE"))

                        || (image.equalsIgnoreCase("CONSTANT"))

                        || (image.equalsIgnoreCase("NUMBER"))

                        || (image.equalsIgnoreCase("VARCHAR2")))) { //Avoid catching ';' of other statements

                    return null;

                } else if ((image.equalsIgnoreCase("VIEW"))

                        || (image.equalsIgnoreCase("PROCEDURE"))

                        || (image.equalsIgnoreCase("FUNCTION"))

                        || (image.equalsIgnoreCase("BEGIN"))

                        || (image.equalsIgnoreCase("DECLARE"))

                        || (image.equalsIgnoreCase("CREATE"))

                        || (image.equalsIgnoreCase("CURSOR"))

                        || (image.equalsIgnoreCase("EXCEPTION"))

                        || (image.equalsIgnoreCase("PRAGMA"))

                        || (image.equalsIgnoreCase("END"))

                        || (image.equalsIgnoreCase("COMMENT"))) { //Avoid catching ';' of other statements

                    return null;

                }

            } else if (tokenID == PlsqlTokenId.LINE_COMMENT) {

                //only single comment line

                if (image.toUpperCase(Locale.ENGLISH).contains("<FOLD>")) {

                    customStartToken = tmp;

                } else if (image.toUpperCase(Locale.ENGLISH).contains("<END-FOLD>")) {

                    if (customStartToken != null) {

                        String name = customStartToken.text().toString();

                        int index = name.toUpperCase(Locale.ENGLISH).indexOf("<FOLD>");

                        name = name.substring(index + 7).trim();

                        if (ts.moveNext()) {

                            tmp = ts.token();

                            PlsqlBlock custom = new PlsqlBlock(customStartToken.offset(tokenHierarchy),

                                    tmp.offset(tokenHierarchy), name, "", PlsqlBlockType.CUSTOM_FOLD);

                            customFoldBlocks.add(custom);

                        }

                        customStartToken = null;

                    }

                } else {

                    PlsqlBlock child = checkComment(tmp, ts);