/*

 * To change this template, choose Tools | Templates

 * and open the template in the editor.

 */

package org.apidesign.bck2brwsr.ide.editor;

import com.sun.source.tree.AnnotationTree;

import com.sun.source.tree.AssignmentTree;

import com.sun.source.tree.CompilationUnitTree;

import com.sun.source.tree.ExpressionTree;

import com.sun.source.tree.LiteralTree;

import com.sun.source.tree.MethodTree;

import com.sun.source.util.SourcePositions;

import com.sun.source.util.TreePath;

import com.sun.source.util.TreePathScanner;

import com.sun.source.util.Trees;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.List;

import java.util.concurrent.atomic.AtomicBoolean;

import javax.lang.model.element.TypeElement;

import javax.swing.text.Document;

import org.netbeans.api.editor.mimelookup.MimeRegistration;

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

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

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

import org.netbeans.api.lexer.Language;

import org.netbeans.api.lexer.TokenHierarchy;

import org.netbeans.api.lexer.TokenSequence;

import org.netbeans.modules.parsing.api.Snapshot;

import org.netbeans.modules.parsing.spi.Parser;

import org.netbeans.modules.parsing.spi.Scheduler;

import org.netbeans.modules.parsing.spi.SchedulerEvent;

import org.netbeans.modules.parsing.spi.SchedulerTask;

import org.netbeans.modules.parsing.spi.TaskFactory;

import org.openide.util.Exceptions;

/**

 *

 * @author Tomas Zezula

 */

public final class JSEmbeddingProvider extends JavaParserResultTask<Parser.Result> {

    private static final int PRIORITY = 1000;

    private static final String JS_ANNOTATION = "org.apidesign.bck2brwsr.core.JavaScriptBody";  //NOI18N

    private static final String BODY = "body";                            //NOI18N

    private static final String JAVA_MIME_TYPE = "text/x-java";           //NOI18N

    private static final String JAVASCRIPT_MIME_TYPE = "text/javascript"; //NOI18N

    private final AtomicBoolean canceled = new AtomicBoolean();

    private JSEmbeddingProvider() {

        super(JavaSource.Phase.ELEMENTS_RESOLVED);

    }

    @Override

    public int getPriority() {

        return PRIORITY;

    }

    @Override

    public void cancel() {

        canceled.set(true);

    }

    @Override

    public Class<? extends Scheduler> getSchedulerClass() {

        return Scheduler.EDITOR_SENSITIVE_TASK_SCHEDULER;

    }

    @Override

    public void run(Parser.Result t, SchedulerEvent se) {

        canceled.set(false);

        final CompilationInfo ci = CompilationInfo.get(t);

        final CompilationUnitTree cu = ci.getCompilationUnit();

        final Trees trees = ci.getTrees();

        final SourcePositions sp = trees.getSourcePositions();

        final Finder f = new Finder(trees);

        final List<LiteralTree> result = new ArrayList<LiteralTree>();

        f.scan(cu, result);

        if (!result.isEmpty()) {

            try {

                final TokenHierarchy<Document> tk = TokenHierarchy.get(ci.getDocument());

                final Language<?> java = Language.find(JAVA_MIME_TYPE);

                final Language<?> javaScript = Language.find(JAVASCRIPT_MIME_TYPE);

                if (java != null && javaScript != null) {

                    final TokenSequence<?> seq = tk.tokenSequence(java);

                    if (seq != null) {

                        for (LiteralTree lt : result) {

                            final int start = (int) sp.getStartPosition(cu, lt);

                            final int end = (int) sp.getEndPosition(cu, lt);

                            seq.move(start);

                            while (seq.moveNext() && seq.offset() < end) {

                                seq.createEmbedding(javaScript, 1, 1, true);

                            }

                        }

                    }

                }

            } catch (IOException ioe) {

                Exceptions.printStackTrace(ioe);

            }

        }

    }

    private static final class Finder extends TreePathScanner<Void, List<? super LiteralTree>> {

        private final Trees trees;

        private CompilationUnitTree cu;

        private boolean inEmbedding;

        Finder(final Trees trees) {

            this.trees = trees;

        }

        @Override

        public Void visitCompilationUnit(

                final CompilationUnitTree unit,

                final List p) {

            this.cu = unit;

            return super.visitCompilationUnit(unit, p);

        }

        @Override

        public Void visitMethod(

                final MethodTree m,

                final List<? super LiteralTree> p) {

            for (AnnotationTree a : m.getModifiers().getAnnotations()) {

                final TypeElement ae = (TypeElement) trees.getElement(TreePath.getPath(cu, a.getAnnotationType()));

                if (ae != null && JS_ANNOTATION.contentEquals(ae.getQualifiedName())) {

                    final List<? extends ExpressionTree> args =  a.getArguments();

                    for (ExpressionTree kvp : args) {

                        if (kvp instanceof AssignmentTree) {

                            final AssignmentTree assignemt = (AssignmentTree) kvp;

                            if (BODY.equals(assignemt.getVariable().toString())) {

                                inEmbedding = true;

                                try {

                                    scan(assignemt.getExpression(), p);

                                } finally {

                                    inEmbedding = false;

                                }

                            }

                        }

                    }

                }

            }

            return null;

        }

        @Override

        public Void visitLiteral(LiteralTree node, List<? super LiteralTree> p) {

            if (inEmbedding) {

                p.add(node);

            }

            return super.visitLiteral(node, p);

        }

    }

    @MimeRegistration(

            service = TaskFactory.class,

            mimeType = JAVA_MIME_TYPE)

    public static final class Factory extends TaskFactory {

        @Override

        public Collection<? extends SchedulerTask> create(Snapshot snpsht) {

            return Collections.singleton(new JSEmbeddingProvider());

        }

    }

}