import org.netbeans.modules.cnd.modelimpl.platform.CsmEventDispatcher;

        onFileObjectExternalCreate(Arrays.asList(file));

    }

    public final void onFileObjectExternalCreate(Collection<FileObject> files) {

    /*package*/ interface Delegate {

        void index(FileObject file);

        void removed(FileObject root);

    }

    private static volatile Delegate delegate;

    /*package*/ static void setDelegate(Delegate d) {

        delegate = d;

    }

/*

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

 *

 * Copyright 2014 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 2014 Sun Microsystems, Inc.

 */

package org.netbeans.modules.cnd.modelimpl.platform;

import java.util.logging.Logger;

import org.netbeans.modules.cnd.api.project.NativeFileItem;

import org.netbeans.modules.cnd.api.project.NativeProject;

import org.netbeans.modules.cnd.modelimpl.debug.TraceFlags;

import org.openide.filesystems.FileObject;

/**

 * Combines file events (as in FileChangeListener)

 * and native project item events (as in NativeProjectListener)

 * @author Vladimir Kvashin

 */

/*package*/ class CsmEvent {

    public static final Logger LOG = Logger.getLogger("CsmEvent"); // NOI18N

    public enum Kind {

        FILE_DELETED(FileObject.class),

        FILE_CREATED(FileObject.class),

        FILE_RENAMED_CREATED(FileObject.class),

        FILE_RENAMED_DELETED(FileObject.class),

        FOLDER_CREATED(FileObject.class),

        FILE_CHANGED(FileObject.class),

        FILE_ATTRIBUTE_CHANGED(FileObject.class),

        ITEM_ADDED(NativeFileItem.class),

        ITEM_REMOVED(NativeFileItem.class),

        ITEM_PROPERTY_CHANGED(NativeFileItem.class),

        ITEMS_ALL_PROPERTY_CHANGED(null),

        ITEM_RENAMED_DELETED(NativeFileItem.class),

        ITEM_RENAMED_CREATED(NativeFileItem.class),

        PROJECT_DELETED(NativeProject.class),

        FILES_IN_SOURCE_ROOT_DELETED(FileObject.class),

        FILE_INDEXED(FileObject.class),

        NULL(null);

        private final Class cls;

        private Kind(Class cls) {

            this.cls = cls;

        }

    }

    private final Kind kind;

    private final Object object;

    private final String oldPath;

    /*package*/ static CsmEvent create(Kind kind, CsmEvent event) {

        return new CsmEvent(kind, event.object, event.oldPath);

    }

    /*package*/ static CsmEvent createItemEvent(Kind kind, NativeFileItem item) {

        return new CsmEvent(kind, item, null);

    }

    /*package*/ static CsmEvent createItemEvent(Kind kind, NativeFileItem item, String oldPath) {

        return new CsmEvent(kind, item, oldPath);

    }

    /*package*/ static CsmEvent createFileEvent(Kind kind, FileObject fileObject) {

        return new CsmEvent(kind, fileObject, null);

    }

    /*package*/ static CsmEvent createFileEvent(Kind kind, FileObject fileObject, String oldNameExt) {

        return new CsmEvent(kind, fileObject, oldNameExt);

    }

    /*package*/ static CsmEvent createEmptyEvent(Kind kind) {

        return new CsmEvent(kind, null, null);

    }

    /*package*/ static CsmEvent createProjectEvent(Kind kind, NativeProject project) {

        return new CsmEvent(kind, project, null);

    }

    private CsmEvent(Kind kind, Object object, String oldPath) {

        assert (object == null) ? kind.cls == null : kind.cls.isAssignableFrom(object.getClass());

        this.kind = kind;

        this.object = object;

        this.oldPath = oldPath;

    }

    public Kind getKind() {

        return kind;

    }

    public String getPath() {

        if (object instanceof FileObject) {

            return ((FileObject) object).getPath();

        } else if (object instanceof NativeFileItem) {

            return ((NativeFileItem) object).getAbsolutePath();

        } else {

            return null;

        }

    }

    public String getOldPath() {

        return oldPath;

    }

    public FileObject getFileObject() {

        return get(FileObject.class);

    }

    public NativeFileItem getNativeFileItem() {

        return get(NativeFileItem.class);

    }

    public NativeProject getNativeProject() {

        return get(NativeProject.class);

    }

    private <T> T get(Class<T> cls) {

        if (object != null && cls.isAssignableFrom(object.getClass())) {

            return (T) object;

        }

        return null;

    }

    @Override

    public String toString() {

        return getClass().getSimpleName() + ' ' + kind + ' ' + object + ' ' + oldPath;

    }

    public static void trace(String format, Object... args) {

        if (TraceFlags.TRACE_EXTERNAL_CHANGES) {

            System.out.printf("CsmEvent: %s\n", String.format(format, args));

        }

    }

}

/*

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

 *

 * Copyright 2014 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 2014 Sun Microsystems, Inc.

 */

package org.netbeans.modules.cnd.modelimpl.platform;

import java.util.Collection;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedList;

import java.util.List;

import java.util.Set;

import java.util.logging.Level;

import org.netbeans.modules.cnd.api.model.CsmFile;

import org.netbeans.modules.cnd.api.model.CsmProject;

import org.netbeans.modules.cnd.api.project.NativeFileItem;

import org.netbeans.modules.cnd.api.project.NativeProject;

import org.netbeans.modules.cnd.api.project.NativeProjectItemsListener;

import org.netbeans.modules.cnd.debug.CndTraceFlags;

import org.netbeans.modules.cnd.modelimpl.csm.core.FileImpl;

import org.netbeans.modules.cnd.modelimpl.csm.core.ModelImpl;

import org.netbeans.modules.cnd.modelimpl.csm.core.ProjectBase;

import org.netbeans.modules.cnd.modelimpl.debug.TraceFlags;

import org.netbeans.modules.cnd.modelutil.CsmUtilities;

import org.netbeans.modules.cnd.spi.utils.CndFileSystemProvider;

import org.netbeans.modules.cnd.utils.CndPathUtilities;

import org.netbeans.modules.cnd.utils.CndUtils;

import org.netbeans.modules.cnd.utils.FSPath;

import org.netbeans.modules.cnd.utils.MIMENames;

import org.netbeans.modules.dlight.libs.common.InvalidFileObjectSupport;

import org.openide.filesystems.FileAttributeEvent;

import org.openide.filesystems.FileChangeListener;

import org.openide.filesystems.FileEvent;

import org.openide.filesystems.FileObject;

import org.openide.filesystems.FileRenameEvent;

import org.openide.filesystems.FileUtil;

import org.openide.util.RequestProcessor;

/**

 * File events come from

 *  1) FileChangeListener 

 *  2) NativeProjectItemsListener 

 *  3) CndIndexer

 * 

 * @author Vladimir Kvashin

 */

public final class CsmEventDispatcher {

    // static (singleton) members

    private static final CsmEventDispatcher instance = new CsmEventDispatcher();

    public static CsmEventDispatcher getInstance() {

        return instance;

    }

    // instance members

    private final FileListener fileListener;

    private final ItemListener itemListener;

    private final CndIndexer.Delegate indexListener;

    private final Object listenersLock = new Object();

    private final HashMap<NativeProject, CsmEventListener> listeners = new HashMap<>();

    private final RequestProcessor RP = new RequestProcessor(getClass().getSimpleName(), 1);

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

    private final Object eventsLock = new Object();

    private LinkedList<CsmEvent> eventsQueue = new LinkedList<>();

    private CsmEventDispatcher() {

        itemListener = new ItemListener();

        fileListener = new FileListener();

        indexListener = new IndexListener();

    }

    /*package*/ void startup() {

        if (CndTraceFlags.USE_INDEXING_API) {

            CndIndexer.setDelegate(indexListener);

        } else {

            CndFileSystemProvider.addFileChangeListener(fileListener);

        }        

    }

    /*package*/ void shutdown() {

        if (CndTraceFlags.USE_INDEXING_API) {

            CndFileSystemProvider.removeFileChangeListener(fileListener);

        } else {

            CndIndexer.setDelegate(null);

        }

        // todo: clean up events ,etc

    }

    // shouldn't it be ProjectImpl ?

    public void registerProject(ProjectBase project) {        

        Object pp = project.getPlatformProject();

        if (pp instanceof NativeProject) {

            NativeProject nativeProject = (NativeProject) pp;

            synchronized (listenersLock) {

                CndUtils.assertNull(listeners.get(nativeProject), "Listener already exist for " + nativeProject); //NOI18N

                CsmEventListener listener = new CsmEventListener(project);

                listeners.put(nativeProject, listener);                

                nativeProject.addProjectItemsListener(itemListener);

            }

        } else {

            // I wouldn't say its totally incorrect, just not we expect => something goes wrong => warn

            CndUtils.assertTrue(false, "platform ptoject should be NativeProject, but is " + pp + " for " + project); //NOI18N

        }

    }

    // shouldn't it be ProjectImpl ?

    public void unregisterProject(ProjectBase project) {

        Object pp = project.getPlatformProject();

        if (pp instanceof NativeProject) {

            NativeProject nativeProject = (NativeProject) pp;

            synchronized (listenersLock) {

                nativeProject.removeProjectItemsListener(itemListener);

                listeners.remove(nativeProject);

            }

        } else {

            // I wouldn't say its totally incorrect, just not we expect => something goes wrong => warn

            CndUtils.assertTrue(false, "platform ptoject should be NativeProject, but is " + pp + " for " + project); //NOI18N

        }

    }

    public void enableListening(ProjectBase project, boolean enable) {

        Object pp = project.getPlatformProject();

        if (pp instanceof NativeProject) {

            synchronized (listenersLock) {

                CsmEventListener listener = listeners.get((NativeProject) pp);

                if (listener != null) {

                    listener.enableListening(enable);

                }

            }

        }

    }

    private void registerEvent(CsmEvent.Kind kind, FileObject fileObject) {

        synchronized (eventsLock) {

            eventsQueue.addLast(CsmEvent.createFileEvent(kind, fileObject));

        }

        task.schedule(0);

    }

    private void registerEvents(CsmEvent... events) {

        synchronized (eventsLock) {

            for (CsmEvent e : events) {

                eventsQueue.addLast(e);

            }            

        }

        task.schedule(0);

    }

    private void registerEvents(CsmEvent.Kind kind, List<NativeFileItem> items) {

        synchronized (eventsLock) {

            for (NativeFileItem item : items) {

                eventsQueue.addLast(CsmEvent.createItemEvent(kind, item));

            }            

        }

        task.schedule(0);

    }

    private class Worker implements Runnable {

        @Override

        public void run() {

            while (true) {

                LinkedList<CsmEvent> curEvents;

                synchronized (eventsLock) {

                    if (eventsQueue.isEmpty()) {

                        return;

                    }

                    curEvents = eventsQueue;

                    eventsQueue = new LinkedList<>();

                }

                for (CsmEvent event : curEvents) {

                    processEvent(event);

                }

            }            

        }        

    }

    private void processEvent(CsmEvent event) {

        final ModelImpl model = ModelSupport.instance().getModel();

        if (model == null) {

            return;

        }

        CsmEvent.trace("dispatching %s", event);

        switch (event.getKind()) {

            case ITEM_ADDED:

            case ITEM_REMOVED:

            case ITEM_PROPERTY_CHANGED:

            case ITEM_RENAMED_DELETED:

            case ITEM_RENAMED_CREATED:

            {

                NativeFileItem item = event.getNativeFileItem();

                CndUtils.assertNotNullInConsole(item, "NativeFileItem should not be null: " + event); //NOI18N

                dispatch(event, item.getNativeProject());

                break;

            }

            case FILE_DELETED:

            case FILE_CREATED:

            case FILE_RENAMED_CREATED:

            case FILE_RENAMED_DELETED:

            case FILE_CHANGED:

            case FILE_INDEXED:

            {

                FileObject fo = event.getFileObject();

                CndUtils.assertNotNullInConsole(fo, "FileObject should not be null: " + event); //NOI18N

                CsmFile[] files = model.findFiles(FSPath.toFSPath(fo), false, false);

                Set<ProjectBase> handledProjects = new HashSet<>();

                for (int i = 0; i < files.length; ++i) {

                    FileImpl file = (FileImpl) files[i];

                    ProjectBase project = file.getProjectImpl(true);

                    if (project != null) {

                        handledProjects.add(project);

                        dispatch(CsmEvent.createFileEvent(CsmEvent.Kind.FILE_CHANGED, fo), project);

                    }

                }

                if (event.getKind() == CsmEvent.Kind.FILE_CREATED || event.getKind() == CsmEvent.Kind.FILE_INDEXED) {

                    Collection<CsmProject> ownerCsmProjects = CsmUtilities.getOwnerCsmProjects(fo);

                    for (CsmProject prj : ownerCsmProjects) {

                        if (prj instanceof ProjectBase) {

                            ProjectBase project = (ProjectBase) prj;

                            if (!handledProjects.contains(project)) {

                                dispatch(event.getKind() == CsmEvent.Kind.FILE_INDEXED

                                        ? CsmEvent.createFileEvent(CsmEvent.Kind.FILE_CREATED, fo)

                                        : event, project);

                            }

                        }

                    }

                }

                break;

            }

            case ITEMS_ALL_PROPERTY_CHANGED:

                dispatchAll(event);

                break;

            case PROJECT_DELETED:

            {

                NativeProject nativeProject = event.getNativeProject();

                CndUtils.assertNotNullInConsole(nativeProject, "NativeProject should not be null: " + event); //NOI18N

                dispatch(event, nativeProject);

                break;

            }

            case FILES_IN_SOURCE_ROOT_DELETED:

            {

                FileObject fo = event.getFileObject();

                CndUtils.assertNotNullInConsole(fo, "FileObject should not be null: " + event); //NOI18N

                Collection<CsmProject> projects = CsmUtilities.getOwnerCsmProjects(fo);

                for (CsmProject project : projects) {

                    dispatch(event, project);

                }

                break;

            }

            case FOLDER_CREATED:

            case FILE_ATTRIBUTE_CHANGED:

            case NULL:

                // ignore assert?

                break;

            default:

                throw new AssertionError(event.getKind().name());

        }

        //<editor-fold defaultstate="collapsed" desc="Previous Implementation">

        /*

        NativeFileItem item = event.getNativeFileItem();

        if (item != null) {

            // this is an item event

            dispatch(event, item.getNativeProject());

        } else {

            // this is a file event

            FileObject fo = event.getFileObject();

            CndUtils.assertNotNull(fo, "Event does not contain neither FileObject nor NativeFileItem"); //NOI18N

            if (event.getKind() == CsmEvent.Kind.FILES_IN_SOURCE_ROOT_DELETED) {

                Collection<CsmProject> projects = CsmUtilities.getOwnerCsmProjects(fo);

                for (CsmProject project : projects) {

                    dispatch(event, project);

                }

            } else {

                CsmFile[] files = model.findFiles(FSPath.toFSPath(fo), false, false);

                Set<ProjectBase> handledProjects = new HashSet<>();

                for (int i = 0; i < files.length; ++i) {

                    FileImpl file = (FileImpl) files[i];

                    ProjectBase project = file.getProjectImpl(true);

                    if (project != null) {

                        handledProjects.add(project);

                        dispatch(event, project);

                    }

                }

                if (event.getKind() == CsmEvent.Kind.FILE_CREATED || event.getKind() == CsmEvent.Kind.FILE_INDEXED) {

                    Collection<CsmProject> ownerCsmProjects = CsmUtilities.getOwnerCsmProjects(fo);

                    for (CsmProject prj : ownerCsmProjects) {

                        if (prj instanceof ProjectBase) {

                            ProjectBase project = (ProjectBase) prj;

                            if (!handledProjects.contains(project)) {

                                dispatch(event.getKind() == CsmEvent.Kind.FILE_INDEXED ?

                                        CsmEvent.createFileEvent(CsmEvent.Kind.FILE_CREATED, fo) :

                                        event, project);

                            }

                        }

                    }

                }

            }

        }

        */

        //</editor-fold>

    }

    private void dispatchAll(CsmEvent event) {

        Collection<CsmEventListener> listenersCopy;

        synchronized (listenersLock) {

            listenersCopy = listeners.values();

        }

        for (CsmEventListener l : listenersCopy) {

            l.fireEvent(event);

        }

    }

    private void dispatch(CsmEvent event, CsmProject project) {

        CsmEventListener listener = getListener(project);

        if (listener != null) {

            listener.fireEvent(event);

        } else {

            CsmEvent.LOG.log(Level.FINEST, "Skipping event {0}", event);

        }

    }

    private void dispatch(CsmEvent event, NativeProject project) {

        CsmEventListener listener = getListener(project);

        if (listener != null) {

            listener.fireEvent(event);

        } else {

            CsmEvent.LOG.log(Level.FINEST, "Skipping event {0}", event);

        }

    }

    private CsmEventListener getListener(CsmProject project) {

        Object pp = project.getPlatformProject();

        if (pp instanceof NativeProject) {

            synchronized (listenersLock) {

                return listeners.get((NativeProject) pp);

            }

        } 

        return null;

    }

    private CsmEventListener getListener(NativeProject project) {

        if (project != null) {

            synchronized (listenersLock) {

                return listeners.get(project);

            }

        }

        return null;

    }

    private boolean isCOrCpp(FileObject fo) {

        String mime = fo.getMIMEType();

        if (mime == null) {

            mime = FileUtil.getMIMEType(fo);

            if (TraceFlags.TRACE_EXTERNAL_CHANGES) {

                CsmEvent.LOG.log(Level.INFO, "External updates: MIME resolved: {0}", mime);

            }

        }

        return MIMENames.isFortranOrHeaderOrCppOrC(mime);

    }

    private boolean isCOrCppOrInvalid(FileObject fo) {

        return !fo.isValid() || isCOrCpp(fo);

    }

    private class ItemListener implements NativeProjectItemsListener {

        @Override

        public void filesAdded(List<NativeFileItem> items) {

            registerEvents(CsmEvent.Kind.ITEM_ADDED, items);

        }

        @Override

        public void filesRemoved(List<NativeFileItem> items) {

            registerEvents(CsmEvent.Kind.ITEM_REMOVED, items);

        }

        @Override

        public void filesPropertiesChanged(List<NativeFileItem> items) {

            registerEvents(CsmEvent.Kind.ITEM_PROPERTY_CHANGED, items);

        }

        @Override

        public void filesPropertiesChanged() {

            registerEvents(CsmEvent.createEmptyEvent(CsmEvent.Kind.ITEMS_ALL_PROPERTY_CHANGED));

        }

        @Override

        public void fileRenamed(String oldPath, NativeFileItem newFileIetm) {

            registerEvents(

                    CsmEvent.createItemEvent(CsmEvent.Kind.ITEM_RENAMED_DELETED, newFileIetm, oldPath),

                    CsmEvent.createItemEvent(CsmEvent.Kind.ITEM_RENAMED_CREATED, newFileIetm, oldPath));

        }

        @Override

        public void projectDeleted(NativeProject nativeProject) {

            registerEvents(CsmEvent.createProjectEvent(CsmEvent.Kind.PROJECT_DELETED, nativeProject));

        }

        @Override

        public void fileOperationsStarted(NativeProject nativeProject) {

            CsmEventListener listener = getListener(nativeProject);

            if (listener != null) {

                listener.suspend();

            }

        }

        @Override

        public void fileOperationsFinished(NativeProject nativeProject) {

            CsmEventListener listener = getListener(nativeProject);

            if (listener != null) {

                listener.resume();

            }

        }        

    }

    private class FileListener implements FileChangeListener {

        @Override

        public void fileFolderCreated(FileEvent fe) {

            // ignore

        }

        @Override

        public void fileDataCreated(FileEvent fe) {

            if (isCOrCppOrInvalid(fe.getFile())) {

                registerEvent(CsmEvent.Kind.FILE_CREATED, fe.getFile());

            }

        }

        @Override

        public void fileChanged(FileEvent fe) {

            if (isCOrCppOrInvalid(fe.getFile())) {

                registerEvent(CsmEvent.Kind.FILE_CHANGED, fe.getFile());

            }

        }

        @Override

        public void fileDeleted(FileEvent fe) {

            if (isCOrCppOrInvalid(fe.getFile())) {

                registerEvent(CsmEvent.Kind.FILE_DELETED, fe.getFile());

            }

        }

        @Override

        public void fileRenamed(FileRenameEvent fe) {

            FileObject fo = fe.getFile();

            if (isCOrCppOrInvalid(fo)) {

                FSPath newPath = FSPath.toFSPath(fo);

                String strPrevExt = (fe.getExt() == null || fe.getExt().isEmpty()) ? "" : "." + fe.getExt(); // NOI18N

                String strPrevPath = CndPathUtilities.getDirName(newPath.getPath()) + '/' + fe.getName() + strPrevExt; // NOI18N

                FSPath prevPath = new FSPath(newPath.getFileSystem(), strPrevPath);        

                FileObject removedFO = InvalidFileObjectSupport.getInvalidFileObject(prevPath.getFileSystem(), prevPath.getPath());

                registerEvents(

                        CsmEvent.createFileEvent(CsmEvent.Kind.FILE_RENAMED_DELETED, removedFO),

                        CsmEvent.createFileEvent(CsmEvent.Kind.FILE_RENAMED_CREATED, fo));

            }

        }

        @Override

        public void fileAttributeChanged(FileAttributeEvent fe) {

            // nothing

        }        

    }

    private class IndexListener implements CndIndexer.Delegate {

        @Override

        public void index(FileObject file) {

            registerEvent(CsmEvent.Kind.FILE_INDEXED, file);

        }

        @Override

        public void removed(FileObject root) {

            registerEvent(CsmEvent.Kind.FILES_IN_SOURCE_ROOT_DELETED, root); 

        }

    }    

}

/*

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

 *

 * Copyright 2014 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 2014 Sun Microsystems, Inc.

 */

package org.netbeans.modules.cnd.modelimpl.platform;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import java.util.logging.Level;

import org.netbeans.modules.cnd.api.model.CsmFile;

import org.netbeans.modules.cnd.api.project.NativeFileItem;

import org.netbeans.modules.cnd.api.project.NativeProject;

import org.netbeans.modules.cnd.modelimpl.csm.core.FileImpl;

import org.netbeans.modules.cnd.modelimpl.csm.core.ProjectBase;

import org.netbeans.modules.cnd.modelimpl.debug.TraceFlags;

import org.netbeans.modules.cnd.modelimpl.repository.RepositoryUtils;

import org.netbeans.modules.cnd.utils.CndUtils;

import org.openide.filesystems.FileObject;

import org.openide.filesystems.FileStateInvalidException;

import org.openide.util.Exceptions;

import org.openide.util.RequestProcessor;

/**

 * @author Vladimir Voskresensky

 * @author Vladimir Kvashin

 */

/*package*/ final class CsmEventListener {

    private final ProjectBase project;

    private final NativeProject nativeProject;

    private volatile boolean enabledEventsHandling = true;

    //private static final RequestProcessor RP = new RequestProcessor(CsmEventListener.class.getSimpleName());

    private final RequestProcessor.Task task;

    private final Object eventsLock = new Object();

    private int suspendCount = 0;

    private HashMap<String, CsmEvent> events = new LinkedHashMap<>();

    private static final CsmEvent NULL = CsmEvent.createEmptyEvent(CsmEvent.Kind.NULL);

    public CsmEventListener(ProjectBase project) {

        assert project.getPlatformProject() instanceof NativeProject;

        this.project = project;

        this.nativeProject = (NativeProject) project.getPlatformProject();

        this.task = ModelSupport.instance().getModel().createModelTask(new Worker(), getClass().getSimpleName());

    }

    public ProjectBase getProject() {

        return project;

    }

    public NativeProject getNativeProject() {

        return nativeProject;

    }

    public void enableListening(boolean enable) {

        if (TraceFlags.TIMING) {

            CsmEvent.LOG.log(Level.INFO, "\n%{0} ProjectListeners {1}...", new Object[] {enable ? "enable" : "disable",

                    nativeProject.getProjectDisplayName()});

        }

        enabledEventsHandling = enable;

    }

    void fireEvent(CsmEvent event) {

        switch (event.getKind()) {

            case FILE_INDEXED:

            case FOLDER_CREATED:

            case FILE_ATTRIBUTE_CHANGED:

            case NULL:

                return;

        }

        CsmEvent.trace("%s dispatched to %s", event, project);

        checkEvent(event);

        String path = getPath(event);

        synchronized (eventsLock) {

            CsmEvent prev = events.get(path);

            events.put(path, convert(prev, event));

        }

        task.schedule(0); // fe.runWhenDeliveryOver(taskScheduler); ???

    }

    String getPath(CsmEvent event) {

        FileObject fo = event.getFileObject();

        if (fo != null) {

            return fo.getPath();

        }

        NativeFileItem item = event.getNativeFileItem();

        if (item != null) {

            return item.getAbsolutePath();

        }

        NativeProject np = event.getNativeProject();

        if (np != null) {

            return np.getProjectRoot();

        }

        return "/"; //NOI18N

    }

    void checkEvent(CsmEvent event) {

        FileObject fo = event.getFileObject();

        if (fo != null) {

            try {

                assert fo.getFileSystem().equals(nativeProject.getFileSystem());

            } catch (FileStateInvalidException ex) {

                Exceptions.printStackTrace(ex);

            }

        }

        NativeProject np = event.getNativeProject();

        if (np == null) {

            NativeFileItem item = event.getNativeFileItem();

            if (item != null) {

                np = item.getNativeProject();

            }

        }

        if (np != null) {

            assert np.equals(nativeProject);

        }

    }

    void resume() {

        boolean schedule;

        synchronized (eventsLock) {

            CndUtils.assertTrue(suspendCount > 0, "resume without suspend " + suspendCount);

            suspendCount--;

            if (suspendCount < 0) {

                suspendCount = 0;

            }

            schedule = (suspendCount == 0);

        }

        if (schedule) {

            task.schedule(0);

        }

    }

    void suspend() {

        synchronized (eventsLock) {

            CndUtils.assertTrue(suspendCount >= 0, "suspend with " + suspendCount);

            suspendCount++;

        }

    }

    /*package*/void flush() {

        task.schedule(0);

        task.waitFinished();

    }

    //<editor-fold defaultstate="collapsed" desc="old impl">

    /***

   private void processEvents(Collection<CsmEvent> events) {

        if (!enabledEventsHandling) {

            CsmEvent.trace("events processing disabled, skipping %d events", events.size());

            return;

        }

        CsmEvent.trace("processing %d events", events.size());

        boolean checkForRemoved = false;

        for (CsmEvent event : events) {

            CsmEvent.trace("processing %s", event);

            switch (event.getKind()) {

                case FILE_DELETED:

                case ITEM_REMOVED:

                case FILE_RENAMED_DELETED:

                case ITEM_RENAMED_DELETED:

                    checkForRemoved = true;

                    break;

                case FILE_CREATED:

                case FILE_RENAMED_CREATED:

                    project.onFileObjectExternalCreate(event.getFileObject());

                    break;

                case ITEM_ADDED:

                    project.onFileItemsAdded(Arrays.asList(event.getNativeFileItem()));

                    break;

                case FOLDER_CREATED:

                    // nothing

                    break;

                case FILE_CHANGED:

                    project.findFile(event.getPath(), false, false);

                    break;

                case FILE_ATTRIBUTE_CHANGED:

                    // nothing

                    break;

                case ITEM_PROPERTY_CHANGED:

                    project.onFileItemsPropertyChanged(Arrays.asList(event.getNativeFileItem()), false);

                    break;

                case ITEMS_ALL_PROPERTY_CHANGED:

                    List<NativeFileItem> items = new ArrayList<>();

                    for (NativeFileItem item : nativeProject.getAllFiles()) {

                        if (!item.isExcluded()) {

                            switch (item.getLanguage()) {

                                case C:

                                case CPP:

                                case FORTRAN:

                                    items.add(item);

                                    break;

                                default:

                                    break;

                            }

                        }

                        project.onFileItemsPropertyChanged(items, true);

                    }

                    break;

                case ITEM_RENAMED_CREATED:

                    project.onFileItemRenamed(event.getOldPath(), event.getNativeFileItem());

                    break;

                case PROJECT_DELETED:

                    RepositoryUtils.onProjectDeleted(nativeProject);

                    break;

                case FILES_IN_SOURCE_ROOT_DELETED:

                    checkForRemoved = true;

                    break;

                case FILE_INDEXED:

                    CndUtils.assertTrue(false, "FILE_INDEXED event should never reach end listener"); //NOI18N

                    break;

                case NULL:

                    // nothing

                    break;

                default:

                    throw new AssertionError(event.getKind().name());

            }

            if (checkForRemoved) {

                project.checkForRemoved();

            }

        }

    }

     */

    //</editor-fold>

    private void processEvents(Collection<CsmEvent> events) {

        if (!enabledEventsHandling) {

            CsmEvent.trace("events processing disabled, skipping %d events", events.size());

            return;

        }

        CsmEvent.trace("processing %d events", events.size());

        boolean projectDeleted = false;

        boolean checkForRemoved = false;

        boolean projectRemoved = false;

        boolean allPropertiesChanged = false;

        List<FileObject> createdFiles = new ArrayList<>();

        List<NativeFileItem> addedItems = new ArrayList<>();

        List<NativeFileItem> changedItemProps = new ArrayList<>();

        List<String> changedFiles = new ArrayList<>();

        List<CsmEvent> renamedItems = new ArrayList<>();

        for (CsmEvent event : events) {

            CsmEvent.trace("processing %s", event);

            switch (event.getKind()) {

                case FILE_DELETED:

                case ITEM_REMOVED:

                case FILE_RENAMED_DELETED:

                case ITEM_RENAMED_DELETED:

                    checkForRemoved = true;

                    break;

                case FILE_CREATED:

                case FILE_RENAMED_CREATED:

                    createdFiles.add(event.getFileObject());

                    break;

                case ITEM_ADDED:

                    addedItems.add(event.getNativeFileItem());

                    break;

                case FOLDER_CREATED:

                    // nothing

                    break;

                case FILE_CHANGED:

                    changedFiles.add(event.getPath());

                    break;

                case FILE_ATTRIBUTE_CHANGED:

                    // nothing

                    break;

                case ITEM_PROPERTY_CHANGED:

                    changedItemProps.add(event.getNativeFileItem());

                    break;

                case ITEMS_ALL_PROPERTY_CHANGED:

                    allPropertiesChanged = true;

                    break;

                case ITEM_RENAMED_CREATED:

                    renamedItems.add(event);

                    break;

                case PROJECT_DELETED:

                    projectDeleted = true;

                    break;

                case FILES_IN_SOURCE_ROOT_DELETED:

                    checkForRemoved = true;

                    break;

                case FILE_INDEXED:

                    CndUtils.assertTrue(false, "FILE_INDEXED event should never reach end listener"); //NOI18N

                    break;

                case NULL:

                    // nothing

                    break;

                default:

                    throw new AssertionError(event.getKind().name());

            }

            if (projectDeleted) {

                RepositoryUtils.onProjectDeleted(nativeProject);

                return;

            }

            if (!renamedItems.isEmpty()) {

                for (CsmEvent csmEvent : renamedItems) {

                    project.onFileItemRenamed(event.getOldPath(), event.getNativeFileItem());

                }

            }

            if (allPropertiesChanged) {

                List<NativeFileItem> items = new ArrayList<>();

                for (NativeFileItem item : nativeProject.getAllFiles()) {

                    if (!item.isExcluded()) {

                        switch (item.getLanguage()) {

                            case C:

                            case CPP:

                            case FORTRAN:

                                items.add(item);

                                break;

                            default:

                                break;

                        }

                    }

                    project.onFileItemsPropertyChanged(items, true);

                }

                changedItemProps.clear();

            }

            if(!changedFiles.isEmpty()) {

                for (String path : changedFiles) {

                    CsmFile csmFile = project.findFile(path, false, false);

                    if (csmFile != null) {

                        project.onFileImplExternalChange((FileImpl) csmFile);

                    }

                }

            }

            if (!changedItemProps.isEmpty()) {

                project.onFileItemsPropertyChanged(changedItemProps, false);

            }

            if (!createdFiles.isEmpty()) {

                project.onFileObjectExternalCreate(createdFiles);

            }

            if (!addedItems.isEmpty()) {

                project.onFileItemsAdded(addedItems);

            }

            if (checkForRemoved) {

                project.checkForRemoved();

            }

        }

    }

// the table below is incomplete: to me, it's easier to just fill the switch/case and add some comments there

// but I left it just in case I decide to fill it later :)

/*-------------------------------------------------------------------------------------------------------------------------------------------

                                     (prevKind)

(curKind) | F/DEL  | F/CR    | F/REN_CR | F/REN_DL |   F/CH   | I/ADD  | I/RM   | I/PROP | I/ALPROP | I/REN_CR | I/REN_DL | P/DEL  | F/RT_DEL |

----------------------------------------------------------------------------------------------------------------------------------------------

F/DEL     | F/DEL  | null    | null     | assert   | F/DEL    | null   | F/DEL  | F/DEL  | assert   | null     | assert   | P/DEL  | assert   |

I/RM      | I/RM   | null    | null     | assert   | I/RM     | null   | I/RM   | I/RM   | assert   | null     | assert   | P/DEL  | assert   |

F/RT_DEL  | assert | assert  | assert   | assert   | assert   | assert | assert | assert | assert   | assert   | assert   | P/DEL  | F/RT_DEL |

F/CR      | F/CH   | F/CR    | assert   | F/CH     | F/CH     | I/ADD  | ?      | ?      | assert   |          |          | P/DEL  |          |

I/ADD     | I/ADD  | I/ADD?  | I/ADD    | I/ADD    | I/ADD?   | I/ADD  | F/CH   |        | assert   |          |          | P/DEL  | assert   |

F/REN_CR  | F/CH   | assert  | assert   | F/CH     | assert   |        |        |        | assert   |          |          | P/DEL  |          |

I/REN_CR  |        |         |          |          |          |        |        |        | assert   |          |          | P/DEL  |          |

F/REN_DL  | assert | null (?)| null (?) | assert   | F/REN_DL |        |        |        | assert   |          |          | P/DEL  |          |

I/REN_DL  |        |         |          |          |          |        |        |        | assert   |          |          | P/DEL  |          |

F/CH      | assert | F/CR    | F/REN_CR | assert   | F/CH     |        |        |        | assert   |          |          | P/DEL  |          |

I/PROP    | null   | F/CR    | null     | assert   | I/PROP   | I/ADD  | I/RM   | I/PROP | assert   | I/REN_CR | assert   | P/DEL  | assert   |

I/ALPROP  | assert | assert  | assert   | assert   | assert   | assert | assert | assert | assert   | assert   | assert   | P/DEL  |          |

P/DEL     | P/DEL  | P/DEL   | P/DEL    | P/DEL    | P/DEL    | P/DEL  | P/DEL  | P/DEL  | P/DEL    | P/DEL    | P/DEL    | P/DEL  | P/DEL    |

----------------------------------------------------------------------------------------------------------------------------------------------*/

    private static CsmEvent convert(CsmEvent prev, CsmEvent cur) {

        if (prev == null || prev.getKind() == CsmEvent.Kind.NULL) {

            return cur;

        }

        if (prev.getKind() == CsmEvent.Kind.PROJECT_DELETED) {

            return prev;

        } else if (cur.getKind() == CsmEvent.Kind.PROJECT_DELETED) {

            return cur;

        }

        switch (cur.getKind()) {

            case FILE_DELETED: //<editor-fold defaultstate="collapsed" desc="...">

                switch (prev.getKind()) {

                    case FILE_DELETED:                  return cur;

                    case ITEM_REMOVED:                  return cur; // doesn't matter, processing is the same

                    case FILE_CREATED:                  return doNull();

                    case ITEM_ADDED:                    return doNull();

                    case FILE_RENAMED_CREATED:          return doNull();

                    case ITEM_RENAMED_CREATED:          return doNull();

                    case FILE_RENAMED_DELETED:          return doAssert(prev, cur);

                    case ITEM_RENAMED_DELETED:          return doAssert(prev, cur);

                    case FILE_CHANGED:                  return cur;

                    case ITEM_PROPERTY_CHANGED:         return cur;

                    case ITEMS_ALL_PROPERTY_CHANGED:    return doAssert(prev, cur, prev); // does that mean that the project is deleted?

                    case FILES_IN_SOURCE_ROOT_DELETED:  return cur; // doesn't matter, processing is thesame

                    default:    throw new IllegalArgumentException("unexpected " + prev.getKind()); // NOI18N

                }   //</editor-fold>   

            case FILE_CREATED://<editor-fold defaultstate="collapsed" desc="...">

                switch (prev.getKind()) {

                    case FILE_DELETED:                  return doChanged(cur);

                    case ITEM_REMOVED:                  return doChanged(cur);

                    case FILE_CREATED:                  return prev;

                    case ITEM_ADDED:                    return prev; // item events are stronger

                    case FILE_RENAMED_CREATED:          return doAssert(prev, cur);

                    case ITEM_RENAMED_CREATED:          return prev; // ITEM_RENAMED_CREATED will finally cause checkForRemove and nativeItemAdded

                    case FILE_RENAMED_DELETED:          return doChanged(cur);

                    case ITEM_RENAMED_DELETED:          return doChanged(cur);

                    case FILE_CHANGED:                  return prev;

                    case ITEM_PROPERTY_CHANGED:         return prev; // ?

                    case ITEMS_ALL_PROPERTY_CHANGED:    return doAssert(prev, cur, prev); // prev event path is a project path!

                    case FILES_IN_SOURCE_ROOT_DELETED:  return doAssert(prev, cur); // prev event path is a project path!

                    default:    throw new AssertionError(prev.getKind());

                }//</editor-fold>

            case FILE_RENAMED_CREATED://<editor-fold defaultstate="collapsed" desc="...">

                switch (prev.getKind()) {

                    case FILE_DELETED:                  return doChanged(cur);

                    case ITEM_REMOVED:                  return doChanged(cur);

                    case FILE_CREATED:                  return doAssert(prev, cur);

                    case ITEM_ADDED:                    return prev;

                    case FILE_RENAMED_CREATED:          return doAssert(prev, cur);

                    case ITEM_RENAMED_CREATED:          return doAssert(prev, cur);

                    case FILE_RENAMED_DELETED:          return doChanged(cur);

                    case ITEM_RENAMED_DELETED:          return doChanged(cur);

                    case FILE_CHANGED:                  return doAssert(prev, cur);

                    case ITEM_PROPERTY_CHANGED:         return cur; //?

                    case ITEMS_ALL_PROPERTY_CHANGED:    return doAssert(prev, cur, prev); // prev event path is a project path!

                    case FILES_IN_SOURCE_ROOT_DELETED:  return doAssert(prev, cur, prev); // prev event path is a project path!

                    default:    throw new AssertionError(prev.getKind());

                }//</editor-fold>

            case FILE_RENAMED_DELETED://<editor-fold defaultstate="collapsed" desc="...">

                switch (prev.getKind()) {

                    case FILE_DELETED:                  return doAssert(prev, cur);

                    case ITEM_REMOVED:                  return doNullOnRename(prev, cur); //?

                    case FILE_CREATED:                  return doNullOnRename(prev, cur);

                    case ITEM_ADDED:                    return doNullOnRename(prev, cur);

                    case FILE_RENAMED_CREATED:          return doNullOnRename(prev, cur);

                    case ITEM_RENAMED_CREATED:          return doNullOnRename(prev, cur);

                    case FILE_RENAMED_DELETED:          return doAssert(prev, cur);

                    case ITEM_RENAMED_DELETED:          return doAssert(prev, cur);

                    case FILE_CHANGED:                  return cur;

                    case ITEM_PROPERTY_CHANGED:         return cur;

                    case ITEMS_ALL_PROPERTY_CHANGED:    return doAssert(prev, cur, prev); // prev event path is a project path!

                    case FILES_IN_SOURCE_ROOT_DELETED:  return doAssert(prev, cur, prev); // prev event path is a project path!

                    default:    throw new AssertionError(prev.getKind());

                }//</editor-fold>

            case FILE_CHANGED://<editor-fold defaultstate="collapsed" desc="...">

                switch (prev.getKind()) {

                    case FILE_DELETED:                  return doAssert(prev, cur);

                    case ITEM_REMOVED:                  return cur;

                    case FILE_CREATED:                  return prev;

                    case FILE_RENAMED_CREATED:          return prev;

                    case FILE_RENAMED_DELETED:          return doAssert(prev, cur);

                    case FILE_CHANGED:                  return cur;

                    case ITEM_ADDED:                    return cur;

                    case ITEM_PROPERTY_CHANGED:         return prev;

                    case ITEM_RENAMED_CREATED:          return prev;

                    case ITEM_RENAMED_DELETED:          return doAssert(prev, cur);

                    case ITEMS_ALL_PROPERTY_CHANGED:    return doAssert(prev, cur, prev); // prev event path is a project path!

                    case FILES_IN_SOURCE_ROOT_DELETED:  return doAssert(prev, cur, prev); // prev event path is a project path!

                    default:    throw new IllegalArgumentException("unexpected " + prev.getKind()); // NOI18N

                }//</editor-fold>

            case ITEM_ADDED://<editor-fold defaultstate="collapsed" desc="...">

                switch (prev.getKind()) {

                    case FILE_DELETED:                  return cur;

                    case ITEM_REMOVED:                  return doChanged(CsmEvent.Kind.ITEM_PROPERTY_CHANGED,  cur);

                    case FILE_CREATED:                  return cur;

                    case ITEM_ADDED:                    return cur;

                    case FILE_RENAMED_CREATED:          return cur;

                    case ITEM_RENAMED_CREATED:          return cur; //?

                    case FILE_RENAMED_DELETED:          return cur; //?

                    case ITEM_RENAMED_DELETED:          return cur; //?

                    case FILE_CHANGED:                  return cur;

                    case ITEM_PROPERTY_CHANGED:         return cur; //?

                    case ITEMS_ALL_PROPERTY_CHANGED:    return doAssert(prev, cur, prev); // prev event path is a project path!

                    case FILES_IN_SOURCE_ROOT_DELETED:  return doAssert(prev, cur, prev); // prev event path is a project path!

                    default:    throw new IllegalArgumentException("unexpected " + prev.getKind()); // NOI18N

                }//</editor-fold>

            case ITEM_REMOVED://<editor-fold defaultstate="collapsed" desc="...">

                switch (prev.getKind()) {

                    case FILE_DELETED:                  return cur; // procssing is the same

                    case ITEM_REMOVED:                  return cur;

                    case FILE_CREATED:                  return cur; //?

                    case ITEM_ADDED:                    return doNull();

                    case FILE_RENAMED_CREATED:          return doNull();

                    case ITEM_RENAMED_CREATED:          return doNull();

                    case FILE_RENAMED_DELETED:          return cur; // processing is the same

                    case ITEM_RENAMED_DELETED:          return cur; // processing is the same

                    case FILE_CHANGED:                  return cur;

                    case ITEM_PROPERTY_CHANGED:         return cur; //???

                    case ITEMS_ALL_PROPERTY_CHANGED:    return doAssert(prev, cur, prev); // prev event path is a project path!

                    case FILES_IN_SOURCE_ROOT_DELETED:  return doAssert(prev, cur, prev); // prev event path is a project path!

                    default:    throw new IllegalArgumentException("unexpected " + prev.getKind()); // NOI18N

                }//</editor-fold>

            case ITEM_PROPERTY_CHANGED://<editor-fold defaultstate="collapsed" desc="...">

                switch (prev.getKind()) {

                    case FILE_DELETED:                  return doNull();

                    case ITEM_REMOVED:                  return doNull();

                    case FILE_CREATED:                  return cur;

                    case ITEM_ADDED:                    return prev;

                    case FILE_RENAMED_CREATED:          return prev;

                    case ITEM_RENAMED_CREATED:          return prev;

                    case FILE_RENAMED_DELETED:          return doNull();

                    case ITEM_RENAMED_DELETED:          return doNull();

                    case FILE_CHANGED:                  return cur; // item event is stronger

                    case ITEM_PROPERTY_CHANGED:         return cur;

                    case ITEMS_ALL_PROPERTY_CHANGED:    return doAssert(prev, cur, prev); // prev event path is a project path!

                    case FILES_IN_SOURCE_ROOT_DELETED:  return doAssert(prev, cur, prev); // prev event path is a project path!

                    default:    throw new IllegalArgumentException("unexpected " + prev.getKind()); // NOI18N

                }//</editor-fold>

            case ITEMS_ALL_PROPERTY_CHANGED://<editor-fold defaultstate="collapsed" desc="...">

                switch (prev.getKind()) {

                    case FILE_DELETED:                  // fallthrough

                    case ITEM_REMOVED:                  // fallthrough

                    case FILE_CREATED:                  // fallthrough

                    case FILE_RENAMED_CREATED:          // fallthrough

                    case FILE_RENAMED_DELETED:          // fallthrough

                    case FILE_CHANGED:                  // fallthrough

                    case ITEM_ADDED:                    // fallthrough

                    case ITEM_PROPERTY_CHANGED:         // fallthrough

                    case ITEM_RENAMED_CREATED:          // fallthrough

                    case ITEM_RENAMED_DELETED:          return doAssert(prev, cur); // cur path is project, prev path is file

                    case ITEMS_ALL_PROPERTY_CHANGED:    return cur;

                    case FILES_IN_SOURCE_ROOT_DELETED:  return cur; // should we create a synthetic event for this?

                    default:    throw new IllegalArgumentException("unexpected " + prev.getKind()); // NOI18N

                }//</editor-fold>

            case ITEM_RENAMED_DELETED://<editor-fold defaultstate="collapsed" desc="...">

                switch (prev.getKind()) {

                    case FILE_DELETED:                  return doNull();

                    case ITEM_REMOVED:                  return doNull();

                    case FILE_CREATED:                  return cur;

                    case ITEM_ADDED:                    return doNull();

                    case FILE_RENAMED_CREATED:          return doNull();

                    case ITEM_RENAMED_CREATED:          return doNull();

                    case FILE_RENAMED_DELETED:          return cur;

                    case ITEM_RENAMED_DELETED:          return cur;

                    case FILE_CHANGED:                  return cur;

                    case ITEM_PROPERTY_CHANGED:         return cur; //???

                    case ITEMS_ALL_PROPERTY_CHANGED:    return doAssert(prev, cur, prev); // prev event path is a project path!

                    case FILES_IN_SOURCE_ROOT_DELETED:  return doAssert(prev, cur, prev); // prev event path is a project path!

                    default:    throw new IllegalArgumentException("unexpected " + prev.getKind()); // NOI18N

                }//</editor-fold>

            case ITEM_RENAMED_CREATED://<editor-fold defaultstate="collapsed" desc="...">

                switch (prev.getKind()) {

                    case FILE_DELETED:                  return doChanged(cur);

                    case ITEM_REMOVED:                  return doChanged(cur);

                    case FILE_CREATED:                  return cur;

                    case ITEM_ADDED:                    return prev;// or cur... doesn/t really matter

                    case FILE_RENAMED_CREATED:          return cur;

                    case ITEM_RENAMED_CREATED:          return cur;

                    case FILE_RENAMED_DELETED:          return doChanged(cur);

                    case ITEM_RENAMED_DELETED:          return doChanged(cur);

                    case FILE_CHANGED:                  return cur;

                    case ITEM_PROPERTY_CHANGED:         return cur;

                    case ITEMS_ALL_PROPERTY_CHANGED:    return doAssert(prev, cur, prev); // prev event path is a project path!

                    case FILES_IN_SOURCE_ROOT_DELETED:  return doAssert(prev, cur, prev); // prev event path is a project path!

                    default:    throw new IllegalArgumentException("unexpected " + prev.getKind()); // NOI18N

                }//</editor-fold>

            case FILES_IN_SOURCE_ROOT_DELETED://<editor-fold defaultstate="collapsed" desc="...">

                switch (prev.getKind()) {

                    case FILE_DELETED:                  // fallthrough

                    case ITEM_REMOVED:                  // fallthrough

                    case FILE_CREATED:                  // fallthrough

                    case ITEM_ADDED:                    // fallthrough

                    case FILE_RENAMED_CREATED:          // fallthrough

                    case ITEM_RENAMED_CREATED:          // fallthrough

                    case FILE_RENAMED_DELETED:          // fallthrough

                    case ITEM_RENAMED_DELETED:          // fallthrough

                    case FILE_CHANGED:                  // fallthrough

                    case ITEM_PROPERTY_CHANGED:         return doAssert(prev, cur); // cur path is project, prev path is item ?!

                    case ITEMS_ALL_PROPERTY_CHANGED:    return prev; // ??? should we create a combined event?

                    case FILES_IN_SOURCE_ROOT_DELETED:  return cur;

                    default:    throw new IllegalArgumentException("unexpected " + prev.getKind()); // NOI18N

                }//</editor-fold>

            default:    throw new AssertionError(prev.getKind());

        }

    }

    private static CsmEvent doAssert(CsmEvent prev, CsmEvent cur) {

        return doAssert(prev, cur, cur);

    }

    private static CsmEvent doAssert(CsmEvent prev, CsmEvent cur, CsmEvent correct ){

        CndUtils.assertTrueInConsole(false, "invalid states " + prev + " " + cur);

        return correct;

    }

    private static CsmEvent doChanged(CsmEvent.Kind kind, CsmEvent cur) {

        return CsmEvent.create(kind, cur);

    }

    private static CsmEvent doChanged(CsmEvent cur) {

        return CsmEvent.create(CsmEvent.Kind.FILE_CHANGED, cur);

    }

    private static CsmEvent doNull() {

        return NULL;

    }

    private static CsmEvent doNullOnRename(CsmEvent prev, CsmEvent cur) {

        return NULL;

    }

    private final class Worker implements Runnable {

        @Override

        public void run() {

            HashMap<String, CsmEvent> curEvents;

            synchronized (eventsLock) {

                if (events.isEmpty()) {

                    return;

                }

                curEvents = events;

                if (suspendCount == 0) {

                    events = new LinkedHashMap<>();

                } else {

                    HashMap<String, CsmEvent> suspendedRemoves = new LinkedHashMap<>();

                    for (Iterator<Map.Entry<String, CsmEvent>> it = curEvents.entrySet().iterator(); it.hasNext();) {

                        Map.Entry<String, CsmEvent> entry = it.next();

                        CsmEvent value = entry.getValue();

                        // hold on with delete events and delete/create pair from rename event

                        if (value.getKind() == CsmEvent.Kind.FILE_DELETED || value.getKind() == CsmEvent.Kind.ITEM_REMOVED) {

                            //(value.getKind() == CsmEvent.Kind.FILE_CREATED && value.event instanceof FileRenameEvent)) {

                            suspendedRemoves.put(entry.getKey(), value);

                            it.remove();

                        }

                    }