/**
    *
    */
   package pt.digitalis.maven.ormgenerator;
   
   import java.io.BufferedReader;
   import java.io.BufferedWriter;
   import java.io.File;
   import java.io.FileInputStream;
  import java.io.FileNotFoundException;
  import java.io.FileReader;
  import java.io.FileWriter;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.Writer;
  import java.util.Date;
  import java.util.HashMap;
  import java.util.Map;
  import java.util.Properties;
  
  import javax.xml.parsers.SAXParserFactory;
  
  import org.apache.maven.plugin.logging.Log;
  
  import pt.digitalis.maven.ormgenerator.utils.FileUtils;
  import pt.digitalis.maven.ormgenerator.utils.FreemarkerExecutor;
  import freemarker.template.TemplateException;
  
  /**
   * Creates the service code, and the IoC contributions for them
   *
   * @author Ant�nio Silva <a href="mailto:asilva@digitalis.pt">asilva@digitalis.pt</a>
   * @author Pedro Viegas <a href="mailto:pviegas@digitalis.pt">pviegas@digitalis.pt</a>
   * @created 2007/11/14
   */
  public class ServiceExecutor extends BaseExecutor {
  
      /** The name given to the model class */
      public static final String MODEL_MODULE_NAME = "DIFModelModule";
  
      /** The name given to the model class */
      public static final String MODULE_PROPERTIES_NAME = "modules";
  
      /** The name of the template for the service */
      public static final String SERVICE_TEMPLATE = "service.ftl";
  
      /** The name of the template for the service */
      public static final String SERVICE_IMPL_TEMPLATE = "serviceimpl.ftl";
  
      /** The name of the template for the service */
      public static final String SERVICE_DIRECTORY_TEMPLATE = "serviceDirectory.ftl";
  
      /** The name of the template for the service */
      public static final String SERVICE_DIRECTORY_IMPL_TEMPLATE = "serviceDirectoryImpl.ftl";
  
      /** The name of the template for the database */
      public static final String DATABASE_DIRECTORY_TEMPLATE = "databaseDirectory.ftl";
  
      /** The name of the template for the database */
      public static final String DATABASE_DIRECTORY_IMPL_TEMPLATE = "databaseDirectoryImpl.ftl";
  
      /** The name of the template for the service */
      public static final String MODULE_TEMPLATE = "module.ftl";
  
      /** The name of the template properties for the service */
      public static final String MODULE_PROPERTIES_TEMPLATE = "moduleProperties.ftl";
  
      /** The suffix given to the generated files */
      public static final String SERVICE_FILE_SUFFIX = "Service";
  
      /** The suffix given to the generated files */
      public static final String SERVICE_DIRECTORY_FILE_SUFFIX = "ServiceDirectory";
  
      /** The suffix given to the generated files */
      public static final String DATABASE_DIRECTORY_FILE = "Directory";
  
      /** Service data parsed from the XML. */
      private ServiceCfg serviceData = null;
  
      /** The service configuration file path. */
      private String serviceConfigurationFileName = null;
  
      /** The logger */
      private Log logger = null;
  
      /** The project files path */
      private String baseDir;
  
      /** The database name */
      private String dataSourceName;
  
      /** The project resource files path */
      private String resourcesPath;
  
      /** Multi instance mode */
      private Boolean multiInstance;
  
      /**
       * Class constructor instantiates the <code>ServiceExecutor</code> with the required initializations
      *
      * @param packageName
      *            The base package for the generated files
      * @param dataSourceName
      *            the database name
      * @param templateDir
      *            Path for the template directory, could be relative or absolute.
      * @param destinationDir
      *            directory where the generated files should be inserted.
      * @param baseCodeDIR
      *            the project base path
      * @param serviceConfigurationFileName
      *            Service configuration file name, this file should read from the resources
      * @param multiInstance
      *            Multi instance mode
      * @param logger
      *            the Maven Plugin logger
      */
     public ServiceExecutor(String packageName, String dataSourceName, String templateDir, String destinationDir,
             String baseCodeDIR, String serviceConfigurationFileName, Boolean multiInstance, Log logger) {
         super(packageName, templateDir, destinationDir);
         this.setServiceConfigurationFileName(serviceConfigurationFileName);
         this.setLogger(logger);
         this.multiInstance = multiInstance;
         this.baseDir = baseCodeDIR;
         this.dataSourceName = dataSourceName;
         this.resourcesPath = baseCodeDIR + "/src/main/resources";
     }
 
     /**
      * Reads the service configuration file and populates the ServiceCfg
      *
      */
     public void getServiceConfigurationData() {
         try {
             // Obtains the file to be read
             InputStream f = new FileInputStream(this.getServiceConfigurationFileName());
             ServiceHandler handler =
                     new ServiceHandler(obtainPath(this.getDestinationDir(), this.getPackageName() + DAO_PACKAGE));
             SAXParserFactory factory = SAXParserFactory.newInstance();
             factory.setValidating(false);
             javax.xml.parsers.SAXParser parser;
 
             // parses the XML
             parser = factory.newSAXParser();
             parser.parse(f, handler);
             this.setServiceData(handler.getServiceCfg());
 
         } catch (Exception e) {
             this.setServiceData(null);
             this.getLogger().error(e.getMessage(), e);
         }
     }
 
     /**
      * This method is responsible to generate all the files.
      *
      * @return Returns <code>true</code> if the generation process went well and <code>false</code> otherwise
      */
     public boolean execute() {
         boolean result = true;
 
         // Obtains the data from XML file
         this.getServiceConfigurationData();
 
         if (this.getServiceData() == null) {
             this.getLogger()
                     .error(
                             "The service executor process was unable to read the Service configuration file with the name "
                                     + this.getServiceConfigurationFileName()
                                     + ". Please check if the file is in the classpath");
             result = false;
 
         } else {
             // Configures the freemarker engine
             this.prepareExecutor(this.getDestinationDir());
             if (this.getFreemarkerConfig() == null) {
                 this
                         .getLogger()
                         .error(
                                 "The service executor process was unable to build the freemarker configuration. Please check if the template directory is in classpath  under the directory "
                                         + this.getTemplateDir());
                 result = false;
             } else {
                 // generates the files
                 result = this.generateServiceFiles(this.getDestinationDir());
             }
         }
         return result;
     }
 
     /**
      * Generates the files from the templates
      *
      * @param generatedDest
      *            generated file destination dir
      * @return The result is <code>true</code> if the files were correctly generated well and false otherwise
      */
     public boolean generateServiceFiles(String generatedDest) {
         // Get or create a template
         boolean result = false;
 
         try {
 
             String pathInterface = obtainPath(generatedDest, this.getPackageName());
             String pathImpl = obtainPath(generatedDest, this.getPackageName() + IMPL_PACKAGE_SUFFIX);
             String pathModuleDesc = obtainPath(this.resourcesPath, "");
 
             // Generate services
             for (Services service : this.getServiceData().getServices()) {
                 // Builds the data to be merged with the template
                 Map<String, Object> map = new HashMap<String, Object>();
                 map.put("packageName", this.getPackageName());
                 map.put("date", new Date());
                 map.put("service", service);
 
                 // Generates the interface
                 String path = getInterfacePath(pathInterface, service, SERVICE_FILE_SUFFIX);
                 FreemarkerExecutor.processFreemarker(this.getFreemarkerConfig(), map, SERVICE_TEMPLATE, path);
 
                 // Generate the implementation
                 path = getImplementationPath(pathImpl, service, SERVICE_FILE_SUFFIX);
                 FreemarkerExecutor.processFreemarker(this.getFreemarkerConfig(), map, SERVICE_IMPL_TEMPLATE, path);
             }
 
             if (multiInstance) {
                 // Generate service directories
                 for (Services service : this.getServiceData().getServices()) {
                     // Builds the data to be merged with the template
                     Map<String, Object> map = new HashMap<String, Object>();
                     map.put("packageName", this.getPackageName());
                     map.put("date", new Date());
                     map.put("service", service);
 
                     // Generates the interface
                     String path = getInterfacePath(pathInterface, service, SERVICE_DIRECTORY_FILE_SUFFIX);
                     FreemarkerExecutor.processFreemarker(this.getFreemarkerConfig(), map, SERVICE_DIRECTORY_TEMPLATE, path);
 
                     // Generate the implementation
                     path = getImplementationPath(pathImpl, service, SERVICE_DIRECTORY_FILE_SUFFIX);
                     FreemarkerExecutor.processFreemarker(this.getFreemarkerConfig(), map, SERVICE_DIRECTORY_IMPL_TEMPLATE, path);
                 }
 
                 // Generate database directory
                 Map<String, Object> map = new HashMap<String, Object>();
                 map.put("packageName", this.getPackageName());
                 map.put("datasource", dataSourceName);
                 map.put("date", new Date());
                 map.put("services", getServiceData().getServices());
 
                 // Generates the interface
                 String path = getInterfacePath(pathInterface, dataSourceName + DATABASE_DIRECTORY_FILE);
                 FreemarkerExecutor.processFreemarker(this.getFreemarkerConfig(), map, DATABASE_DIRECTORY_TEMPLATE, path);
 
                 // Generate the implementation
                 path = getImplementationPath(pathImpl, dataSourceName + DATABASE_DIRECTORY_FILE);
                 FreemarkerExecutor.processFreemarker(this.getFreemarkerConfig(), map, DATABASE_DIRECTORY_IMPL_TEMPLATE, path);
             }
 
             generateModuleTemplate(pathInterface);
             generateModulePropertiesTemplate(pathModuleDesc);
             updateHibernateConfigurationFile();
 
             result = true;
         } catch (IOException e) {
             this.getLogger().error(e.getMessage(), e);
         } catch (TemplateException e) {
             this.getLogger().error(e.getMessage(), e);
         }
         return result;
     }
 
     /**
      * Created the module descriptor file
      *
      * @param pathToDescriptor
      *            the path to where the file should be created
      * @throws IOException
      * @throws TemplateException
      */
     private void generateModulePropertiesTemplate(String pathToDescriptor) throws IOException, TemplateException {
 
         // Reads the existing file and it's modules
         String path = getModulePropertiesPath(pathToDescriptor);
         StringBuffer previousModules = new StringBuffer();
 
         try {
             Properties moduleFile = new Properties();
             moduleFile.load(new FileInputStream(path));
 
             String[] previousModulesArray = moduleFile.getProperty("modules").split(",");
 
             for (String moduleName : previousModulesArray) {
                 moduleName = moduleName.trim();
 
                 if (!moduleName.equals(this.getPackageName() + "." + MODEL_MODULE_NAME)) {
                     previousModules.append(moduleName);
                     previousModules.append(", ");
                 }
             }
         } catch (FileNotFoundException exception) {
             // Do nothing. If no file exists no previous modules exist for us to add. New clean file will be created
         }
 
         // Builds the data to be merged with the template
         Map<String, Object> map = new HashMap<String, Object>();
         map.put("packageName", this.getPackageName());
         map.put("modelClassName", MODEL_MODULE_NAME);
         map.put("previousModules", previousModules.toString());
         // Generate the implementation
         FreemarkerExecutor.processFreemarker(this.getFreemarkerConfig(), map, MODULE_PROPERTIES_TEMPLATE, path);
     }
 
     /**
      * @param prefix
      *            an indentation prefix to add to all generated lines
      * @return the mapping section of hibernate.cfg.xml
      */
     private String getMappings(String prefix) {
         String relativeDir = FileUtils.dotNotation2PathNotation(getPackageName() + ".data");
         relativeDir = relativeDir.replace("\\", "/");
         File hbms = new File(baseDir + "/src/main/resources/" + relativeDir);
         StringBuffer buffer = new StringBuffer();
 
         // If the directory data exists get the *.hbm.xml files
         if (hbms.exists() && hbms.isDirectory()) {
             for (File file : hbms.listFiles()) {
                 if (file.isDirectory()) {
                     for (File innerFile : file.listFiles()) {
                         if (innerFile.getName().contains(".hbm.xml")) {
                             buffer.append(prefix + "<mapping resource=\"" + relativeDir + "/" + file.getName() + "/"
                                     + innerFile.getName() + "\"/>\n");
                         }
                     }
                 } else if (file.getName().contains(".hbm.xml")) {
                     buffer.append(prefix + "<mapping resource=\"" + relativeDir + "/" + file.getName() + "\"/>\n");
                 }
             }
         }
 
         return buffer.toString();
     }
 
     /**
      * @param line
      *            the line to infer the indentation
      * @return an indentation set of white spaces
      */
     private String getPrefixIdentation(String line) {
         StringBuffer prefix = new StringBuffer("");
         int i = 0;
         boolean more = true;
 
         while (more) {
             if (line.charAt(i) == ' ')
                 prefix.append(' ');
             else if (line.charAt(i) == '\t')
                 prefix.append("    ");
             else
                 more = false;
 
             i++;
         }
 
         return prefix.toString();
     }
 
     /**
      * Updates the projects existing hibernate configuration file with all mappings
      */
     private void updateHibernateConfigurationFile() {
         String pathToFile = resourcesPath + File.separator + dataSourceName + ".cfg.xml";
         File cfg = new File(pathToFile);
 
         StringBuffer contents = new StringBuffer();
         BufferedReader input = null;
         try {
             input = new BufferedReader(new FileReader(cfg));
             String line = null;
             boolean hasWrittenMappings = false;
             boolean noLineSeparator = false;
 
             while ((line = input.readLine()) != null) {
                 noLineSeparator = false;
 
                 if (line.contains("<mapping resource")) {
                     if (hasWrittenMappings)
                         // Ignores the current line.
                         line = null;
                     else {
                         line = getMappings(getPrefixIdentation(line));
                         hasWrittenMappings = true;
                         noLineSeparator = true;
                     }
                 }
 
                 if (!hasWrittenMappings && (line != null) && line.contains("</session-factory>")) {
                     line = getMappings("    " + getPrefixIdentation(line)) + line;
                     hasWrittenMappings = true;
                 }
 
                 if (line != null) {
                     contents.append(line);
                     if (!noLineSeparator)
                         contents.append(System.getProperty("line.separator"));
                 }
             }
 
         } catch (IOException ex) {
             contents = null;
             ex.printStackTrace();
 
         } finally {
             try {
                 if (input != null)
                     input.close();
             } catch (IOException ex) {
                 ex.printStackTrace();
             }
         }
 
         // Not null. file exists and context parsed/updated
         if (contents != null) {
             Writer output = null;
 
             try {
                 output = new BufferedWriter(new FileWriter(cfg));
                 output.write(contents.toString());
 
             } catch (IOException ex) {
                 ex.printStackTrace();
             } finally {
                 try {
                     if (output != null)
                         output.close();
 
                 } catch (IOException ex) {
                     ex.printStackTrace();
                 }
             }
         }
     }
 
     /**
      * @param pathInterface
      * @throws IOException
      * @throws TemplateException
      */
     private void generateModuleTemplate(String pathInterface) throws IOException, TemplateException {
         // Builds the data to be merged with the template
         Map<String, Object> map = new HashMap<String, Object>();
         map.put("packageName", this.getPackageName());
         map.put("date", new Date());
         map.put("modelClassName", MODEL_MODULE_NAME);
         map.put("serviceCfg", this.getServiceData());
         // Generate the implementation
         String path = getModulePath(pathInterface);
         FreemarkerExecutor.processFreemarker(this.getFreemarkerConfig(), map, MODULE_TEMPLATE, path);
     }
 
     /**
      * Creates the path for the interface files
      *
      * @param pathInterface
      *            The base file path for the interface
      * @param service
      * @param sufix
      * @return The interface file path
      */
     private String getInterfacePath(String pathInterface, Services service, String sufix) {
         String path = pathInterface + File.separator + "I" + service.getName() + sufix + JAVA_EXTENSION;
         return path;
     }
 
     /**
      * Creates the path for the implementation files
      *
      * @param pathImpl
      *            The base file path for the interface
      * @param service
      *            service name
      * @param sufix
      * @return The implementation file path
      */
     private String getImplementationPath(String pathImpl, Services service, String sufix) {
         String path;
         path = pathImpl + File.separator + service.getName() + sufix + IMPL_FILE_SUFFIX + JAVA_EXTENSION;
         return path;
     }
 
     /**
      * Creates the path for the interface files
      *
      * @param pathInterface
      *            The base file path for the interface
      * @param sufix
      * @return The interface file path
      */
     private String getInterfacePath(String pathInterface, String sufix) {
         String path = pathInterface + File.separator + "I" + sufix + JAVA_EXTENSION;
         return path;
     }
 
     /**
      * Creates the path for the implementation files
      *
      * @param pathImpl
      *            The base file path for the interface
      * @param sufix
      * @return The implementation file path
      */
     private String getImplementationPath(String pathImpl, String sufix) {
         String path;
         path = pathImpl + File.separator + sufix + IMPL_FILE_SUFFIX + JAVA_EXTENSION;
         return path;
     }
 
     /**
      * Creates the path for the implementation files
      *
      * @param pathImpl
      *            The base file path for the interface
      * @return The implementation file path
      */
     private String getModulePath(String pathImpl) {
         String path;
         path = pathImpl + File.separator + MODEL_MODULE_NAME + JAVA_EXTENSION;
         return path;
     }
 
     /**
      * Creates the path for the implementation files
      *
      * @param pathImpl
      *            The base file path for the interface
      * @return The implementation file path
      */
     private String getModulePropertiesPath(String pathImpl) {
         String path;
         path = pathImpl + File.separator + MODULE_PROPERTIES_NAME + PROPERTIES_EXTENSION;
         return path;
     }
 
     /**
      * @return the serviceData
      */
     public ServiceCfg getServiceData() {
         return serviceData;
     }
 
     /**
      * @param serviceData
      *            the serviceData to set
      */
     private void setServiceData(ServiceCfg serviceData) {
         this.serviceData = serviceData;
     }
 
     /**
      * @return the serviceConfigurationFileName
      */
     private String getServiceConfigurationFileName() {
         return serviceConfigurationFileName;
     }
 
     /**
      * @param serviceConfigurationFilePath
      *            the serviceConfigurationFileName to set
      */
     private void setServiceConfigurationFileName(String serviceConfigurationFilePath) {
         this.serviceConfigurationFileName = serviceConfigurationFilePath;
     }
 
     /**
      * @return the logger
      */
     private Log getLogger() {
         return logger;
     }
 
     /**
      * @param logger
      *            the logger to set
      */
     private void setLogger(Log logger) {
         this.logger = logger;
     }
 }