/*

 * 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.fold;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.List;

import java.util.Observable;

import java.util.Observer;

import java.util.logging.Level;

import java.util.logging.Logger;

import javax.swing.event.DocumentEvent;

import javax.swing.text.AbstractDocument;

import javax.swing.text.BadLocationException;

import javax.swing.text.Document;

import org.netbeans.api.editor.fold.Fold;

import org.netbeans.api.editor.fold.FoldHierarchy;

import org.netbeans.api.editor.fold.FoldType;

import org.netbeans.editor.BaseDocument;

import org.netbeans.modules.plsql.lexer.PlsqlBlock;

import org.netbeans.modules.plsql.lexer.PlsqlBlockFactory;

import org.netbeans.modules.plsql.lexer.PlsqlBlockType;

import org.netbeans.modules.plsqlsupport.options.OptionsUtilities;

import org.netbeans.spi.editor.fold.FoldHierarchyTransaction;

import org.netbeans.spi.editor.fold.FoldManager;

import org.netbeans.spi.editor.fold.FoldOperation;

import org.openide.util.Exceptions;

import org.openide.util.Lookup;

import org.openide.util.RequestProcessor;

/**

 *

 * @author chrlse

 */

public class NewPlsqlFoldManager implements FoldManager, Runnable, Observer {

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

    private static final RequestProcessor RP = new RequestProcessor(NewPlsqlFoldManager.class.getName(), 1, false, false);

    private static final int TASK_DELAY = 100;

    private final RequestProcessor.Task task = RP.create(this);

    private FoldOperation operation;

    private Document doc;

    // Note: FoldSearchObject need to be in a List, otherwise contains doesn't work. Seems HashSet keeps internal list of hash.

    private final List<FoldSearchObject> foldSearchObjects = new ArrayList<FoldSearchObject>();

    private List<Fold> removedFoldList = new ArrayList<Fold>(3);

    private boolean initial = true;

    private PlsqlBlockFactory blockFactory;

    @Override

    public void init(FoldOperation operation) {

        this.operation = operation;

        if (LOG.isLoggable(Level.FINE)) {

            LOG.log(Level.FINE, "Initialized: {0}", System.identityHashCode(this));

        }

    }

    private FoldOperation getOperation() {

        return operation;

    }

    @Override

    public void initFolds(FoldHierarchyTransaction transaction) {

        doc = getOperation().getHierarchy().getComponent().getDocument();

        blockFactory = getBlockFactory();

        if (blockFactory != null) {

            blockFactory.addObserver(this);

        }

        task.schedule(TASK_DELAY);

    }

    @Override

    public void insertUpdate(DocumentEvent evt, FoldHierarchyTransaction transaction) {

        if (LOG.isLoggable(Level.FINER)) {

            LOG.log(Level.FINER, "insertUpdate: {0}", System.identityHashCode(this));

        }

        processRemovedFolds(transaction);

    }

    @Override

    public void removeUpdate(DocumentEvent evt, FoldHierarchyTransaction transaction) {

        if (LOG.isLoggable(Level.FINER)) {

            LOG.log(Level.FINER, "removeUpdate: {0}", System.identityHashCode(this));

        }

        processRemovedFolds(transaction);

    }

    @Override

    public void changedUpdate(DocumentEvent evt, FoldHierarchyTransaction transaction) {

        if (LOG.isLoggable(Level.FINER)) {

            LOG.log(Level.FINER, "changeUpdate: {0}", System.identityHashCode(this));

        }

        processRemovedFolds(transaction);

    }

    @Override

    public void removeEmptyNotify(Fold emptyFold) {

        if (LOG.isLoggable(Level.FINER)) {

            LOG.log(Level.FINER, "removeEmptyNotify: {0}", System.identityHashCode(this));

        }

        removeFoldNotify(emptyFold);

    }

    @Override

    public void removeDamagedNotify(Fold damagedFold) {

        if (LOG.isLoggable(Level.FINER)) {

            LOG.log(Level.FINER, "removeDamagedNotify: {0}", System.identityHashCode(this));

        }

        removeFoldNotify(damagedFold);

    }

    @Override

    public void expandNotify(Fold expandedFold) {

    }

    @Override

    public void release() {

        if (LOG.isLoggable(Level.FINE)) {

            LOG.log(Level.FINE, "release: {0}", System.identityHashCode(this));

        }

    }

    @Override

    public void update(Observable o, Object arg) {

        if (LOG.isLoggable(Level.FINER)) {

            LOG.log(Level.FINER, "update: {0}", System.identityHashCode(this));

        }

        task.schedule(TASK_DELAY);

    }

    @Override

