package net.sf.jpkgmk.prototype;
   
   import java.io.File;
   import java.io.FileNotFoundException;
   import java.io.IOException;
   import java.util.ArrayList;
   import java.util.Iterator;
   import java.util.List;
   
  import net.sf.jpkgmk.PackageException;
  import net.sf.jpkgmk.pkgmap.PkgMap;
  import net.sf.jpkgmk.pkgmap.PkgMapEntry;
  import net.sf.jpkgmk.util.VariableMap;
  import net.sf.jpkgmk.util.VariableResolver;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  /**
   * Represents a search command to be used when creating a package from this prototype.
   * <p>
   * For details refer to <a href="http://docs.sun.com/app/docs/doc/806-7008/6jftmsc21?a=view">
   * http://docs.sun.com/app/docs/doc/806-7008/6jftmsc21?a=view</a> 
   * in section &quot;<i>Providing a Search Path for the pkgmk Command</i>&quot;.
   * </p>
   * 
   * @author gommma (gommma AT users.sourceforge.net)
   * @author Last changed by: $Author: gommma $
   * @version $Revision: 2 $ $Date: 2008-08-20 21:14:19 +0200 (Mi, 20 Aug 2008) $
   * @since 1.0
   */
  public class PrototypeEntryCommandSearch extends PrototypeEntryCommand
  {
      private Log log = LogFactory.getLog(PrototypeEntryCommandSearch.class);
      private String[] searchPaths;
      /** Intermediate prototype which is used to return the pgkmap entries and to create the physical files */
      private Prototype prototype;
  
      public PrototypeEntryCommandSearch(String[] searchPaths) {
          super(CommandType.SEARCH);
          this.searchPaths = searchPaths;
      }
  
      @Override
      protected String getCommandLinePart() {
          StringBuffer sb = new StringBuffer();
  
          for (int i = 0; i < searchPaths.length; i++) {
              sb.append(searchPaths[i]);
  
              if(i<searchPaths.length-1) {
                  sb.append(" ");
              }
          }
          return sb.toString();
      }
  
      public List<PkgMapEntry> createPkgMapEntry(File targetDir, VariableResolver variableResolver) {
          try {
              Prototype prototype = getPrototype(variableResolver);
              // Create a temporary pkgmap java object for being able to return the pkgMapEntries
              PkgMap pkgMap = prototype.createPkgMap(targetDir);
              return pkgMap.getPkgMapEntries();
          } catch (IOException e) {
              throw new PackageException("Exception while building prototype entries for 'search' command. dir="+targetDir, e);
          }
      }
  
      public void create(File targetDir, VariableResolver variableResolver) throws IOException {
          log.debug("<Entering> create(File basedir)");
          try {
              Prototype prototype = getPrototype(variableResolver);
              prototype.createFiles(targetDir);
          } catch (IOException e) {
              throw new PackageException("Exception while building prototype entries for 'search' command. dir="+targetDir, e);
          }
      }
  
      List<File> getResolvedSearchPaths(VariableResolver variableResolver) throws FileNotFoundException {
          List<File> resultDirs = new ArrayList<File>();
          for (int i = 0; i < this.searchPaths.length; i++) {
              log.debug("Resolving search path '" + this.searchPaths[i] + "'...");
              File dir = super.resolveFile(this.searchPaths[i], variableResolver);
              log.debug("Resolved search path '" + this.searchPaths[i] + "' to '" + dir.getAbsolutePath() + "'.");
              resultDirs.add(dir);
          }
          return resultDirs;
      }
  
      /**
       * @param variableResolver
       * @return The prototype object which is lazily created if it was not created before.
       * @throws IOException
       */
      Prototype getPrototype(VariableResolver variableResolver) throws IOException {
          if(this.prototype == null) {
              log.debug("Will create the prototype lazily...");
              try {
                  List<File> searchPaths = getResolvedSearchPaths(variableResolver);
                 PrototypeBuilder prototypeBuilder = new PrototypeBuilder();
                 for (Iterator<File> iterator = searchPaths.iterator(); iterator.hasNext();) {
                     File file = iterator.next();
                     // As in the documentation for the "search" command, it will NOT recurse over subdirectories
                     prototypeBuilder.addDirectory(file, false);
                 }
                 this.prototype = prototypeBuilder.getPrototype();
                 // Inherit all variables from parent prototype to child prototype. From the specs of "param=value" (=variables):
                 // "Places the indicated parameter in the current environment. Spans to subsequent included prototype files."
                 this.prototype.setVariableMap((VariableMap)variableResolver);
             } catch (FileNotFoundException e) {
                 throw new PackageException("Problem while resolving the search paths " + this.getLine() + ".", e);
             }
         }
         return this.prototype;
     }
 
     @Override
     public String toString()
     {
         StringBuffer sb = new StringBuffer();
         sb.append(super.toString());
         sb.append(this.getClass().getName()).append("[");
         sb.append("searchPaths=").append(this.searchPaths);
         sb.append("]");
         return sb.toString();
     }
 }