/*

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

  *

  * Copyright 2009-2011 Sun Microsystems, Inc. All rights reserved.

  *

  * 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.  Sun designates this

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

  * by Sun 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 2009-2011 Sun Microsystems, Inc.

  */

 package org.netbeans.modules.jackpot30.compiler;

 import com.sun.source.util.JavacTask;

 import com.sun.source.util.TaskEvent;

 import com.sun.source.util.TaskListener;

 import com.sun.source.util.TreePath;

 import com.sun.source.util.Trees;

 import com.sun.tools.javac.api.JavacTrees;

 import com.sun.tools.javac.api.MultiTaskListener;

 import com.sun.tools.javac.jvm.Gen;

 import com.sun.tools.javac.parser.ParserFactory;

 import com.sun.tools.javac.processing.JavacProcessingEnvironment;

 import com.sun.tools.javac.tree.JCTree.JCCompilationUnit;

 import com.sun.tools.javac.util.Context;

 import com.sun.tools.javac.util.Context.Key;

 import com.sun.tools.javac.util.Log;

 import com.sun.tools.javac.util.Options;

 import java.io.File;

 import java.lang.reflect.Field;

 import java.net.URL;

 import java.util.Collection;

 import java.util.HashSet;

 import java.util.LinkedList;

 import java.util.List;

 import java.util.Set;

 import javax.annotation.processing.AbstractProcessor;

 import javax.annotation.processing.ProcessingEnvironment;

 import javax.annotation.processing.Processor;

 import javax.annotation.processing.RoundEnvironment;

 import javax.annotation.processing.SupportedAnnotationTypes;

 import javax.lang.model.SourceVersion;

 import javax.lang.model.element.TypeElement;

 import javax.lang.model.util.ElementFilter;

 import javax.tools.Diagnostic.Kind;

 import javax.tools.JavaFileManager;

 import javax.tools.JavaFileObject;

 import javax.tools.StandardJavaFileManager;

 import javax.tools.StandardLocation;

 import org.netbeans.api.java.classpath.ClassPath;

 import org.netbeans.api.java.source.ClasspathInfo;

 import org.netbeans.api.java.source.CompilationInfoHack;

 import org.netbeans.lib.nbjavac.services.NBParserFactory;

 import org.netbeans.modules.jackpot30.compiler.AbstractHintsAnnotationProcessing.Reporter;

 import org.netbeans.spi.java.classpath.support.ClassPathSupport;

 import org.openide.filesystems.FileUtil;

 import org.openide.util.Lookup;

 import org.openide.util.lookup.ServiceProvider;

 /**

  *

  * @author lahvac

  */

 @SupportedAnnotationTypes("*")

 @ServiceProvider(service=Processor.class)

 public final class HintsAnnotationProcessingImpl extends AbstractProcessor {

     private final Collection<String> seenTypes = new LinkedList<String>();

     private final Collection<AbstractHintsAnnotationProcessing> processors = new LinkedList<AbstractHintsAnnotationProcessing>();

     @Override

     public synchronized void init(ProcessingEnvironment processingEnv) {

         super.init(processingEnv);

         for (AbstractHintsAnnotationProcessing p : Lookup.getDefault().lookupAll(AbstractHintsAnnotationProcessing.class)) {

             if (p.initialize(processingEnv)) {

                 processors.add(p);

             }

         }

         if (processors.isEmpty()) {

             return;

         }

         if (!(processingEnv instanceof JavacProcessingEnvironment)) {

             throw new UnsupportedOperationException("Not a JavacProcessingEnvironment");

         }

         Context c = ((JavacProcessingEnvironment) processingEnv).getContext();

         MultiTaskListener.instance(c).add(new TaskListenerImpl());

     }

     @Override

     public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {

         for (TypeElement type : ElementFilter.typesIn(roundEnv.getRootElements())) {

             seenTypes.add(type.getQualifiedName().toString());

         }

         if (roundEnv.processingOver()) {

             try {

                 //XXX: workarounding a bug in CRTable (see HintsAnnotationProcessingTest.testCRTable):

                 Context c = ((JavacProcessingEnvironment) processingEnv).getContext();

                 Options.instance(c).remove("-Xjcov");

                 Field f = Gen.class.getDeclaredField("genCrt");

                 f.setAccessible(true);

                 f.set(Gen.instance(c), false);

             } catch (Exception e) {

                 e.printStackTrace();

             }

         }

         return false;

     }

     private void doProcessing(TypeElement type) {

         if (!seenTypes.remove(type.getQualifiedName().toString())) return;

         Context c = ((JavacProcessingEnvironment) processingEnv).getContext();

         StandardJavaFileManager s = (StandardJavaFileManager) c.get(JavaFileManager.class);

         ClassPath boot = computeClassPath(s, StandardLocation.PLATFORM_CLASS_PATH);

         ClassPath compile = computeClassPath(s, StandardLocation.CLASS_PATH);

         ClassPath source = computeClassPath(s, StandardLocation.SOURCE_PATH);

         Trees trees = JavacTrees.instance(c);

         final Log log = Log.instance(c);

         final Key<ParserFactory> key = ParserFactoryKeyAccessor.getContextKey();

         ParserFactory origParserFactory = c.get(key);

         c.put(key, (ParserFactory) null);

         NBParserFactory.preRegister(c);

         try {

             TreePath elTree = trees.getPath(type);

             JCCompilationUnit cut = (JCCompilationUnit) elTree.getCompilationUnit();

             if (!cut.sourcefile.toUri().isAbsolute()) {

                 processingEnv.getMessager().printMessage(Kind.NOTE, "Not an absolute URI: " + cut.sourcefile.toUri().toASCIIString(), type);

                 return ; //XXX

             }

             CompilationInfoHack info = new CompilationInfoHack(c, ClasspathInfo.create(boot, compile, source), cut);

             JavaFileObject origSourceFile = log.currentSourceFile();

             try {

                 log.useSource(cut.sourcefile);

                 for (AbstractHintsAnnotationProcessing p : processors) {

                     p.doProcess(info, processingEnv, new Reporter() {

                         @Override public void warning(int offset, String message) {

                             log.warning(offset, "proc.messager", message);

                         }

                     });

                 }

             } finally {

                 log.useSource(origSourceFile);

             }

         } finally {

             if (seenTypes.isEmpty()) {

                 for (AbstractHintsAnnotationProcessing p : processors) {

                     p.finish();

                 }

             }

             c.put(key, (ParserFactory) null);

             c.put(key, origParserFactory);

         }

     }

     @Override

     public SourceVersion getSupportedSourceVersion() {

         return SourceVersion.latest();

     }

     @Override

     public Set<String> getSupportedOptions() {

         Set<String> options = new HashSet<String>();

         for (AbstractHintsAnnotationProcessing p : Lookup.getDefault().lookupAll(AbstractHintsAnnotationProcessing.class)) {

             options.addAll(p.getSupportedOptions());

         }

         return options;

     }

     private static ClassPath computeClassPath(StandardJavaFileManager m, StandardLocation kind) {

         List<URL> urls = new LinkedList<URL>();

         Iterable<? extends File> files = m.getLocation(kind);

         if (files != null) {

             for (File f : files) {

                 urls.add(FileUtil.urlForArchiveOrDir(FileUtil.normalizeFile(f)));

             }

         }

         return ClassPathSupport.createClassPath(urls.toArray(new URL[0]));

     }

     private final class TaskListenerImpl implements TaskListener {

         public TaskListenerImpl() { }

         @Override

         public void started(TaskEvent te) {

         }

         @Override

         public void finished(TaskEvent te) {

             if (te.getKind() == TaskEvent.Kind.ANALYZE) {

                 TypeElement toProcess = te.getTypeElement();

                 assert toProcess != null;

                 doProcessing(toProcess);

             }

         }

     }

     private static final class ParserFactoryKeyAccessor extends ParserFactory {

         ParserFactoryKeyAccessor() {

             super(null);

         }

         public static Key<ParserFactory> getContextKey() {

             return parserFactoryKey;

         }

     }

     static {

         try {

             ClassLoader l = HintsAnnotationProcessingImpl.class.getClassLoader();

             if (l == null) {

                 l = ClassLoader.getSystemClassLoader();

             }

             l.setClassAssertionStatus("org.netbeans.api.java.source.CompilationInfo", false);

         } catch (Throwable t) {

             t.printStackTrace();

         }

     }

 }