/*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to You 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.apache.commons.jci.listeners;
  
  import java.io.File;
  import java.util.ArrayList;
  import java.util.Collection;
  
  import org.apache.commons.jci.compilers.CompilationResult;
  import org.apache.commons.jci.compilers.JavaCompiler;
  import org.apache.commons.jci.compilers.JavaCompilerFactory;
  import org.apache.commons.jci.monitor.FilesystemAlterationObserver;
  import org.apache.commons.jci.problems.CompilationProblem;
  import org.apache.commons.jci.readers.FileResourceReader;
  import org.apache.commons.jci.readers.ResourceReader;
  import org.apache.commons.jci.stores.MemoryResourceStore;
  import org.apache.commons.jci.stores.ResourceStore;
  import org.apache.commons.jci.stores.TransactionalResourceStore;
  import org.apache.commons.jci.utils.ConversionUtils;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  /**
   * A CompilingListener is an improved version of the ReloadingListener.
   * It even compiles the classes from source before doing the reloading.
   * 
   * @author tcurdt
   */
  public class CompilingListener extends ReloadingListener {
  
      private final Log log = LogFactory.getLog(CompilingListener.class);
      
      private final JavaCompiler compiler;
      private final TransactionalResourceStore transactionalStore;
      private ResourceReader reader;
      private CompilationResult lastResult;
      
      public CompilingListener() {
          this(new JavaCompilerFactory().createCompiler("eclipse"));
      }
  
      public CompilingListener( final JavaCompiler pCompiler ) {
          this(pCompiler, new TransactionalResourceStore(new MemoryResourceStore()));
      }
      
      public CompilingListener( final JavaCompiler pCompiler, final TransactionalResourceStore pTransactionalStore ) {
          super(pTransactionalStore);
          compiler = pCompiler;
          transactionalStore = pTransactionalStore;
          lastResult = null;
      }
      
      public JavaCompiler getCompiler() {
          return compiler;
      }
      
      public String getSourceFileExtension() {
          return ".java";
      }
  
      public ResourceReader getReader( final FilesystemAlterationObserver pObserver ) {
          return new FileResourceReader(pObserver.getRootDirectory());
      }
  
      public String getSourceNameFromFile( final FilesystemAlterationObserver pObserver, final File pFile ) {
          return ConversionUtils.stripExtension(ConversionUtils.getResourceNameFromFileName(ConversionUtils.relative(pObserver.getRootDirectory(), pFile))) + getSourceFileExtension();
      }
      
      @Override
      public ResourceStore getStore() {
          return transactionalStore;
      }
  
      public synchronized CompilationResult getCompilationResult() {
          return lastResult;
      }
      
      @Override
      public void onStart( final FilesystemAlterationObserver pObserver ) {
          super.onStart(pObserver);
  
          reader = getReader(pObserver);
  
          transactionalStore.onStart();
     }
 
     public String[] getResourcesToCompile( final FilesystemAlterationObserver pObserver ) {
         final Collection<File> created = getCreatedFiles();
         final Collection<File> changed = getChangedFiles();
 
         final Collection<String> resourceNames = new ArrayList<String>();
         
         for (File createdFile : created) {
             if (createdFile.getName().endsWith(getSourceFileExtension())) {
                 resourceNames.add(getSourceNameFromFile(pObserver, createdFile));
             }
         }
         
         for (File changedFile : changed) {
             if (changedFile.getName().endsWith(getSourceFileExtension())) {
                 resourceNames.add(getSourceNameFromFile(pObserver, changedFile));
             }
         }
 
         final String[] result = new String[resourceNames.size()];
         resourceNames.toArray(result);
         return result;
     }
     
     @Override
     public boolean isReloadRequired( final FilesystemAlterationObserver pObserver ) {
         boolean reload = false;
 
         final Collection<File> created = getCreatedFiles();
         final Collection<File> changed = getChangedFiles();
         final Collection<File> deleted = getDeletedFiles();
         
         log.debug("created:" + created.size() + " changed:" + changed.size() + " deleted:" + deleted.size() + " resources");
 
         if (deleted.size() > 0) {
             for (File deletedFile : deleted) {
                 final String resourceName = ConversionUtils.getResourceNameFromFileName(ConversionUtils.relative(pObserver.getRootDirectory(), deletedFile));
                 
                 if (resourceName.endsWith(getSourceFileExtension())) {
                     // if source resource got removed delete the corresponding class 
                     transactionalStore.remove(ConversionUtils.stripExtension(resourceName) + ".class");
                 } else {
                     // ordinary resource to be removed
                     transactionalStore.remove(resourceName);
                 }
                 
                 // FIXME: does not remove nested classes
                 
             }
             reload = true;
         }
                                 
         final String[] resourcesToCompile = getResourcesToCompile(pObserver);
 
         if (resourcesToCompile.length > 0) {
 
             log.debug(resourcesToCompile.length + " classes to compile");
             
             final CompilationResult result = compiler.compile(resourcesToCompile, reader, transactionalStore);
             
             synchronized(this) {
                 lastResult = result;
             }
             
             final CompilationProblem[] errors = result.getErrors();
             final CompilationProblem[] warnings = result.getWarnings();
             
             log.debug(errors.length + " errors, " + warnings.length + " warnings");
         
             if (errors.length > 0) {
                 // FIXME: they need to be marked for re-compilation
                 // and then added as compileables again
                 for (int j = 0; j < resourcesToCompile.length; j++) {
                     transactionalStore.remove(resourcesToCompile[j]);
                 }
             }
             
             reload = true;
         }
         
         return reload;
     }    
 }