/*

 * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.

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

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

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

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package com.sun.tools.sjavac.server;

import java.io.BufferedReader;

import java.io.File;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.io.PrintWriter;

import java.io.StringWriter;

import java.net.Socket;

import java.net.URI;

import java.net.URISyntaxException;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import java.util.Map;

import java.util.concurrent.Future;

import javax.tools.JavaFileManager;

import javax.tools.JavaFileObject;

import javax.tools.StandardJavaFileManager;

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

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

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

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

import com.sun.tools.sjavac.comp.Dependencies;

import com.sun.tools.sjavac.comp.JavaCompilerWithDeps;

import com.sun.tools.sjavac.comp.SmartFileManager;

import com.sun.tools.sjavac.comp.ResolveWithDeps;

/**

 * The compiler thread maintains a JavaCompiler instance and

 * can receive a request from the client, perform the compilation

 * requested and report back the results.

 *

 *  * <p><b>This is NOT part of any supported API.

 * If you write code that depends on this, you do so at your own

 * risk.  This code and its internal interfaces are subject to change

 * or deletion without notice.</b></p>

 */

public class CompilerThread implements Runnable {

    private JavacServer javacServer;

    private CompilerPool compilerPool;

    private List<Future<?>> subTasks;

    // Communicating over this socket.

    private Socket socket;

    // The necessary classes to do a compilation.

    private com.sun.tools.javac.api.JavacTool compiler;

    private StandardJavaFileManager fileManager;

    private BaseFileManager fileManagerBase;

    private SmartFileManager smartFileManager;

    private Context context;

    // If true, then this thread is serving a request.

    private boolean inUse = false;

    CompilerThread(CompilerPool cp) {

        compilerPool = cp;

        javacServer = cp.getJavacServer();

    }

    /**

     * Execute a minor task, for example generating bytecodes and writing them to disk,

     * that belong to a major compiler thread task.

     */

    public synchronized void executeSubtask(Runnable r) {

        subTasks.add(compilerPool.executeSubtask(this, r));

    }

    /**

     * Count the number of active sub tasks.

     */

    public synchronized int numActiveSubTasks() {

        int c = 0;

        for (Future<?> f : subTasks) {

            if (!f.isDone() && !f.isCancelled()) {

                c++;

            }

        }

        return c;

    }

    /**

     * Use this socket for the upcoming request.

     */

    public void setSocket(Socket s) {

        socket = s;

    }

    /**

     * Prepare the compiler thread for use. It is not yet started.

     * It will be started by the executor service.

     */

    public synchronized void use() {

        assert(!inUse);

        inUse = true;

        compiler = com.sun.tools.javac.api.JavacTool.create();

        fileManager = compiler.getStandardFileManager(null, null, null);

        fileManagerBase = (BaseFileManager)fileManager;

        smartFileManager = new SmartFileManager(fileManager);

        context = new Context();

        context.put(JavaFileManager.class, smartFileManager);

        ResolveWithDeps.preRegister(context);

        JavaCompilerWithDeps.preRegister(context, this);

    }

    /**

     * Prepare the compiler thread for idleness.

     */

    public synchronized void unuse() {

        assert(inUse);

        inUse = false;

        compiler = null;

        fileManager = null;

        fileManagerBase = null;

        smartFileManager = null;

        context = null;

        subTasks = null;

    }

    /**

     * Expect this key on the next line read from the reader.

     */

    private static boolean expect(BufferedReader in, String key) throws IOException {

        String s = in.readLine();

        if (s != null && s.equals(key)) {

            return true;

        }

        return false;

    }

    // The request identifier, for example GENERATE_NEWBYTECODE

    String id = "";

    public String currentRequestId() {

        return id;

    }

    PrintWriter stdout;

    PrintWriter stderr;

    int forcedExitCode = 0;

    public void logError(String msg) {

        stderr.println(msg);

        forcedExitCode = -1;

    }

    /**

     * Invoked by the executor service.

     */

