/**
    * Copyright 2004-2012 The Kuali Foundation
    *
    * Licensed under the Educational Community 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.opensource.org/licenses/ecl2.php
    *
   * 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.torque.mojo;
  
  import static org.apache.commons.io.FileUtils.forceMkdir;
  
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.List;
  
  import org.apache.maven.plugin.MojoExecutionException;
  import org.apache.torque.mojo.morph.DataMorpher;
  import org.apache.torque.mojo.morph.MorphRequest;
  import org.apache.torque.mojo.morph.Morpher;
  import org.codehaus.plexus.util.DirectoryScanner;
  import org.codehaus.plexus.util.StringUtils;
  import org.kuali.core.db.torque.PrettyPrint;
  import org.kuali.core.db.torque.Utils;
  
  /**
   * Converts Ant impex data XML files into maven-impex-plugin data XML files
   *
   * @goal morphdata
   * @phase generate-sources
   */
  public class MorphDataMojo extends BaseMojo {
      Utils utils = new Utils();
  
      /**
       * The directory in which the morphed XML will be generated.
       *
       * @parameter expression="${newDataOutputDir}" default-value="${project.build.directory}/generated-impex/xml"
       * @required
       */
      private File newDataOutputDir;
  
      /**
       * The directory containing the source (non-morphed) data XML files
       *
       * @parameter expression="${oldDataXMLDir}" default-value="${basedir}/src/main/impex"
       * @required
       */
      private File oldDataXMLDir;
  
      /**
       * The default set of files in that directory to include (ant style notation)
       *
       * @parameter expression="${oldDataXMLIncludes}" default-value="*.xml"
       * @required
       */
      private String oldDataXMLIncludes;
  
      /**
       * The default set of files in that directory to exclude (ant style notation)
       *
       * @parameter expression="${oldDataXMLExcludes}" default-value="schema.xml"
       */
      private String oldDataXMLExcludes;
  
      /**
       * Use our configuration to determine the list of files we need to convert
       */
      protected String[] getOldFiles() throws IOException {
          DirectoryScanner ds = new DirectoryScanner();
          ds.setIncludes(new String[] { getOldDataXMLIncludes() });
          if (getOldDataXMLExcludes() != null) {
              ds.setExcludes(new String[] { getOldDataXMLExcludes() });
          }
          ds.setBasedir(getOldDataXMLDir());
          ds.scan();
          return ds.getIncludedFiles();
      }
  
      protected boolean isMorphNeeded(final File oldFile, final File newFile) {
          if (!newFile.exists()) {
              return true;
          }
  
          long lastModifiedOld = oldFile.lastModified();
          long lastModifiedNew = newFile.lastModified();
          return lastModifiedOld > lastModifiedNew;
      }
  
     protected List<MorphRequest> getMorphRequests(final String[] oldFiles) throws IOException {
         String inputPath = getOldDataXMLDir().getAbsolutePath();
         String outputPath = getNewDataOutputDir().getAbsolutePath();
         forceMkdir(getNewDataOutputDir());
         List<MorphRequest> requests = new ArrayList<MorphRequest>();
         for (String oldFilename : oldFiles) {
             String oldFilePath = inputPath + FS + oldFilename;
             String newFilePath = outputPath + FS + oldFilename;
             File oldFile = new File(oldFilePath);
             File newFile = new File(newFilePath);
             if (!isMorphNeeded(oldFile, newFile)) {
                 getLog().debug("Skipping morph on " + oldFilename);
                 continue;
             }
             MorphRequest request = new MorphRequest();
             request.setEncoding(getEncoding());
             request.setName(oldFile.getName());
             request.setInputStream(new FileInputStream(oldFile));
             request.setOutputStream(new FileOutputStream(newFile));
             requests.add(request);
         }
         return requests;
     }
 
     protected void showConfig() {
         getLog().info(StringUtils.repeat("-", utils.getDefaultPrintableConsoleWidth() - 7));
         getLog().info("   From: " + oldDataXMLDir.getAbsolutePath());
         getLog().info("     To: " + newDataOutputDir.getAbsolutePath());
         getLog().info("Include: " + oldDataXMLIncludes);
         getLog().info("Exclude: " + oldDataXMLExcludes);
     }
 
     @Override
     protected void executeMojo() throws MojoExecutionException {
         try {
             showConfig();
             String[] oldFiles = getOldFiles();
             PrettyPrint pp = new PrettyPrint("[INFO] Converting " + oldFiles.length + " data XML files");
             utils.left(pp);
             List<MorphRequest> requests = getMorphRequests(oldFiles);
             for (MorphRequest request : requests) {
                 Morpher morpher = new DataMorpher(request, getProject().getArtifactId());
                 morpher.executeMorph();
             }
             utils.right(pp);
             int skipCount = oldFiles.length - requests.size();
             if (skipCount > 0) {
                 getLog().info("Skipped " + skipCount + " files that were unchanged.");
             }
         } catch (IOException e) {
             throw new MojoExecutionException("Unexpected error", e);
         }
     }
 
     public File getNewDataOutputDir() {
         return newDataOutputDir;
     }
 
     public void setNewDataOutputDir(final File newDataOutputDir) {
         this.newDataOutputDir = newDataOutputDir;
     }
 
     public File getOldDataXMLDir() {
         return oldDataXMLDir;
     }
 
     public void setOldDataXMLDir(final File oldDataXMLDir) {
         this.oldDataXMLDir = oldDataXMLDir;
     }
 
     public String getOldDataXMLIncludes() {
         return oldDataXMLIncludes;
     }
 
     public void setOldDataXMLIncludes(final String oldDataXMLIncludes) {
         this.oldDataXMLIncludes = oldDataXMLIncludes;
     }
 
     public String getOldDataXMLExcludes() {
         return oldDataXMLExcludes;
     }
 
     public void setOldDataXMLExcludes(final String oldDataXMLExcludes) {
         this.oldDataXMLExcludes = oldDataXMLExcludes;
     }
 }