/*
    * Copyright 2005 Edward Kuns
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    * http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.castor.xmlctf.compiler;
  
  import java.io.File;
  import java.util.HashSet;
  
  import org.apache.tools.ant.BuildException;
  import org.apache.tools.ant.Project;
  import org.apache.tools.ant.taskdefs.Javac;
  import org.apache.tools.ant.types.Path;
  import org.castor.xmlctf.XMLTestCase;
  import org.castor.xmlctf.util.FileServices;
  
  /**
   * Compiles a directory tree, recursively. This class is built around the use of
   * the ANT JAVAC task.
   */
  public class AntJavaCompiler implements Compiler {
      /** A Set of directories to ignore. */
      private static final HashSet IGNORE_DIRS = new HashSet();
  
      static {
          IGNORE_DIRS.add(FileServices.CVS);
          IGNORE_DIRS.add(FileServices.SVN);
          IGNORE_DIRS.add("org");
          IGNORE_DIRS.add("com");
          IGNORE_DIRS.add("net");
      }
  
      private final File  _baseDirectory;
      private final File  _outputDirectory;
  
      private String      _javaVersion = null;
      private Javac       _compiler;
  
      /**
       * Creates a compiler for a given directory.
       *
       * @param baseDirectory The directory that holds the files to be compiled.
       */
      public AntJavaCompiler(final File baseDirectory) {
          if (baseDirectory == null) {
              throw new IllegalArgumentException("'baseDirectory' must not be null.");
          }
          _baseDirectory = baseDirectory;
          _outputDirectory = baseDirectory;
      }
  
      /**
       * Sets the Java source version the current test will be using.
       * @param javaSourceVersion The Java Source version to be used.
       */
      public void setJavaSourceVersion(final float javaSourceVersion) {
          float srcVersion = javaSourceVersion;
          if (javaSourceVersion >= 5F && javaSourceVersion < 10F) {
              srcVersion = 1.0F + (javaSourceVersion / 10F);
          }
          _javaVersion = "" + srcVersion;
      }
  
      /**
       * Compiles the content of a directory. Throws a <code>CompilationException</code>
       * if the build fails.
       */
      public void compileDirectory() {
          _compiler = makeCompiler(_baseDirectory, _outputDirectory);
          compileDirectory(_baseDirectory, _outputDirectory);
      }
  
      /**
       * Creates and returns a Ant Javac compiler.
       * @param srcDir Source directory for compiation.
       * @param destDir Destination directory for compilation.
       *
       * @return Ant Javac compiler
       */
      private Javac makeCompiler(final File srcDir, final File destDir) {
          Project project = new Project();
          project.init();
          project.setBasedir(srcDir.getAbsolutePath());
  
          Javac compiler = new Javac();
          compiler.setProject(project);
          compiler.setDestdir(destDir.getAbsoluteFile());
          compiler.setOptimize(false);
         compiler.setDebug(true);
         compiler.setDebugLevel("lines,vars,source");
         compiler.setIncludejavaruntime(true);
         if (XMLTestCase._verbose) {
             compiler.setListfiles(true);
             compiler.setVerbose(true);
         } else {
             compiler.setNowarn(true);
         }
         if (_javaVersion != null) {
             compiler.setSource(_javaVersion);
         }
         Path classpath = compiler.createClasspath();
         classpath.setPath(System.getProperty("java.class.path"));
         classpath.add(new Path(project, destDir.getAbsolutePath()));
         compiler.setClasspath(classpath);
         return compiler;
     }
 
     /**
      * Compiles a directory tree. Throws a <code>CompilationException</code> if build
      * fails.
      *
      * @param srcDir Source directory holding the files to be compiled.
      * @param destDir Destination directory to put the compiled classes in.
      */
     private void compileDirectory(final File srcDir, final File destDir) {
         File[] entries = srcDir.listFiles();
         for (int i = 0; i < entries.length; i++) {
             File entry = entries[i];
             if (entry.isDirectory() && !IGNORE_DIRS.contains(entry.getName())) {
                 compileDirectory(entry, destDir);
             }
         }
         entries = null;
 
         try {
             Path srcPath = _compiler.createSrc();
             srcPath.setLocation(destDir);
             _compiler.setSrcdir(srcPath);
             _compiler.execute();
         } catch (BuildException ex) {
             throw new CompilationException("Problem compiling directory " + srcDir, ex);
         }
     }
 
 }