    public void run() {

        // Unique nr that identifies this request.

        int thisRequest = compilerPool.startRequest();

        long start = System.currentTimeMillis();

        int numClasses = 0;

        StringBuilder compiledPkgs = new StringBuilder();

        use();

        PrintWriter out = null;

        try {

            javacServer.log("<"+thisRequest+"> Connect from "+socket.getRemoteSocketAddress()+" activethreads="+compilerPool.numActiveRequests());

            BufferedReader in = new BufferedReader(new InputStreamReader(

                                                       socket.getInputStream()));

            out = new PrintWriter(new OutputStreamWriter(

                                                  socket.getOutputStream()));

            if (!expect(in, JavacServer.PROTOCOL_COOKIE_VERSION)) {

                javacServer.log("<"+thisRequest+"> Bad protocol from ip "+socket.getRemoteSocketAddress());

                return;

            }

            String cookie = in.readLine();

            if (cookie == null || !cookie.equals(""+javacServer.getCookie())) {

                javacServer.log("<"+thisRequest+"> Bad cookie from ip "+socket.getRemoteSocketAddress());

                return;

            }

            if (!expect(in, JavacServer.PROTOCOL_CWD)) {

                return;

            }

            String cwd = in.readLine();

            if (cwd == null)

                return;

            if (!expect(in, JavacServer.PROTOCOL_ID)) {

                return;

            }

            id = in.readLine();

            if (id == null)

                return;

            if (!expect(in, JavacServer.PROTOCOL_ARGS)) {

                return;

            }

            Iterable<File> path = Arrays.<File> asList(new File(cwd));

            for (;;) {

                String l = in.readLine();

                if (l == null)

                    return;

                if (l.equals(JavacServer.PROTOCOL_SOURCES_TO_COMPILE))

                    break;

                if (l.startsWith("--server:"))

                    continue;

                if (!l.startsWith("-") && l.endsWith(".java")) {

                    the_classes.add(new File(l));

                    numClasses++;

                } else {

                    the_options.add(l);

                }

                continue;

            }

            // Load sources to compile

            for (;;) {

                String l = in.readLine();

                if (l == null)

                    return;

                if (l.equals(JavacServer.PROTOCOL_VISIBLE_SOURCES))

                    break;

                try {

                    sourcesToCompile.add(new URI(l));

                    numClasses++;

                } catch (URISyntaxException e) {

                    return;

                }

            }

            // Load visible sources

            boolean fix_drive_letter_case =

                StringUtils.toLowerCase(System.getProperty("os.name")).startsWith("windows");

            for (;;) {

                String l = in.readLine();

                if (l == null)

                    return;

                if (l.equals(JavacServer.PROTOCOL_END))

                    break;

                try {

                    URI u = new URI(l);

                    if (fix_drive_letter_case) {

                        // Make sure the driver letter is lower case.

                        String s = u.toString();

                        if (s.startsWith("file:/") &&

                            Character.isUpperCase(s.charAt(6))) {

                            u = new URI("file:/"+Character.toLowerCase(s.charAt(6))+s.substring(7));

                        }

                    }

                    visibleSources.add(u);

                } catch (URISyntaxException e) {

                    return;

                }

            }

            // A completed request has been received.

            // Now setup the actual compilation....

            // First deal with explicit source files on cmdline and in at file.

            for (JavaFileObject i : fileManager.getJavaFileObjectsFromFiles(the_classes)) {

                compilationUnits.append(i);

            }

            // Now deal with sources supplied as source_to_compile.

            for (URI u : sourcesToCompile) {

                sourcesToCompileFiles.append(new File(u));

            }

            for (JavaFileObject i : fileManager.getJavaFileObjectsFromFiles(sourcesToCompileFiles)) {

                compilationUnits.append(i);

            }

            // Log the options to be used.

            StringBuilder options = new StringBuilder();

            for (String s : the_options) {

                options.append(">").append(s).append("< ");

            }

            javacServer.log(id+" <"+thisRequest+"> options "+options.toString());

            forcedExitCode = 0;

            // Create a new logger.

            StringWriter stdoutLog = new StringWriter();

            StringWriter stderrLog = new StringWriter();

            stdout = new PrintWriter(stdoutLog);

            stderr = new PrintWriter(stderrLog);

            com.sun.tools.javac.main.Main.Result rc = com.sun.tools.javac.main.Main.Result.OK;

            try {

                if (compilationUnits.size() > 0) {

                    // Bind the new logger to the existing context.

                    context.put(Log.outKey, stderr);

                    Log.instance(context).setWriter(Log.WriterKind.NOTICE, stdout);

                    Log.instance(context).setWriter(Log.WriterKind.WARNING, stderr);

                    Log.instance(context).setWriter(Log.WriterKind.ERROR, stderr);

                    // Process the options.

                    com.sun.tools.javac.api.JavacTool.processOptions(context, smartFileManager, the_options);

                    fileManagerBase.setContext(context);

                    smartFileManager.setVisibleSources(visibleSources);

                    smartFileManager.cleanArtifacts();

                    smartFileManager.setLog(stdout);

                    Dependencies.instance(context).reset();

                    com.sun.tools.javac.main.Main ccompiler = new com.sun.tools.javac.main.Main("javacTask", stderr);

                    String[] aa = the_options.toArray(new String[0]);

                    // Do the compilation!

                    rc = ccompiler.compile(aa, context, compilationUnits.toList(), null);

                    while (numActiveSubTasks()>0) {

                        try { Thread.sleep(1000); } catch (InterruptedException e) { }

                    }

                    smartFileManager.flush();

                }

            } catch (Exception e) {

                stderr.println(e.getMessage());

                forcedExitCode = -1;

            }

            // Send the response..

            out.println(JavacServer.PROTOCOL_STDOUT);

            out.print(stdoutLog);

            out.println(JavacServer.PROTOCOL_STDERR);

            out.print(stderrLog);

            // The compilation is complete! And errors will have already been printed on out!

            out.println(JavacServer.PROTOCOL_PACKAGE_ARTIFACTS);

            Map<String,Set<URI>> pa = smartFileManager.getPackageArtifacts();

            for (String aPkgName : pa.keySet()) {

                out.println("+"+aPkgName);

                Set<URI> as = pa.get(aPkgName);

                for (URI a : as) {

                    out.println(" "+a.toString());

                }

            }

            Dependencies deps = Dependencies.instance(context);

            out.println(JavacServer.PROTOCOL_PACKAGE_DEPENDENCIES);

            Map<String,Set<String>> pd = deps.getDependencies();

            for (String aPkgName : pd.keySet()) {

                out.println("+"+aPkgName);

                Set<String> ds = pd.get(aPkgName);

                    // Everything depends on java.lang

                    if (!ds.contains(":java.lang")) ds.add(":java.lang");

                for (String d : ds) {

                    out.println(" "+d);

                }

            }

            out.println(JavacServer.PROTOCOL_PACKAGE_PUBLIC_APIS);

            Map<String,String> pp = deps.getPubapis();

            for (String aPkgName : pp.keySet()) {

                out.println("+"+aPkgName);

                String ps = pp.get(aPkgName);

                // getPubapis added a space to each line!

                out.println(ps);

                compiledPkgs.append(aPkgName+" ");

            }

            out.println(JavacServer.PROTOCOL_SYSINFO);

            out.println("num_cores=" + Runtime.getRuntime().availableProcessors());

            out.println("max_memory=" + Runtime.getRuntime().maxMemory());

            out.println(JavacServer.PROTOCOL_RETURN_CODE);

            // Errors from sjavac that affect compilation status!

            int rcv = rc.exitCode;

            if (rcv == 0 && forcedExitCode != 0) {

                rcv = forcedExitCode;

            }

            out.println("" + rcv);

            out.println(JavacServer.PROTOCOL_END);

            out.flush();

        } catch (IOException e) {

            e.printStackTrace();

        } finally {

            try {

                if (out != null) out.close();

                if (!socket.isClosed()) {

                    socket.close();

                }

                socket = null;

            } catch (Exception e) {

                javacServer.log("ERROR "+e);

                e.printStackTrace();

            }

            compilerPool.stopRequest();

            long duration = System.currentTimeMillis()-start;

            javacServer.addBuildTime(duration);

            float classpersec = ((float)numClasses)*(((float)1000.0)/((float)duration));

            javacServer.log(id+" <"+thisRequest+"> "+compiledPkgs+" duration " + duration+ " ms    num_classes="+numClasses+

                             "     classpersec="+classpersec+" subtasks="+subTasks.size());

            javacServer.flushLog();

            unuse();

            compilerPool.returnCompilerThread(this);

        }

    }

}