    public void run() {

        if (operation.isReleased()) {

            if (LOG.isLoggable(Level.FINE)) {

                LOG.log(Level.FINE, "Update skipped, already released: {0}", System.identityHashCode(this));

            }

            return;

        }

        ((BaseDocument) doc).readLock();

        try {

            if (blockFactory != null) {

                FoldHierarchy hierarchy = getOperation().getHierarchy();

                hierarchy.lock();

                try {

                    if (operation.isReleased()) {

                        if (LOG.isLoggable(Level.FINE)) {

                            LOG.log(Level.FINE, "Update skipped, already released: {0}", System.identityHashCode(this));

                        }

                        return;

                    }

                    if (LOG.isLoggable(Level.FINE)) {

                        LOG.log(Level.FINE, "Updating: {0}", System.identityHashCode(this));

                        LOG.log(Level.FINE, "blockFactory.getBlockHierarchy().size(): {0}", blockFactory.getBlockHierarchy().size());

                        LOG.log(Level.FINE, "blockFactory.getNewBlocks().size(): {0}", blockFactory.getNewBlocks().size());

                        LOG.log(Level.FINE, "blockFactory.getRemovedBlocks().size(): {0}", blockFactory.getRemovedBlocks().size());

                    }

                    FoldHierarchyTransaction transaction = getOperation().openTransaction();

                    try {

                        final Fold root = hierarchy.getRootFold();

                        if (initial) {

                            List<PlsqlBlock> blocks = blockFactory.getBlockHierarchy();

                            updateFolds(blocks, transaction, null);

                            //Add custom fold blocks

                            updateFolds(blockFactory.getCustomFolds(), transaction, null);

                            initial = false;

                        } else {

                            final List<FoldSearchObject> collapsedFolds = new ArrayList<FoldSearchObject>();

                            getCollapsedFolds(root, collapsedFolds);

                            final List<PlsqlBlock> oldBlocks = blockFactory.getRemovedBlocks();

                            //Remove non existing blocks   

                            if (!oldBlocks.isEmpty()) {

                                final int childCount = root.getFoldCount();

                                for (int i = (childCount - 1); i >= 0; i--) {

                                    final Fold child = root.getFold(i);

                                    removeWithChildren(child, oldBlocks, transaction);

                                }

                            }

                            //Add new blocks to the hierarchy

                            List<PlsqlBlock> blocks = blockFactory.getNewBlocks();

                            updateFolds(blocks, transaction, collapsedFolds);

                            //Add custom fold blocks

                            updateFolds(blockFactory.getCustomFolds(), transaction, collapsedFolds);

                        }

                    } catch (BadLocationException ex) {

                        Exceptions.printStackTrace(ex);

                    } finally {

                        transaction.commit();

                    }

                } finally {

                    hierarchy.unlock();

                }

            }

        } finally {

            ((BaseDocument) doc).readUnlock();

        }

    }

