/*
    Dateiverwaltung - File management in your browser
    Copyright (C) 2017 Ulrich Hilger, http://uhilger.de

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as
    published by the Free Software Foundation, either version 3 of the
    License, or (at your option) any later version.

    This program 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 Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
package de.uhilger.filecms.api;

import de.uhilger.filecms.data.CompilerIssue;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.tools.Diagnostic;
import javax.tools.DiagnosticCollector;
import javax.tools.JavaCompiler;
import javax.tools.JavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
import org.apache.commons.io.FileUtils;
import org.apache.tomcat.util.log.SystemLogHandler;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.ProjectHelper;

/**
 *
 */
public class CompileService extends Api {
  
  private static final Logger logger = Logger.getLogger(CompileService.class.getName());
  
  public String antBuild(String relPath) {
    
    // Create a stream to hold the output
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    PrintStream ps = new PrintStream(baos);
    // IMPORTANT: Save the old System.out!
    PrintStream old = System.out;
    PrintStream err = System.err;
    // Tell Java to use your special stream
    System.setOut(ps);    
    System.setErr(ps);
    
    File targetDir = getTargetDir(relPath); // App-Ordner
    StringBuilder sb = new StringBuilder();
    sb.append("Ant build ist noch nicht implementiert.");

    sb.append("<br/>");
    sb.append("targetDir: ");
    sb.append(targetDir.getAbsolutePath());
    
    File buildFile = new File(targetDir, "build.xml");
    Project p = new Project();
    //p.setName("FileCms Build");
    FileCmsBuildListener listener = new FileCmsBuildListener();
    p.addBuildListener(listener);
    p.setUserProperty("ant.file", buildFile.getAbsolutePath());
    p.init();
    ProjectHelper helper = ProjectHelper.getProjectHelper();
    p.addReference("ant.projectHelper", helper);
    helper.parse(p, buildFile);
    p.executeTarget(p.getDefaultTarget());  
    sb.append("<br/>");
    sb.append(listener.getOutput());
    
    
    // Print some output: goes to your special stream
    //System.out.println("Foofoofoo!");
    // Put things back
    System.out.flush();
    System.err.flush();
    System.setOut(old);
    System.setErr(err);
    // Show what happened
    //System.out.println("Here: " + baos.toString());    
    
    sb.append("<br/>");
    sb.append(baos.toString());
    
    
    return sb.toString();
  }
  
  
  /**
   * Annahme: relPath zeigt auf einen Ordner, in dem ein build-Ordner die 
   * fertigen Klassen und ein web-Ordner die Struktur mit WEB-INF 
   * enthaelt.
   * 
   * @param relPath  der relative Pfad, der auf den App-Ordner verweist
   * @return 
   */
  public String buildApp(String relPath) {
    String result = "ok";
    try {
      File targetDir = getTargetDir(relPath); // App-Ordner
      File classesDir = new File(targetDir, "web/WEB-INF/classes");
      if(classesDir.exists()) {
        FileUtils.deleteDirectory(classesDir);
      }
      classesDir.mkdirs();
      File buildDir = new File(targetDir, "build/");
      File[] files = buildDir.listFiles();
      for(int i = 0; i < files.length; i++) {
        if(files[i].isDirectory()) {
          FileUtils.copyDirectoryToDirectory(files[i], classesDir);
        } else {
          FileUtils.copyFileToDirectory(files[i], classesDir);   
        }
      }
    } catch(Exception ex) {
      logger.log(Level.SEVERE, ex.getLocalizedMessage(), ex);
    }
    return result;
  }
    
  public List<CompilerIssue> compileAll(String relPath) {
    logger.fine(relPath);
    List<CompilerIssue> compilerIssues = new ArrayList();
    try {
      File targetDir = getTargetDir(relPath);
      ArrayList<File> files = new ArrayList();
      collectFiles(files, targetDir, new JavaFileFilter());
      JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
      DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector();
      StandardJavaFileManager fileManager = compiler.getStandardFileManager(diagnostics, null, null);
      Iterable<? extends JavaFileObject> compilationUnits = fileManager.getJavaFileObjectsFromFiles(files);
      
      
      final Iterable<String> options = buildOptions(targetDir);
      
      compiler.getTask(null, null, diagnostics, options, null, compilationUnits).call();
      fileManager.close();
      collectResults(diagnostics, compilerIssues, relPath);
    } catch(Exception ex) {
      logger.log(Level.SEVERE, ex.getLocalizedMessage(), ex);
    }
    return compilerIssues;
  }
  
  private void collectResults(DiagnosticCollector<JavaFileObject> diagnostics, List<CompilerIssue> compilerIssues, String relPath) {
    List compileResults = diagnostics.getDiagnostics();
    Iterator i = compileResults.iterator();
    while (i.hasNext()) {
      Object o = i.next();
      Diagnostic<? extends JavaFileObject> err;
      if (o instanceof Diagnostic) {
        err = (Diagnostic) o;
        CompilerIssue issue = new CompilerIssue();
        issue.setKind(err.getKind().name());
        issue.setLineNumber(err.getLineNumber());
        issue.setMessage(err.getMessage(Locale.GERMANY));
        
        String srcName = err.getSource().getName().replace("\\", "/");
        String cleanRelPath = relPath.replace(HOME_DIR_NAME + "/", "").replace(PUB_DIR_NAME + "/", "");
        int pos = srcName.indexOf(cleanRelPath);
        String className = srcName.substring(pos + cleanRelPath.length());
        issue.setSourceName(className.replace("/", ".").substring(1));
        //issue.setSourceName(srcName + "\r\n" + relPath);
        compilerIssues.add(issue);
      }
    }
  }
  
