import java.util.concurrent.CancellationException;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.FutureTask;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.TimeoutException;

import org.openide.util.Exceptions;

import org.openide.util.RequestProcessor;

        WorkerTask task;

        synchronized (activeTaskLock) {

            task = activeTask;

            if (task != null && !sameContext(task.context, context)) {

                task.cancel();

                task = null;

                activeTask = null;

            }

    public static CsmSelect.NameAcceptor createNameAcceptor(final String text, final SearchType searchType) {

        final NameMatcher nameMatcher = NameMatcherFactory.createNameMatcher(text, searchType);

        return new NameAcceptorImpl(nameMatcher);

    }

        if (context2 == null) {

            return false;

        }

        if (!context1.getSearchType().equals(context2.getSearchType())) {

            return false;

        }

        if (!context1.getText().equals(context2.getText())) {

            return false;

        }

        return true;

    private static class WorkerTask extends FutureTask<Void> {

        private final Set<CppSymbolDescriptor> result;

        private final Context context;

        private final AtomicBoolean cancelled;

        public WorkerTask(Context context, CsmSelect.NameAcceptor nameAcceptor) {

            this(context, nameAcceptor, new HashSet<CppSymbolDescriptor>(), new AtomicBoolean(false));

        }

        private WorkerTask(Context context, CsmSelect.NameAcceptor nameAcceptor, Set<CppSymbolDescriptor> result, AtomicBoolean cancelled) {

            super(new Worker(context, nameAcceptor, result, cancelled), null);

            this.context = context;

            this.result = result;

            this.cancelled = cancelled;

        }

        private List<CppSymbolDescriptor> getResult() {

            synchronized (resultLock) {

                return new ArrayList<CppSymbolDescriptor>(result);

            }

        }

        private boolean hasResult() {

            synchronized (resultLock) {

                return !result.isEmpty();

            }

        }

        public void cancel() {

            cancelled.set(true);

        }

    }

    private static class Worker implements Runnable {

        private final Context context;

        private final Set<CppSymbolDescriptor> result;

        private long startTime;

        private final AtomicBoolean cancelled;

        private final CsmSelect.NameAcceptor nameAcceptor;

        private Worker(Context context, CsmSelect.NameAcceptor nameAcceptor, Set<CppSymbolDescriptor> result, AtomicBoolean cancelled) {

            if (TRACE) {

                LOG.log(Level.INFO, "New Worker for searching \"{0}\", {1} in {2} created.", // NOI18N

                        new Object[]{context.getText(), context.getSearchType().name(), context.getProject()});

            }

            this.context = context;

            this.result = result;

            this.cancelled = cancelled;

            this.nameAcceptor = nameAcceptor;

        }

        @Override

        public void run() {

            if (TRACE) {

                startTime = System.currentTimeMillis();

            }

            try {

                CsmCacheManager.enter();

                try {

                    collect(context);

                } finally {

                    CsmCacheManager.leave();

                }

                if (TRACE) {

                    LOG.log(Level.INFO, "Worker for searching \"{0}\", {1} in {2} cancelled [after {3} ms.].", // NOI18N

                            new Object[]{context.getText(), context.getSearchType().name(), context.getProject(), (System.currentTimeMillis() - startTime)});

                }

            } catch (CancellationException ex) {

                if (TRACE) {

                    LOG.log(Level.INFO, "Worker for searching \"{0}\", {1} in {2} cancelled [after {3} ms.].", // NOI18N

                            new Object[]{context.getText(), context.getSearchType().name(), context.getProject(), (System.currentTimeMillis() - startTime)});

                }

            } finally {

                if (TRACE) {

                    LOG.log(Level.INFO, "Worker for searching \"{0}\", {1} in {2} done [in {3} ms.].", // NOI18N

                            new Object[]{context.getText(), context.getSearchType().name(), context.getProject(), (System.currentTimeMillis() - startTime)});

                }

            }

        }

        private void collect(Context context) {

            if (context.getProject() == null) {

                Set<CsmProject> libs = new HashSet<CsmProject>();

                for (CsmProject csmProject : CsmModelAccessor.getModel().projects()) {

                    checkCancelled();

                    collectSymbols(csmProject);

                    collectLibs(csmProject, libs);

                }

                for (CsmProject csmProject : libs) {

                    checkCancelled();

                    collectSymbols(csmProject);

                }

            } else {

                NativeProject nativeProject = context.getProject().getLookup().lookup(NativeProject.class);

                if (nativeProject != null) {

                    CsmProject csmProject = CsmModelAccessor.getModel().getProject(nativeProject);

                    if (csmProject != null) {

                        collectSymbols(csmProject);

                    }

                }

            }

        }

        private void collectLibs(CsmProject project, Collection<CsmProject> libs) {

            for( CsmProject lib : project.getLibraries()) {

                if (! libs.contains(lib)) {

                    libs.add(lib);

                    collectLibs(lib, libs);

                }

            }

        }

        private void collectSymbols(CsmProject csmProject) {

            // process project namespaces

            collectSymbols(csmProject.getGlobalNamespace());

            CsmSelect.CsmFilter nameFilter = CsmSelect.getFilterBuilder().createNameFilter(nameAcceptor);

            // process project files

            for(CsmFile csmFile : csmProject.getAllFiles()) {

                checkCancelled();

                // macros

                Iterator<CsmMacro> macros = CsmSelect.getMacros(csmFile, nameFilter);

                while (macros.hasNext()) {

                    checkCancelled();

                    CsmMacro macro = macros.next();

                    if (nameAcceptor.accept(macro.getName())) {

                        if(CsmVisibilityQuery.isVisible(macro)) {

                            addResult(new CppSymbolDescriptor(macro));

                        }

                    }

                }

                checkCancelled();

                // static functions

                Iterator<CsmFunction> funcs = CsmSelect.getStaticFunctions(csmFile, nameFilter);

                while (funcs.hasNext()) {

                    checkCancelled();

                    CsmFunction func = funcs.next();

                    if (nameAcceptor.accept(func.getName())) {

                        if (CsmKindUtilities.isFunctionDefinition(func)) { // which is unlikely, but just in case

                            if(CsmVisibilityQuery.isVisible(func)) {

                                addResult(new CppSymbolDescriptor(func));

                            }

                        } else {

                            // static functions definitions are not returned by Select;

                            // neither do they reside in namespace

                            CsmFunctionDefinition definition = func.getDefinition();

                            if (definition != null ) {

                                if(CsmVisibilityQuery.isVisible(definition)) {

                                    addResult(new CppSymbolDescriptor(definition));

                                }

                            }

                        }

                    }

                }

                checkCancelled();

                CsmSelect.CsmFilter definitions = CsmSelect.getFilterBuilder().createCompoundFilter(nameFilter,  CsmSelect.getFilterBuilder().createKindFilter(Kind.FUNCTION_DEFINITION));

                Iterator<CsmOffsetableDeclaration> declarations = CsmSelect.getDeclarations(csmFile, definitions);

                while (declarations.hasNext()) {

                    checkCancelled();

                    CsmOffsetableDeclaration decl = declarations.next();

                    if (nameAcceptor.accept(decl.getName())) {

                        if (CsmKindUtilities.isFunctionDefinition(decl) && ((CsmFunction)decl).isStatic()) {

                            CsmFunction func = (CsmFunction) decl;

                            if (func.equals(func.getDeclaration()) && CsmKindUtilities.isFile(func.getScope())) {

                                if(CsmVisibilityQuery.isVisible(func)) {

                                    addResult(new CppSymbolDescriptor(func));

                                }

                            }

                        }

                    }

                }

                checkCancelled();

                // static variables

                Iterator<CsmVariable> vars = CsmSelect.getStaticVariables(csmFile, nameFilter);

                while (vars.hasNext()) {

                    checkCancelled();

                    CsmVariable var = vars.next();

                    if (nameAcceptor.accept(var.getName())) {

                        if(CsmVisibilityQuery.isVisible(var)) {

                            addResult(new CppSymbolDescriptor(var));

                        }

                    }

                }

            }

        }

        private void collectSymbols(CsmNamespace namespace) {

            // we can filter out "simple" (non-class) namespace elements via CsmSelect;

            // later we have to instantiate classes and enums to check their *members* as well

            CsmSelect.CsmFilter nameFilter = CsmSelect.getFilterBuilder().createNameFilter(nameAcceptor);

            CsmSelect.CsmFilter simpleKindFilter = CsmSelect.getFilterBuilder().createKindFilter(

                    CsmDeclaration.Kind.FUNCTION, CsmDeclaration.Kind.FUNCTION_DEFINITION, 

                    CsmDeclaration.Kind.FUNCTION_FRIEND, CsmDeclaration.Kind.FUNCTION_FRIEND_DEFINITION,

                    CsmDeclaration.Kind.VARIABLE, CsmDeclaration.Kind.TYPEDEF);

            CsmSelect.CsmFilter simpleNameAndKindFilter = CsmSelect.getFilterBuilder().createCompoundFilter(nameFilter, simpleKindFilter);

            Iterator<? extends CsmOffsetableDeclaration> declarations = CsmSelect.getDeclarations(namespace, simpleNameAndKindFilter);

            while (declarations.hasNext()) {

                checkCancelled();

                CsmOffsetableDeclaration decl = declarations.next();

                if (nameAcceptor.accept(decl.getName())) {

                    if (CsmKindUtilities.isFunction(decl)) {

                        // do not add declarations if their definitions exist

                        if (CsmKindUtilities.isFunctionDefinition(decl)) {

                            if(CsmVisibilityQuery.isVisible(decl)) {

                                addResult(new CppSymbolDescriptor(decl));

                            }

                        } else {

                            CsmFunctionDefinition definition = ((CsmFunction) decl).getDefinition();

                            if (definition == null || definition == decl) {

                                if(CsmVisibilityQuery.isVisible(decl)) {

                                    addResult(new CppSymbolDescriptor(decl));

                                }

                            }

                        }

                    } else {

                        if(CsmVisibilityQuery.isVisible(decl)) {

                            addResult(new CppSymbolDescriptor(decl));

                        }

                    }

                }

            }

            // instantiate classes and enums to check them and their members as well

            CsmSelect.CsmFilter kindFilter = CsmSelect.getFilterBuilder().createKindFilter(

                    CsmDeclaration.Kind.CLASS, CsmDeclaration.Kind.ENUM, CsmDeclaration.Kind.STRUCT);

            CsmSelect.CsmFilter classesOrMembers = CsmSelect.getFilterBuilder().createOrFilter(kindFilter, nameFilter);

            declarations = CsmSelect.getDeclarations(namespace, kindFilter);

            while (declarations.hasNext()) {

                checkCancelled();

                addDeclarationIfNeed(declarations.next(), classesOrMembers, nameFilter);

            }

            // process nested namespaces

            for (CsmNamespace child : namespace.getNestedNamespaces()) {

                checkCancelled();

                collectSymbols(child);

            }

        }

        /**

         * Is called for classes, enums and their members.

         * Checks name, if it suites, adds result to symbols collection.

         * Does the same recursively (with members/enumerators)

         */

        private void addDeclarationIfNeed(CsmOffsetableDeclaration decl, CsmSelect.CsmFilter classesOrMembers, CsmSelect.CsmFilter nameFilter) {

            if (nameAcceptor.accept(decl.getName())) {

                if(CsmVisibilityQuery.isVisible(decl)) {

                    addResult(new CppSymbolDescriptor(decl));

                }

            }

            if (CsmKindUtilities.isClass(decl)) {

                CsmClass cls = (CsmClass) decl;

                final Iterator<CsmMember> classMembers = CsmSelect.getClassMembers(cls, classesOrMembers);

                while(classMembers.hasNext()) {

                    addDeclarationIfNeed(classMembers.next(), classesOrMembers, nameFilter);

                }

            } else if (CsmKindUtilities.isEnum(decl)) {

                CsmEnum en = (CsmEnum) decl;

                Iterator<CsmEnumerator> enumerators = CsmSelect.getEnumerators(en, nameFilter);

                while(enumerators.hasNext()) {

                    CsmEnumerator enumerator = enumerators.next();

                    if (nameAcceptor.accept(enumerator.getName())) {

                        if(CsmVisibilityQuery.isVisible(enumerator)) {

                            addResult(new CppSymbolDescriptor(enumerator));

                        }

                    }

                }

            }

        }

        private void checkCancelled() throws CancellationException {

            if (cancelled.get()) {

                throw new CancellationException();

            }

        }

        private void addResult(CppSymbolDescriptor symbolDescriptor) {

            synchronized (resultLock) {

                result.add(symbolDescriptor);

            }

        }

    }