package org.apache.torque.mojo;
   
   import java.io.File;
   import java.io.FileInputStream;
   import java.io.IOException;
   import java.io.InputStream;
   import java.io.OutputStream;
   import java.util.HashSet;
   import java.util.List;
  import java.util.Properties;
  import java.util.Set;
  import java.util.TreeSet;
  
  import org.apache.commons.io.FileUtils;
  import org.apache.commons.io.IOUtils;
  import org.apache.maven.plugin.MojoExecutionException;
  import org.apache.maven.plugin.MojoFailureException;
  import org.apache.tools.ant.DirectoryScanner;
  import org.apache.torque.engine.database.model.Database;
  import org.apache.torque.engine.database.model.Table;
  import org.kuali.core.db.torque.SetUtils;
  import org.kuali.core.db.torque.Utils;
  
  /**
   * This mojo identifies data files that are present on the file system but are not present in schema.xml. This can
   * happen if a table is removed from the schema.
   * 
   * It sets a project property called "impex.data.invalid". This property is a comma delimited list of filenames that
   * have no match in the db schema.
   * 
   * If it finds any invalid files it will also set the project property "impex.found.invalid=true"
   * 
   * @goal id-invalid-data-files
   */
  public class IdentifyInvalidDataFiles extends BaseMojo {
      private static final String FS = System.getProperty("file.separator");
  
      /**
       * @parameter expression="${extension}" default-value=".xml"
       * @required
       */
      private String extension;
  
      /**
       * @parameter expression="${dataDir}" default-value="${project.basedir}/src/main/impex"
       * @required
       */
      private File dataDir;
  
      /**
       * @parameter expression="${dataDirIncludes}" default-value="*.xml"
       */
      private String dataDirIncludes;
  
      /**
       * @parameter expression="${dataDirExcludes}" default-value="schema.xml"
       */
      private String dataDirExcludes;
  
      /**
       * @parameter expression="${schemaXMLFile}" default-value="src/main/impex/schema.xml"
       */
      private String schemaXMLFile;
  
      /**
       * @parameter expression="${targetDatabase}" default-value="oracle"
       */
      private String targetDatabase;
  
      /**
       * Any invalid files are listed in this file. One file per line
       * 
       * @parameter expression="${impex.markedForRemoval}" default-value="${project.build.directory}/impex/invalid.txt"
       */
      private File markedForRemoval;
  
      protected Set<File> getExportedFiles() throws MojoExecutionException {
          String filename = getProject().getBuild().getDirectory() + "/impex/exported-tables.txt";
          File file = new File(filename);
          if (!file.exists()) {
              getLog().warn("Could not locate " + file.getAbsolutePath());
              return new HashSet<File>();
          }
          List<String> tablenames = getContents(file);
          return getExportedFiles(tablenames);
      }
  
      protected Set<File> getExportedFiles(List<String> tablenames) {
          Set<File> files = new TreeSet<File>();
          for (String tablename : tablenames) {
              String filename = dataDir.getAbsolutePath() + FS + tablename + extension;
              File file = new File(filename);
              files.add(file);
          }
          return files;
      }
  
      @SuppressWarnings("unchecked")
      protected List<String> getContents(File file) throws MojoExecutionException {
         InputStream in = null;
         try {
             in = new FileInputStream(file);
             return IOUtils.readLines(in);
         } catch (IOException e) {
             throw new MojoExecutionException("Unexpected error", e);
         } finally {
             IOUtils.closeQuietly(in);
         }
     }
 
     @Override
     protected void executeMojo() throws MojoExecutionException, MojoFailureException {
         Utils utils = new Utils();
         try {
             getLog().info("Examining " + dataDir.getAbsolutePath());
             Database db = utils.getDatabase(schemaXMLFile, targetDatabase);
             DirectoryScanner ds = getDirectoryScanner();
             Set<File> existing = getExistingFiles(ds);
             Set<File> exported = getExportedFiles();
             Set<File> allowed = getDatabaseFiles(db);
             if (exported.size() > 0) {
                 allowed = exported;
             }
             Set<File> invalid = SetUtils.difference(existing, allowed);
             getLog().info(existing.size() + " data files currently exist");
             getLog().info(invalid.size() + " of those are invalid");
             StringBuilder sb = new StringBuilder();
             int count = 0;
             StringBuilder invalidFiles = new StringBuilder();
             for (File file : invalid) {
                 if (count != 0) {
                     sb.append(",");
                 }
                 sb.append("**/src/main/impex/" + file.getName());
                 invalidFiles.append(file.getCanonicalPath() + "\n");
                 getLog().info("Marked for removal: " + file.getName());
                 count++;
             }
             Properties properties = getProject().getProperties();
             properties.setProperty("impex.data.invalid", sb.toString());
             if (count > 0) {
                 properties.setProperty("impex.found.invalid", Boolean.TRUE.toString());
                 createFile(markedForRemoval, invalidFiles.toString());
             }
         } catch (Exception e) {
             throw new MojoExecutionException("Error executing mojo", e);
         }
     }
 
     protected void createFile(File file, String contents) throws IOException {
         OutputStream out = null;
         try {
             out = FileUtils.openOutputStream(file);
             IOUtils.write(contents, out);
         } finally {
             IOUtils.closeQuietly(out);
         }
     }
 
     protected Set<File> getDatabaseFiles(Database db) {
         List<?> tables = db.getTables();
         Set<File> files = new TreeSet<File>();
         for (Object object : tables) {
             Table table = (Table) object;
             String tableName = table.getName();
             String filename = dataDir.getAbsolutePath() + FS + tableName + extension;
             File file = new File(filename);
             files.add(file);
         }
         return files;
     }
 
     protected Set<File> getExistingFiles(DirectoryScanner ds) {
         ds.scan();
         String[] relativeFilenames = ds.getIncludedFiles();
         Set<File> files = new TreeSet<File>();
         for (int i = 0; i < relativeFilenames.length; i++) {
             String filename = ds.getBasedir().getAbsolutePath() + FS + relativeFilenames[i];
             File file = new File(filename);
             files.add(file);
         }
         return files;
     }
 
     protected DirectoryScanner getDirectoryScanner() {
         DirectoryScanner ds = new DirectoryScanner();
         ds.setBasedir(dataDir);
         ds.setIncludes(new String[] { dataDirIncludes });
         ds.setExcludes(new String[] { dataDirExcludes });
         return ds;
     }
 
     protected File getFile(Table table) {
         String tableName = table.getName();
         String filename = dataDir.getAbsolutePath() + FS + tableName + extension;
         File file = new File(filename);
         return file;
     }
 
     public File getDataDir() {
         return dataDir;
     }
 
     public void setDataDir(File dataDir) {
         this.dataDir = dataDir;
     }
 
     public String getDataDirIncludes() {
         return dataDirIncludes;
     }
 
     public void setDataDirIncludes(String dataDirIncludes) {
         this.dataDirIncludes = dataDirIncludes;
     }
 
     public String getDataDirExcludes() {
         return dataDirExcludes;
     }
 
     public void setDataDirExcludes(String dataDirExcludes) {
         this.dataDirExcludes = dataDirExcludes;
     }
 
     public String getSchemaXMLFile() {
         return schemaXMLFile;
     }
 
     public void setSchemaXMLFile(String schemaXMLFile) {
         this.schemaXMLFile = schemaXMLFile;
     }
 
     public String getExtension() {
         return extension;
     }
 
     public void setExtension(String extension) {
         this.extension = extension;
     }
 
     public String getTargetDatabase() {
         return targetDatabase;
     }
 
     public void setTargetDatabase(String targetDatabase) {
         this.targetDatabase = targetDatabase;
     }
 
     public File getMarkedForRemoval() {
         return markedForRemoval;
     }
 
     public void setMarkedForRemoval(File markedForRemoval) {
         this.markedForRemoval = markedForRemoval;
     }
 
 }