    private void getCollapsedFolds(final Fold parent, final List<FoldSearchObject> foldInfoLst) {

        if (parent.isCollapsed()) {

            final FoldSearchObject tempInfo = new FoldSearchObject(parent.getStartOffset(), parent.getEndOffset(), parent.getType());

            foldInfoLst.add(tempInfo);

        }

        final int count = parent.getFoldCount();

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

            final Fold temp = parent.getFold(i);

            getCollapsedFolds(temp, foldInfoLst);

        }

    }

    /**

     * Remove fold with its children

     *

     * @param fold

     * @param blockHier

     * @param transaction

     * @return true if removed all the children

     */

    private void removeWithChildren(final Fold fold, final List<PlsqlBlock> blockHier, final FoldHierarchyTransaction transaction) {

        final int childCount = fold.getFoldCount();

        for (int i = (childCount - 1); i >= 0; i--) {

            final Fold child = fold.getFold(i);

            removeWithChildren(child, blockHier, transaction);

        }

        //If a custom fold remove

        if (fold.getType() == PlsqlFoldTypes.CUSTOM || checkExists(fold, blockHier)) {

            operation.removeFromHierarchy(fold, transaction);

            foldSearchObjects.remove(new FoldSearchObject(new FoldAdapter(fold)));

        }

    }

    /**

     * Method that will check whether given fold exists in block hier

     *

     * @param fold

     * @param blockHier

     * @return

     */

    private boolean checkExists(final Fold fold, final List<PlsqlBlock> blockHier) {

        final Comparator<PlsqlBlock> comparator = new Comparator<PlsqlBlock>() {

            @Override

            public int compare(final PlsqlBlock o1, final PlsqlBlock o2) {

                Integer o1pos, o2pos;

                if (o1.getStartOffset() > -1 && o2.getStartOffset() > -1) {

                    o1pos = Integer.valueOf(o1.getStartOffset());

                    o2pos = Integer.valueOf(o2.getStartOffset());

                } else {

                    o1pos = Integer.valueOf(o1.getEndOffset());

                    o2pos = Integer.valueOf(o2.getEndOffset());

                }

                return o1pos.compareTo(o2pos);

            }

        };

        return checkExists(fold, blockHier, comparator);

    }

    /**

     * Method that will check whether given fold exists in block hier

     *

     * @param fold

     * @param blockHier

     * @param comparator

     * @return

     */

    private boolean checkExists(final Fold fold, final List<PlsqlBlock> blockHier, final Comparator<PlsqlBlock> comparator) {

        final int size = blockHier.size();

        Collections.sort(blockHier, comparator);

        if (size == 0) {

            return false;

        }

        //make sure that the fold isn't before the first block or after the last block in the hierarchy.

        if (fold.getStartOffset() > blockHier.get(size - 1).getEndOffset()

                || fold.getEndOffset() < blockHier.get(0).getStartOffset()) {

            return false;

        }

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

            final PlsqlBlock block = blockHier.get(i);

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

                return true;

            }

            if (block.getPreviousStart() <= fold.getStartOffset() && block.getPreviousEnd() >= fold.getEndOffset()) {

                return true;

            }

            if ((block.getEndOffset() == fold.getEndOffset() || fold.getEndOffset() == block.getPreviousEnd()

                    || block.getStartOffset() == fold.getStartOffset() || block.getPreviousStart() == fold.getStartOffset())

                    && (getFoldType(block.getType()).equals(fold.getType()))

                    && (getFoldDescription(block).equals(fold.getDescription()))) {

                return true;

            }

            if (checkExists(fold, block.getChildBlocks(), comparator)) {

                return true;

            }

        }

        return false;

    }

    private FoldType getFoldType(final PlsqlBlockType blockType) {

        switch (blockType) {

            case VIEW:

                return PlsqlFoldTypes.VIEW;

            case TABLE_COMMENT:

                return PlsqlFoldTypes.TABLECOMMENT;

            case COLUMN_COMMENT:

                return PlsqlFoldTypes.COLUMNCOMMENT;

            case COMMENT:

                return PlsqlFoldTypes.COMMENT;

            case PACKAGE:

                return PlsqlFoldTypes.PACKAGE;

            case PACKAGE_BODY:

                return PlsqlFoldTypes.PACKAGEBODY;

            case PROCEDURE_IMPL:

                return PlsqlFoldTypes.PROCEDUREIMPL;

            case FUNCTION_IMPL:

                return PlsqlFoldTypes.FUNCTIONIMPL;

            case PROCEDURE_DEF:

                return PlsqlFoldTypes.PROCEDUREDEF;

            case FUNCTION_DEF:

                return PlsqlFoldTypes.FUNCTIONDEF;

            case DECLARE_END:

                return PlsqlFoldTypes.DECLAREEND;

            case BEGIN_END:

                return PlsqlFoldTypes.BEGINEND;

            case TRIGGER:

                return PlsqlFoldTypes.TRIGGER;

            case IF:

                return PlsqlFoldTypes.IF;

            case CASE:

                return PlsqlFoldTypes.CASE;

            case WHILE_LOOP:

                return PlsqlFoldTypes.WHILELOOP;

            case FOR_LOOP:

                return PlsqlFoldTypes.FORLOOP;

            case LOOP:

                return PlsqlFoldTypes.LOOP;

            case CUSTOM_FOLD:

                return PlsqlFoldTypes.CUSTOM;

            case STATEMENT:

                return PlsqlFoldTypes.STATEMENT;

            case CURSOR:

                return PlsqlFoldTypes.CURSOR;

            case JAVA_SOURCE:

                return PlsqlFoldTypes.JAVASOURCE;

            default:

                return null;

        }

    }

    /**

     * Method that will return the fold description given the Plsql block Used

     * when changing the descriptions only.

     *

     * @param block

     * @return

     */

    private String getFoldDescription(final PlsqlBlock block) {

        switch (block.getType()) {

            case VIEW:

                return block.getPrefix() + "VIEW " + block.getName();

            case TABLE_COMMENT:

                return "COMMENT ON TABLE " + block.getName();

            case COLUMN_COMMENT:

                return "COLUMN COMMENTS ON TABLE " + block.getName();

            case COMMENT:

                return block.getName();

            case PACKAGE:

                return block.getPrefix() + "PACKAGE " + block.getName();

            case PACKAGE_BODY:

                return block.getPrefix() + "PACKAGE BODY " + block.getName();

            case PROCEDURE_IMPL:

                return block.getPrefix() + "PROCEDURE IMPLEMENTATION " + block.getName();

            case FUNCTION_IMPL:

                return block.getPrefix() + "FUNCTION IMPLEMENTATION " + block.getName();

            case PROCEDURE_DEF:

                return "PROCEDURE DEFINITION " + block.getName();

            case FUNCTION_DEF:

                return "FUNCTION DEFINITION " + block.getName();

            case DECLARE_END:

                return "DECLARE BLOCK";

            case BEGIN_END:

                return "BEGIN BLOCK";

            case TRIGGER:

                return block.getPrefix() + "TRIGGER " + block.getName();

            case IF:

                return block.getName();

            case CASE:

                return block.getName();

            case WHILE_LOOP:

                return "WHILE " + block.getName();

            case FOR_LOOP:

                return "FOR " + block.getName();

            case LOOP:

                return "LOOP ";

            case CUSTOM_FOLD:

                return block.getName();

            case STATEMENT:

                return block.getPrefix() + block.getName();

            case CURSOR:

                return "CURSOR " + block.getName();

            case JAVA_SOURCE:

                return block.getPrefix() + "JAVA SOURCE";

            default:

                return "";

        }

    }

    private void removeFoldNotify(Fold removedFold) {

        removedFoldList.add(removedFold);

    }

    private void processRemovedFolds(FoldHierarchyTransaction transaction) {

        for (Fold removedFold : removedFoldList) {

            operation.removeFromHierarchy(removedFold, transaction);

            if (LOG.isLoggable(Level.FINE)) {

                LOG.log(Level.FINE, "Fold={0} removed={1}", new Object[]{removedFold, true});

            }

        }

        removedFoldList.clear();

    }

    private Document getDocument() {

        Object obj = null;

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

            obj = getOperation().getHierarchy().getComponent().getDocument();

            if (obj instanceof AbstractDocument) {

                return (Document) obj;

            }

            try {

                Thread.currentThread().sleep(i);

            } catch (InterruptedException e) {

            }

        }

        throw new IllegalStateException("[PLSQLFolding] PLSQLFoldManager.getDocument() NOT returned AbstractDocument, but " + obj.getClass() + "!. This is caused by not yet resolved issue #49497."); //NOI18N

    }

    private void updateFolds(final List<PlsqlBlock> blockHier, final FoldHierarchyTransaction transaction, final List<FoldSearchObject> collapsedFolds) throws BadLocationException {

        final int count = blockHier.size();

        Document doc = getDocument();

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

            final PlsqlBlock block = blockHier.get(i);

            FoldType foldType = null;

            final PlsqlBlockType type = block.getType();

            String description = "";

            if (!(type == PlsqlBlockType.COMMENT && doc.getText(block.getStartOffset(), block.getEndOffset() - block.getStartOffset()).indexOf("\n") == -1)) { // check for single line comments

                foldType = getFoldType(type);

                description = getFoldDescription(block);

                if (doc.getEndPosition().getOffset() >= block.getEndOffset()) {                    

                    operation.addToHierarchy(foldType, description, isCollapsed(block, foldType, collapsedFolds),

                            block.getStartOffset(), block.getEndOffset(), 0, 0, null, transaction);

                    //check for any child folds and add them also

                    updateFolds(block.getChildBlocks(), transaction, collapsedFolds);

                }

            }

        }

    }

    /**

     * Method that will select and return the corresponding fold to parent from

     * oldRoot fold hierarchy

     *

     * @param parent

     * @param foldInfoLst

     * @return

     */

    private boolean isCollapsed(final PlsqlBlock block, final FoldType foldType, final List<FoldSearchObject> foldInfoLst) {

        if (OptionsUtilities.isPlSqlExpandFolds()) {

            return false;

        }

        if (foldInfoLst == null) {

            return foldType == PlsqlFoldTypes.COMMENT;

        }

        final int size = foldInfoLst.size();

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

            final FoldSearchObject temp = foldInfoLst.get(i);

            if ((temp.getFoldType() == foldType)

                    && (temp.getStartOffset() == block.getPreviousStart())

                    && (temp.getEndOffset() == block.getPreviousEnd())) {

                return true;

            }

        }

        return false;

    }

    /**

     * Method that will return the relevant block factory

     *

     * @return

     */

    private PlsqlBlockFactory getBlockFactory() {

        final Object obj = doc.getProperty(Document.StreamDescriptionProperty);

        if (obj instanceof Lookup.Provider) {

            return ((Lookup.Provider) obj).getLookup().lookup(PlsqlBlockFactory.class);

        }

        return null;

    }

}