package net.sf.stitch.crud;
   
   /*
    * Copyright 2007
    *
    * 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.
   */
  
  import groovy.text.SimpleTemplateEngine;
  import groovy.text.Template;
  import groovy.text.TemplateEngine;
  
  import java.io.File;
  import java.io.FileWriter;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.io.Reader;
  import java.io.Writer;
  import java.util.ArrayList;
  import java.util.LinkedHashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Properties;
  
  import org.apache.maven.plugin.AbstractMojo;
  import org.apache.maven.plugin.MojoExecutionException;
  
  /**
   * Generates a CRUD interface for Entity Beans.
   *
   * @goal crud
   * @phase process-classes
   */
  public class CrudMojo extends AbstractMojo
  {
      /**
       * Location of the file.
       * @parameter expression="${project.build.directory}/${project.build.finalName}"
       * @required
       */
      private File outputDirectory;
      
      /**
       * List of Entity Classes.
       * @parameter
       * @required
       */
      private String [] entityClasses;
      
      /**
       * User defined Template Properties.  Additional information passed to templates.
       * @parameter
       */
      private Properties userProperties;
  
      /**
       * Template location.  Users may override the default templates to get a customized look and feel.  
       * @parameter default-value="net/sf/stitch/crud/templates/"
       */
      private String templateLocation;
  
      /**
       * Creates a basic CRUD interface for the specified entity classes.
       */
      public void execute() throws MojoExecutionException
      {
          getLog().info("CrudMojo.execute");
  
          //  Validate that the output directory exists...
          assert null != this.outputDirectory;
          if (!this.outputDirectory.exists())
          {
              this.outputDirectory.mkdirs();
          }
  
          //  Validate that the entity classes exist...
          final List<CrudEntity> entityClassList = new ArrayList<CrudEntity>(entityClasses.length);
          for (final String className : this.entityClasses)
          {
              getLog().debug("Loading class: " + className);
              try
              {
                  final CrudEntity entityClass = new CrudEntity(className);
                  entityClassList.add(entityClass);
              }
              catch (ClassNotFoundException e)
              {
                  throw new MojoExecutionException ("Unable to load class: " + className, e);
             }
         }
 
         try
         {
             generate(entityClassList);
         }
         catch (Exception e)
         {
             throw new MojoExecutionException ("Problem generating CRUD!", e);
         }
     }
 
     public void generate (final List<CrudEntity> entityClassList)
         throws IOException, ClassNotFoundException
     {
         assert null != outputDirectory && outputDirectory.isDirectory();
 
         final String [] templateSourceFiles =
         {
             "Entity.page.xml",
             "Entity.xhtml",
             "EntityEdit.page.xml",
             "EntityEdit.xhtml",
             "EntityList.page.xml",
             "EntityList.xhtml",
         };
 
         final TemplateEngine engine = new SimpleTemplateEngine();
 
         //  Load each source file into a template...
         final Map<String, Template> templateMap = new LinkedHashMap<String,Template>(templateSourceFiles.length);
         for (final String templateSourceFile : templateSourceFiles)
         {
             getLog().debug("Parsing template source: " + templateSourceFile);
 
             final InputStream templateStream = getClass().getClassLoader().getResourceAsStream(this.templateLocation + templateSourceFile);
             assert null != templateStream;
             final Reader templateReader = new InputStreamReader( templateStream );
             final Template template = engine.createTemplate( templateReader );
             templateMap.put(templateSourceFile, template);
             templateReader.close();
         }
 
         //  Process each template for each entity class...
         for (final CrudEntity entityClass : entityClassList)
         {
             getLog().info("Creating CRUD interface for: " + entityClass.getEntityShortName());
 
             final Map<String,Object> templateParameters = new LinkedHashMap<String,Object>();
             templateParameters.put("crudEntity", entityClass);
             templateParameters.put("userProperties", this.userProperties);
 
             for (final Map.Entry<String, Template> templateEntry : templateMap.entrySet())
             {
                 final String filename = templateEntry.getKey().replace("Entity", entityClass.getEntityShortName());
                 final Template template = templateEntry.getValue();
                 final File outputFile = new File(outputDirectory, filename);
                 final Writer outputFileWriter = new FileWriter (outputFile);
                 try
                 {
                     getLog().debug("Making " + outputFile.getPath());
                     template.make(templateParameters).writeTo(outputFileWriter);
                 }
                 finally
                 {
                     outputFileWriter.close();
                 }
             }
         }
     }
 }