  private void collectFiles(ArrayList<File> files, File dir, FileFilter filter) {
    File[] dirFiles = dir.listFiles(filter);
    for(int i = 0; i < dirFiles.length; i++) {
      if(dirFiles[i].isDirectory()) {
        logger.fine("drill down to " + dirFiles[i].getAbsolutePath());
        collectFiles(files, dirFiles[i], filter);
      } else {
        logger.fine("add " + dirFiles[i].getAbsolutePath());
        files.add(dirFiles[i]);
      }
    }
  }
  
  public class JavaFileFilter implements FileFilter {

    @Override
    public boolean accept(File pathname) {
      boolean doAccept = false;
      if(pathname.getName().endsWith(".java") || pathname.isDirectory()) {
        doAccept = true;
      }
      return doAccept;
    }
  
  }
  
  public class JarFileFilter implements FileFilter {

    @Override
    public boolean accept(File pathname) {
      boolean doAccept = false;
      if(pathname.getName().endsWith(".jar")) {
        doAccept = true;
      }
      return doAccept;
    }
  
  }
  
  /**
   * 
   * @param relPath
   * @param fileNames
   * @param mode 0 = test, 1 = build
   * @return
   * @throws IOException 
   */
  public List<CompilerIssue> compile(String relPath, List fileNames, String mode) throws IOException {
    File targetDir = getTargetDir(relPath);
    ArrayList<File> files = new ArrayList();
    for(int i=0; i < fileNames.size(); i++) {
      Object o = fileNames.get(i);
      if(o instanceof ArrayList) {
        ArrayList al = (ArrayList) o;
        logger.fine(al.get(0).toString());
        File targetFile = new File(targetDir, al.get(0).toString());
        logger.fine(targetFile.getAbsolutePath());
        files.add(targetFile);
      }
    }
    JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
    DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector();
    StandardJavaFileManager fileManager = compiler.getStandardFileManager(diagnostics, null, null);
    Iterable<? extends JavaFileObject> compilationUnits1 = fileManager.getJavaFileObjectsFromFiles(files);    
    final Iterable<String> options = buildOptions(targetDir);
    compiler.getTask(null, fileManager, diagnostics, options, null, compilationUnits1).call();
    fileManager.close();
    List<CompilerIssue> compilerIssues = new ArrayList();
    collectResults(diagnostics, compilerIssues, relPath);
    return compilerIssues;
  }

  private final Iterable<String> buildOptions(File targetDir) {
      String cbase = getCatalinaBase(getServletContext());
      File lib = new File(cbase, "lib");
      String cp = "";
      cp = buildCPFromDir(cp, lib);
      logger.fine(lib.getAbsolutePath());
      logger.fine(cp);
      /*
        wegen dieser Funktion MUSS alles in 'src' liegen
      */
      File srcDir = targetDir;
      while(!srcDir.getName().endsWith("src")) {        
        srcDir = srcDir.getParentFile();
      }
      File appDir = srcDir.getParentFile();
      File appLibDir = new File(appDir, "web/WEB-INF/lib");
      cp = buildCPFromDir(cp, appLibDir);
      logger.fine(cp);
      /*
        ausgehend von src eins hoeher, dann nach build
      */
      File buildDir = new File(appDir, "build");
      final Iterable<String> options = Arrays.asList(new String[]{"-Xlint",
                    "-cp", cp,
                    "-d", buildDir.getAbsolutePath()
                    });      
      try {
        FileUtils.deleteDirectory(buildDir);
        buildDir.mkdir();
      } catch (IOException ex) {
        logger.log(Level.SEVERE, ex.getLocalizedMessage(), ex);
      }
      return options;
  }
  /*
  -classpath $JLIB/jettison-1.3.3.jar:$JLIB/xstream-1.4.7.jar
  */
  private String buildCPFromDir(String cp, File dir) {
    StringBuffer buf = new StringBuffer(cp);
    File[] files = dir.listFiles(new JarFileFilter());
    for(int i = 0; i < files.length; i++) {
      if(buf.length() > 0) {
        buf.append(File.pathSeparatorChar);
      }
      //buf.append("\"");
      buf.append(files[i].getAbsolutePath());
      //buf.append("\"");
    }
    
    return buf.toString();
  }
}



/*

 Beispeil fuer einen dynamischen Compiler-Aufruf
 'in memory'

 String className = "mypackage.MyClass";
 String javaCode = "package mypackage;\n" +
                  "public class MyClass implements Runnable {\n" +
                  "    public void run() {\n" +
                  "        System.out.println("\"Hello World\");\n" +
                  "    }\n" +
                  "}\n";
 Class aClass = CompilerUtils.CACHED_COMPILER.loadFromJava(className, javaCode);
 Runnable runner = (Runnable) aClass.newInstance();
 runner.run();

*/

/*
  CodeMirror Breakpoint bzw. Gutter Marker

  https://codemirror.net/demo/marker.html
*/