package de.juplo.plugins.hibernate;
   
   
   import com.pyx4j.log4j.MavenLogAppender;
   import java.io.File;
   import java.io.FileInputStream;
   import java.io.FileOutputStream;
   import java.io.IOException;
   import java.io.InputStream;
  import java.net.MalformedURLException;
  import java.net.URL;
  import java.security.NoSuchAlgorithmException;
  import java.time.ZonedDateTime;
  import java.util.Collections;
  import java.util.EnumSet;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.LinkedHashSet;
  import java.util.List;
  import java.util.Map;
  import java.util.Map.Entry;
  import java.util.Properties;
  import java.util.Set;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  import javax.persistence.Embeddable;
  import javax.persistence.Entity;
  import javax.persistence.MappedSuperclass;
  import javax.persistence.spi.PersistenceUnitTransactionType;
  import org.apache.maven.artifact.Artifact;
  import org.apache.maven.model.Resource;
  import org.apache.maven.plugin.AbstractMojo;
  import org.apache.maven.plugin.MojoExecutionException;
  import org.apache.maven.plugin.MojoFailureException;
  import org.apache.maven.project.MavenProject;
  import org.hibernate.boot.MetadataBuilder;
  import org.hibernate.boot.MetadataSources;
  import org.hibernate.boot.cfgxml.internal.ConfigLoader;
  import org.hibernate.boot.cfgxml.spi.LoadedConfig;
  import org.hibernate.boot.cfgxml.spi.MappingReference;
  import org.hibernate.boot.model.naming.ImplicitNamingStrategy;
  import org.hibernate.boot.model.naming.PhysicalNamingStrategy;
  import org.hibernate.boot.registry.BootstrapServiceRegistry;
  import org.hibernate.boot.registry.BootstrapServiceRegistryBuilder;
  import org.hibernate.boot.registry.StandardServiceRegistry;
  import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
  import org.hibernate.boot.registry.classloading.spi.ClassLoaderService;
  import org.hibernate.boot.registry.classloading.spi.ClassLoadingException;
  import org.hibernate.boot.registry.selector.spi.StrategySelector;
  import org.hibernate.boot.spi.MetadataImplementor;
  import org.hibernate.cfg.AvailableSettings;
  import static org.hibernate.cfg.AvailableSettings.DIALECT;
  import static org.hibernate.cfg.AvailableSettings.DRIVER;
  import static org.hibernate.cfg.AvailableSettings.FORMAT_SQL;
  import static org.hibernate.cfg.AvailableSettings.HBM2DDL_DELIMITER;
  import static org.hibernate.cfg.AvailableSettings.HBM2DLL_CREATE_NAMESPACES;
  import static org.hibernate.cfg.AvailableSettings.IMPLICIT_NAMING_STRATEGY;
  import static org.hibernate.cfg.AvailableSettings.JPA_JDBC_DRIVER;
  import static org.hibernate.cfg.AvailableSettings.JPA_JDBC_PASSWORD;
  import static org.hibernate.cfg.AvailableSettings.JPA_JDBC_URL;
  import static org.hibernate.cfg.AvailableSettings.JPA_JDBC_USER;
  import static org.hibernate.cfg.AvailableSettings.PASS;
  import static org.hibernate.cfg.AvailableSettings.PHYSICAL_NAMING_STRATEGY;
  import static org.hibernate.cfg.AvailableSettings.SHOW_SQL;
  import static org.hibernate.cfg.AvailableSettings.USER;
  import static org.hibernate.cfg.AvailableSettings.URL;
  import org.hibernate.engine.config.spi.ConfigurationService;
  import org.hibernate.engine.jdbc.connections.spi.ConnectionProvider;
  import org.hibernate.internal.util.config.ConfigurationException;
  import org.hibernate.jpa.boot.internal.ParsedPersistenceXmlDescriptor;
  import org.hibernate.jpa.boot.internal.PersistenceXmlParser;
  import org.hibernate.tool.schema.TargetType;
  import org.hibernate.tool.schema.internal.ExceptionHandlerCollectingImpl;
  import org.hibernate.tool.schema.internal.exec.ScriptTargetOutputToFile;
  import org.hibernate.tool.schema.spi.ExecutionOptions;
  import org.hibernate.tool.schema.spi.SchemaManagementToolCoordinator;
  import org.hibernate.tool.schema.spi.ScriptTargetOutput;
  import org.hibernate.tool.schema.spi.TargetDescriptor;
  import org.scannotation.AnnotationDB;
  
  
  /**
   * Baseclass with common attributes and methods.
   *
   * @phase process-classes
   * @threadSafe
   * @requiresDependencyResolution runtime
   */
  public abstract class AbstractSchemaMojo extends AbstractMojo
  {
    public final static String EXECUTE = "hibernate.schema.execute";
    public final static String OUTPUTDIRECTORY = "project.build.outputDirectory";
    public final static String SCAN_CLASSES = "hibernate.schema.scan.classes";
    public final static String SCAN_DEPENDENCIES = "hibernate.schema.scan.dependencies";
    public final static String SCAN_TESTCLASSES = "hibernate.schema.scan.test_classes";
    public final static String TEST_OUTPUTDIRECTORY = "project.build.testOutputDirectory";
    public final static String SKIPPED = "hibernate.schema.skipped";
    public final static String SCRIPT = "hibernate.schema.script";
 
   private final static Pattern SPLIT = Pattern.compile("[^,\\s]+");
 
   private final Set<String> packages = new HashSet<String>();
 
 
   /**
    * The maven project.
    * <p>
    * Only needed internally.
    *
    * @parameter property="project"
    * @required
    * @readonly
    */
   private MavenProject project;
 
   /**
    * Build-directory.
    * <p>
    * Only needed internally.
    *
    * @parameter property="project.build.directory"
    * @required
    * @readonly
    */
   private String buildDirectory;
 
 
   /** Parameters to configure the genaration of the SQL *********************/
 
   /**
    * Excecute the generated SQL.
    * If set to <code>false</code>, only the SQL-script is created and the
    * database is not touched.
    * <p>
    * <strong>Important:</strong>
    * This configuration value can only be configured through the
    * <code>pom.xml</code>, or by the definition of a system-property, because
    * it is not known by Hibernate nor JPA and, hence, not picked up from
    * their configuration!
    *
    * @parameter property="hibernate.schema.execute" default-value="true"
    * @since 2.0
    */
   private Boolean execute;
 
   /**
    * Skip execution
    * <p>
    * If set to <code>true</code>, the execution is skipped.
    * <p>
    * A skipped execution is signaled via the maven-property
    * <code>${hibernate.schema.skipped}</code>.
    * <p>
    * The execution is skipped automatically, if no modified or newly added
    * annotated classes are found and the dialect was not changed.
    * <p>
    * <strong>Important:</strong>
    * This configuration value can only be configured through the
    * <code>pom.xml</code>, or by the definition of a system-property, because
    * it is not known by Hibernate nor JPA and, hence, not picked up from
    * their configuration!
    *
    * @parameter property="hibernate.schema.skip" default-value="${maven.test.skip}"
    * @since 1.0
    */
   private boolean skip;
 
   /**
    * Force generation/execution
    * <p>
    * Force the generation and (if configured) the execution of the SQL, even if
    * no modified or newly added annotated classes where found and the
    * configuration was not changed.
    * <p>
    * <code>skip</code> takes precedence over <code>force</code>.
    * <p>
    * <strong>Important:</strong>
    * This configuration value can only be configured through the
    * <code>pom.xml</code>, or by the definition of a system-property, because
    * it is not known by Hibernate nor JPA and, hence, not picked up from
    * their configuration!
    *
    * @parameter property="hibernate.schema.force" default-value="false"
    * @since 1.0
    */
   private boolean force;
 
   /**
    * Hibernate dialect.
    *
    * @parameter property="hibernate.dialect"
    * @since 1.0
    */
   private String dialect;
 
   /**
    * Delimiter in output-file.
    * <p>
    * <strong>Important:</strong>
    * This configuration value can only be configured through the
    * <code>pom.xml</code>, or by the definition of a system-property, because
    * it is not known by Hibernate nor JPA and, hence, not picked up from
    * their configuration!
    *
    * @parameter property="hibernate.hbm2ddl.delimiter" default-value=";"
    * @since 1.0
    */
   private String delimiter;
 
   /**
    * Show the generated SQL in the command-line output.
    *
    * @parameter property="hibernate.show_sql"
    * @since 1.0
    */
   private Boolean show;
 
   /**
    * Format output-file.
    *
    * @parameter property="hibernate.format_sql"
    * @since 1.0
    */
   private Boolean format;
 
   /**
    * Specifies whether to automatically create also the database schema/catalog.
    *
    * @parameter property="hibernate.hbm2dll.create_namespaces" default-value="false"
    * @since 2.0
    */
   private Boolean createNamespaces;
 
   /**
    * Implicit naming strategy
    *
    * @parameter property="hibernate.implicit_naming_strategy"
    * @since 2.0
    */
   private String implicitNamingStrategy;
 
   /**
    * Physical naming strategy
    *
    * @parameter property="hibernate.physical_naming_strategy"
    * @since 2.0
    */
   private String physicalNamingStrategy;
 
   /**
    * Wether the project should be scanned for annotated-classes, or not
    * <p>
    * This parameter is intended to allow overwriting of the parameter
    * <code>exclude-unlisted-classes</code> of a <code>persistence-unit</code>.
    * If not specified, it defaults to <code>true</code>
    *
    * @parameter property="hibernate.schema.scan.classes"
    * @since 2.0
    */
   private Boolean scanClasses;
 
   /**
    * Classes-Directory to scan.
    * <p>
    * This parameter defaults to the maven build-output-directory for classes.
    * Additionally, all dependencies are scanned for annotated classes.
    * <p>
    * <strong>Important:</strong>
    * This configuration value can only be configured through the
    * <code>pom.xml</code>, or by the definition of a system-property, because
    * it is not known by Hibernate nor JPA and, hence, not picked up from
    * their configuration!
    *
    * @parameter property="project.build.outputDirectory"
    * @since 1.0
    */
   private String outputDirectory;
 
   /**
    * Dependency-Scopes, that should be scanned for annotated classes.
    * <p>
    * By default, only dependencies in the scope <code>compile</code> are
    * scanned for annotated classes. Multiple scopes can be seperated by
    * white space or commas.
    * <p>
    * If you do not want any dependencies to be scanned for annotated
    * classes, set this parameter to <code>none</code>.
    * <p>
    * The plugin does not scan for annotated classes in transitive
    * dependencies. If some of your annotated classes are hidden in a
    * transitive dependency, you can simply add that dependency explicitly.
    *
    * @parameter property="hibernate.schema.scan.dependencies" default-value="compile"
    * @since 1.0.3
    */
   private String scanDependencies;
 
   /**
    * Whether to scan the test-branch of the project for annotated classes, or
    * not.
    * <p>
    * If this parameter is set to <code>true</code> the test-classes of the
    * artifact will be scanned for hibernate-annotated classes additionally.
    * <p>
    * <strong>Important:</strong>
    * This configuration value can only be configured through the
    * <code>pom.xml</code>, or by the definition of a system-property, because
    * it is not known by Hibernate nor JPA and, hence, not picked up from
    * their configuration!
    *
    * @parameter property="hibernate.schema.scan.test_classes" default-value="false"
    * @since 1.0.1
    */
   private Boolean scanTestClasses;
 
   /**
    * Test-Classes-Directory to scan.
    * <p>
    * This parameter defaults to the maven build-output-directory for
    * test-classes.
    * <p>
    * This parameter is only used, when <code>scanTestClasses</code> is set
    * to <code>true</code>!
    * <p>
    * <strong>Important:</strong>
    * This configuration value can only be configured through the
    * <code>pom.xml</code>, or by the definition of a system-property, because
    * it is not known by Hibernate nor JPA and, hence, not picked up from
    * their configuration!
    *
    * @parameter property="project.build.testOutputDirectory"
    * @since 1.0.2
    */
   private String testOutputDirectory;
 
 
   /** Conection parameters *************************************************/
 
   /**
    * SQL-Driver name.
    *
    * @parameter property="hibernate.connection.driver_class"
    * @since 1.0
    */
   private String driver;
 
   /**
    * Database URL.
    *
    * @parameter property="hibernate.connection.url"
    * @since 1.0
    */
   private String url;
 
   /**
    * Database username
    *
    * @parameter property="hibernate.connection.username"
    * @since 1.0
    */
   private String username;
 
   /**
    * Database password
    *
    * @parameter property="hibernate.connection.password"
    * @since 1.0
    */
   private String password;
 
 
   /** Parameters to locate configuration sources ****************************/
 
   /**
    * Path to a file or name of a ressource with hibernate properties.
    * If this parameter is specified, the plugin will try to load configuration
    * values from a file with the given path or a ressource on the classpath with
    * the given name. If both fails, the execution of the plugin will fail.
    * <p>
    * If this parameter is not set the plugin will load configuration values
    * from a ressource named <code>hibernate.properties</code> on the classpath,
    * if it is present, but will not fail if there is no such ressource.
    * <p>
    * During ressource-lookup, the test-classpath takes precedence.
    *
    * @parameter
    * @since 1.0
    */
   private String hibernateProperties;
 
   /**
    * Path to Hibernate configuration file (.cfg.xml).
    * If this parameter is specified, the plugin will try to load configuration
    * values from a file with the given path or a ressource on the classpath with
    * the given name. If both fails, the execution of the plugin will fail.
    * <p>
    * If this parameter is not set the plugin will load configuration values
    * from a ressource named <code>hibernate.cfg.xml</code> on the classpath,
    * if it is present, but will not fail if there is no such ressource.
    * <p>
    * During ressource-lookup, the test-classpath takes precedence.
    * <p>
    * Settings in this file will overwrite settings in the properties file.
    *
    * @parameter
    * @since 1.1.0
    */
   private String hibernateConfig;
 
   /**
    * Name of the persistence-unit.
    * If this parameter is specified, the plugin will try to load configuration
    * values from a persistence-unit with the specified name. If no such
    * persistence-unit can be found, the plugin will throw an exception.
    * <p>
    * If this parameter is not set and there is only one persistence-unit
    * available, that unit will be used automatically. But if this parameter is
    * not set and there are multiple persistence-units available on,
    * the class-path, the execution of the plugin will fail.
    * <p>
    * Settings in this file will overwrite settings in the properties or the
    * configuration file.
    *
    * @parameter
    * @since 1.1.0
    */
   private String persistenceUnit;
 
   /**
    * List of Hibernate-Mapping-Files (XML).
    * Multiple files can be separated with white-spaces and/or commas.
    *
    * @parameter property="hibernate.mapping"
    * @since 1.0.2
    */
   private String mappings;
 
 
 
   public final void execute(String filename)
     throws
       MojoFailureException,
       MojoExecutionException
   {
     if (skip)
     {
       getLog().info("Execution of hibernate-maven-plugin was skipped!");
       project.getProperties().setProperty(SKIPPED, "true");
       return;
     }
 
     ModificationTracker tracker;
     try
     {
       tracker = new ModificationTracker(buildDirectory, filename, getLog());
     }
     catch (NoSuchAlgorithmException e)
     {
       throw new MojoFailureException("Digest-Algorithm MD5 is missing!", e);
     }
 
     final SimpleConnectionProvider connectionProvider =
         new SimpleConnectionProvider(getLog());
 
     try
     {
       /** Start extended logging */
       MavenLogAppender.startPluginLog(this);
 
       /** Load checksums for old mapping and configuration */
       tracker.load();
 
       /** Create the ClassLoader */
       MutableClassLoader classLoader = createClassLoader();
 
       /** Create a BootstrapServiceRegistry with the created ClassLoader */
       BootstrapServiceRegistry bootstrapServiceRegitry =
           new BootstrapServiceRegistryBuilder()
               .applyClassLoader(classLoader)
               .build();
       ClassLoaderService classLoaderService =
           bootstrapServiceRegitry.getService(ClassLoaderService.class);
 
       Properties properties = new Properties();
       ConfigLoader configLoader = new ConfigLoader(bootstrapServiceRegitry);
 
       /** Loading and merging configuration */
       properties.putAll(loadProperties(configLoader));
       LoadedConfig config = loadConfig(configLoader);
       if (config != null)
         properties.putAll(config.getConfigurationValues());
       ParsedPersistenceXmlDescriptor unit =
           loadPersistenceUnit(classLoaderService, properties);
       if (unit != null)
         properties.putAll(unit.getProperties());
 
       /** Overwriting/Completing configuration */
       configure(properties, tracker);
 
       /** Check configuration for modifications */
       if(tracker.track(properties))
         getLog().debug("Configuration has changed.");
       else
         getLog().debug("Configuration unchanged.");
 
       /** Check, that the outputfile is writable */
       final File output = getOutputFile(filename);
       /** Check, if the outputfile is missing or was changed */
       checkOutputFile(output, tracker);
 
       /** Configure Hibernate */
       final StandardServiceRegistry serviceRegistry =
           new StandardServiceRegistryBuilder(bootstrapServiceRegitry)
               .applySettings(properties)
               .addService(ConnectionProvider.class, connectionProvider)
               .build();
       final MetadataSources sources = new MetadataSources(serviceRegistry);
 
       /** Add the remaining class-path-elements */
       completeClassPath(classLoader);
 
       /** Apply mappings from hibernate-configuration, if present */
       if (config != null)
       {
         for (MappingReference mapping : config.getMappingReferences())
           mapping.apply(sources);
       }
 
       Set<String> classes;
       if (unit == null)
       {
         /** No persistent unit: default behaviour */
         if (scanClasses == null)
           scanClasses = true;
         Set<URL> urls = new HashSet<URL>();
         if (scanClasses)
           addRoot(urls, outputDirectory);
         if (scanTestClasses)
           addRoot(urls, testOutputDirectory);
         addDependencies(urls);
         classes = scanUrls(urls);
       }
       else
       {
         /** Follow configuration in persisten unit */
         if (scanClasses == null)
           scanClasses = !unit.isExcludeUnlistedClasses();
         Set<URL> urls = new HashSet<URL>();
         if (scanClasses)
         {
           /**
            * Scan the root of the persiten unit and configured jars for
            * annotated classes
            */
           urls.add(unit.getPersistenceUnitRootUrl());
           for (URL url : unit.getJarFileUrls())
             urls.add(url);
         }
         if (scanTestClasses)
           addRoot(urls, testOutputDirectory);
         classes = scanUrls(urls);
         for (String className : unit.getManagedClassNames())
           classes.add(className);
         /**
          * Add mappings from the default mapping-file
          * <code>META-INF/orm.xml</code>, if present
          */
         boolean error = false;
         InputStream is;
         is = classLoader.getResourceAsStream("META-INF/orm.xml");
         if (is != null)
         {
           getLog().info("Adding default JPA-XML-mapping from META-INF/orm.xml");
           try
           {
             tracker.track("META-INF/orm.xml", is);
             sources.addResource("META-INF/orm.xml");
           }
           catch (IOException e)
           {
             getLog().error("cannot read META-INF/orm.xml: " + e);
             error = true;
           }
         }
         else
         {
           getLog().debug("no META-INF/orm.xml found");
         }
         /**
          * Add mappings from files, that are explicitly configured in the
          * persistence unit
          */
         for (String mapping : unit.getMappingFileNames())
         {
           getLog().info("Adding explicitly configured mapping from " + mapping);
           is = classLoader.getResourceAsStream(mapping);
           if (is != null)
           {
             try
             {
               tracker.track(mapping, is);
               sources.addResource(mapping);
             }
             catch (IOException e)
             {
               getLog().info("cannot read mapping-file " + mapping + ": " + e);
               error = true;
             }
           }
           else
           {
             getLog().error("cannot find mapping-file " + mapping);
             error = true;
           }
         }
         if (error)
           throw new MojoFailureException(
               "error, while reading mappings configured in persistence-unit \"" +
               unit.getName() +
               "\""
               );
       }
 
       /** Add the configured/collected annotated classes */
       for (String className : classes)
         addAnnotated(className, sources, classLoaderService, tracker);
 
       /** Add explicitly configured classes */
       addMappings(sources, tracker);
 
       /** Skip execution, if mapping and configuration is unchanged */
       if (!tracker.modified())
       {
         getLog().info("Mapping and configuration unchanged.");
         if (force)
           getLog().info("Generation/execution is forced!");
         else
         {
           getLog().info("Skipping schema generation!");
           project.getProperties().setProperty(SKIPPED, "true");
           return;
         }
       }
 
 
       /** Truncate output file */
       try
       {
         new FileOutputStream(output).getChannel().truncate(0).close();
       }
       catch (IOException e)
       {
         String error =
             "Error while truncating " + output.getAbsolutePath() + ": "
             + e.getMessage();
         getLog().warn(error);
         throw new MojoExecutionException(error);
       }
 
       /** Create a connection, if sufficient configuration infromation is available */
       connectionProvider.open(classLoaderService, properties);
 
       MetadataBuilder metadataBuilder = sources.getMetadataBuilder();
 
       StrategySelector strategySelector =
           serviceRegistry.getService(StrategySelector.class);
 
       if (properties.containsKey(IMPLICIT_NAMING_STRATEGY))
       {
         metadataBuilder.applyImplicitNamingStrategy(
             strategySelector.resolveStrategy(
                 ImplicitNamingStrategy.class,
                 properties.getProperty(IMPLICIT_NAMING_STRATEGY)
                 )
             );
       }
 
       if (properties.containsKey(PHYSICAL_NAMING_STRATEGY))
       {
         metadataBuilder.applyPhysicalNamingStrategy(
             strategySelector.resolveStrategy(
                 PhysicalNamingStrategy.class,
                 properties.getProperty(PHYSICAL_NAMING_STRATEGY)
                 )
             );
       }
 
       /** Prepare the generation of the SQL */
       Map settings = new HashMap();
       settings.putAll(
           serviceRegistry
               .getService(ConfigurationService.class)
               .getSettings()
               );
       ExceptionHandlerCollectingImpl handler =
           new ExceptionHandlerCollectingImpl();
       ExecutionOptions options =
           SchemaManagementToolCoordinator
               .buildExecutionOptions(settings, handler);
       final EnumSet<TargetType> targetTypes = EnumSet.of(TargetType.SCRIPT);
       if (execute)
         targetTypes.add(TargetType.DATABASE);
       TargetDescriptor target = new TargetDescriptor()
       {
         @Override
         public EnumSet<TargetType> getTargetTypes()
         {
           return targetTypes;
         }
 
         @Override
         public ScriptTargetOutput getScriptTargetOutput()
         {
           String charset =
               (String)
               serviceRegistry
                   .getService(ConfigurationService.class)
                   .getSettings()
                   .get(AvailableSettings.HBM2DDL_CHARSET_NAME);
           return new ScriptTargetOutputToFile(output, charset);
         }
       };
 
       /**
        * Change class-loader of current thread.
        * This is necessary, because still not all parts of Hibernate 5 use
        * the newly introduced ClassLoaderService and will fail otherwise!
        */
       Thread thread = Thread.currentThread();
       ClassLoader contextClassLoader = thread.getContextClassLoader();
       try
       {
         thread.setContextClassLoader(classLoader);
         build((MetadataImplementor)metadataBuilder.build(), options, target);
         if (handler.getExceptions().size() > 0)
         {
           StringBuilder builder = new StringBuilder();
           builder.append("Hibernate failed:");
           for (Exception e : handler.getExceptions())
           {
             builder.append("\n * ");
             builder.append(e.getMessage());
             AbstractSchemaMojo.printStrackTrace(builder, e);
             builder.append("\n");
           }
           String error = builder.toString();
           getLog().error(error);
           throw new MojoFailureException(error);
         }
       }
       finally
       {
         thread.setContextClassLoader(contextClassLoader);
         /** Track, the content of the generated script */
         checkOutputFile(output, tracker);
       }
     }
     catch (MojoExecutionException e)
     {
       tracker.failed();
       throw e;
     }
     catch (MojoFailureException e)
     {
       tracker.failed();
       throw e;
     }
     catch (RuntimeException e)
     {
       tracker.failed();
       throw e;
     }
     finally
     {
       /** Remember mappings and configuration */
       tracker.save();
 
       /** Close the connection - if one was opened */
       connectionProvider.close();
 
       /** Stop Log-Capturing */
       MavenLogAppender.endPluginLog(this);
     }
   }
 
 
   abstract void build(
       MetadataImplementor metadata,
       ExecutionOptions options,
       TargetDescriptor target
       )
     throws
       MojoFailureException,
       MojoExecutionException;
 
 
   private MutableClassLoader createClassLoader() throws MojoExecutionException
   {
     try
     {
       getLog().debug("Creating ClassLoader for project-dependencies...");
       LinkedHashSet<URL> urls = new LinkedHashSet<URL>();
       File file;
 
       file = new File(testOutputDirectory);
       if (!file.exists())
       {
         getLog().info("Creating test-output-directory: " + testOutputDirectory);
         file.mkdirs();
       }
       urls.add(file.toURI().toURL());
 
       file = new File(outputDirectory);
       if (!file.exists())
       {
         getLog().info("Creating output-directory: " + outputDirectory);
         file.mkdirs();
       }
       urls.add(file.toURI().toURL());
 
       return new MutableClassLoader(urls, getLog());
     }
     catch (Exception e)
     {
       getLog().error("Error while creating ClassLoader!", e);
       throw new MojoExecutionException(e.getMessage());
     }
   }
 
   private void completeClassPath(MutableClassLoader classLoader)
       throws
         MojoExecutionException
   {
     try
     {
       getLog().debug("Completing class-paths of the ClassLoader for project-dependencies...");
       List<String> classpathFiles = project.getCompileClasspathElements();
       if (scanTestClasses)
         classpathFiles.addAll(project.getTestClasspathElements());
       LinkedHashSet<URL> urls = new LinkedHashSet<URL>();
       for (String pathElement : classpathFiles)
       {
         getLog().debug("Dependency: " + pathElement);
         urls.add(new File(pathElement).toURI().toURL());
       }
       classLoader.add(urls);
     }
     catch (Exception e)
     {
       getLog().error("Error while creating ClassLoader!", e);
       throw new MojoExecutionException(e.getMessage());
     }
   }
 
   private Map loadProperties(ConfigLoader configLoader)
       throws
         MojoExecutionException
   {
     /** Try to read configuration from properties-file */
     if (hibernateProperties == null)
     {
       try
       {
         return configLoader.loadProperties("hibernate.properties");
       }
       catch (ConfigurationException e)
       {
         getLog().debug(e.getMessage());
         return Collections.EMPTY_MAP;
       }
     }
     else
     {
       try
       {
         File file = new File(hibernateProperties);
         if (file.exists())
         {
           getLog().info("Reading settings from file " + hibernateProperties + "...");
           return configLoader.loadProperties(file);
         }
         else
           return configLoader.loadProperties(hibernateProperties);
       }
       catch (ConfigurationException e)
       {
         getLog().error("Error while reading properties!", e);
         throw new MojoExecutionException(e.getMessage());
       }
     }
   }
 
   private LoadedConfig loadConfig(ConfigLoader configLoader)
       throws MojoExecutionException
   {
     /** Try to read configuration from configuration-file */
     if (hibernateConfig == null)
     {
       try
       {
         return configLoader.loadConfigXmlResource("hibernate.cfg.xml");
       }
       catch (ConfigurationException e)
       {
         getLog().debug(e.getMessage());
         return null;
       }
     }
     else
     {
       try
       {
         File file = new File(hibernateConfig);
         if (file.exists())
         {
           getLog().info("Reading configuration from file " + hibernateConfig + "...");
           return configLoader.loadConfigXmlFile(file);
         }
         else
         {
           return configLoader.loadConfigXmlResource(hibernateConfig);
         }
       }
       catch (ConfigurationException e)
       {
         getLog().error("Error while reading configuration!", e);
         throw new MojoExecutionException(e.getMessage());
       }
     }
   }
 
   private void configure(Properties properties, ModificationTracker tracker)
       throws MojoFailureException
   {
     /**
      * Special treatment for the configuration-value "execute": if it is
      * switched to "true", the genearation fo the schema should be forced!
      */
     if (tracker.check(EXECUTE, execute.toString()) && execute)
     {
       getLog().info(
           "hibernate.schema.execute was switched on: " +
           "forcing generation/execution of SQL"
           );
       tracker.touch();
     }
     configure(properties, execute, EXECUTE);
 
     /**
      * Configure the generation of the SQL.
      * Overwrite values from properties-file if the configuration parameter is
      * known to Hibernate.
      */
     configure(properties, dialect, DIALECT);
     configure(properties, delimiter, HBM2DDL_DELIMITER);
     configure(properties, format, FORMAT_SQL);
     configure(properties, createNamespaces, HBM2DLL_CREATE_NAMESPACES);
     configure(properties, implicitNamingStrategy, IMPLICIT_NAMING_STRATEGY);
     configure(properties, physicalNamingStrategy, PHYSICAL_NAMING_STRATEGY);
     configure(properties, outputDirectory, OUTPUTDIRECTORY);
     configure(properties, scanDependencies, SCAN_DEPENDENCIES);
     configure(properties, scanTestClasses, SCAN_TESTCLASSES);
     configure(properties, testOutputDirectory, TEST_OUTPUTDIRECTORY);
 
     /**
      * Special treatment for the configuration-value "show": a change of its
      * configured value should not lead to a regeneration of the database
      * schama!
      */
     if (show == null)
       show = Boolean.valueOf(properties.getProperty(SHOW_SQL));
     else
       properties.setProperty(SHOW_SQL, show.toString());
 
     /**
      * Configure the connection parameters.
      * Overwrite values from properties-file.
      */
     configure(properties, driver, DRIVER, JPA_JDBC_DRIVER);
     configure(properties, url, URL, JPA_JDBC_URL);
     configure(properties, username, USER, JPA_JDBC_USER);
     configure(properties, password, PASS, JPA_JDBC_PASSWORD);
 
     if (properties.isEmpty())
     {
       getLog().error("No properties set!");
       throw new MojoFailureException("Hibernate configuration is missing!");
     }
 
     getLog().info("Gathered configuration:");
     for (Entry<Object,Object> entry : properties.entrySet())
       getLog().info("  " + entry.getKey() + " = " + entry.getValue());
   }
 
   private void configure(
       Properties properties,
       String value,
       String key,
       String alternativeKey
       )
   {
     configure(properties, value, key);
 
     if (properties.containsKey(alternativeKey))
     {
       if (properties.containsKey(key))
       {
         getLog().warn(
             "Ignoring property " + alternativeKey + "=\"" +
             properties.getProperty(alternativeKey) +
             "\" in favour for property " + key + "=\"" +
             properties.getProperty(key) + "\""
             );
         properties.remove(alternativeKey);
       }
       else
       {
         value = properties.getProperty(alternativeKey);
         properties.remove(alternativeKey);
         getLog().info(
             "Using value \"" + value + "\" from property " + alternativeKey +
             " for property " + key
             );
         properties.setProperty(key, value);
       }
     }
   }
 
   private void configure(Properties properties, String value, String key)
   {
     if (value != null)
     {
       if (properties.containsKey(key))
       {
         if (!properties.getProperty(key).equals(value))
         {
           getLog().info(
               "Overwriting property " + key + "=\"" +
               properties.getProperty(key) +
               "\" with value \"" + value + "\""
               );
           properties.setProperty(key, value);
         }
       }
       else
       {
         getLog().debug("Using value \"" + value + "\" for property " + key);
         properties.setProperty(key, value);
       }
     }
   }
 
   private void configure(Properties properties, Boolean value, String key)
   {
     configure(properties, value == null ? null : value.toString(), key);
   }
 
   private File getOutputFile(String filename)
       throws
         MojoExecutionException
   {
     File output = new File(filename);
 
     if (!output.isAbsolute())
     {
       // Interpret relative file path relative to build directory
       output = new File(buildDirectory, filename);
     }
     getLog().debug("Output file: " + output.getPath());
 
     // Ensure that directory path for specified file exists
     File outFileParentDir = output.getParentFile();
     if (null != outFileParentDir && !outFileParentDir.exists())
     {
       try
       {
         getLog().info(
             "Creating directory path for output file:" +
             outFileParentDir.getPath()
             );
         outFileParentDir.mkdirs();
       }
       catch (Exception e)
       {
         String error =
             "Error creating directory path for output file: " + e.getMessage();
         getLog().error(error);
         throw new MojoExecutionException(error);
       }
     }
 
     try
     {
       output.createNewFile();
     }
     catch (IOException e)
     {
       String error = "Error creating output file: " + e.getMessage();
       getLog().error(error);
       throw new MojoExecutionException(error);
     }
 
     if (!output.canWrite())
     {
       String error =
           "Output file " + output.getAbsolutePath() + " is not writable!";
       getLog().error(error);
       throw new MojoExecutionException(error);
     }
 
     return output;
   }
 
   private void checkOutputFile(File output, ModificationTracker tracker)
       throws
         MojoExecutionException
   {
     try
     {
       if (output.exists())
         tracker.track(SCRIPT, new FileInputStream(output));
       else
         tracker.track(SCRIPT, ZonedDateTime.now().toString());
     }
     catch (IOException e)
     {
       String error =
           "Error while checking the generated script: " + e.getMessage();
       getLog().error(error);
       throw new MojoExecutionException(error);
     }
   }
 
   private void addMappings(MetadataSources sources, ModificationTracker tracker)
       throws MojoFailureException
   {
     getLog().debug("Adding explicitly configured mappings...");
     if (mappings != null)
     {
       try
       {
         for (String filename : mappings.split("[\\s,]+"))
         {
           // First try the filename as absolute/relative path
           File file = new File(filename);
           if (!file.exists())
           {
             // If the file was not found, search for it in the resource-directories
             for (Resource resource : project.getResources())
             {
               file = new File(resource.getDirectory() + File.separator + filename);
               if (file.exists())
                 break;
             }
           }
           if (file.exists())
           {
             if (file.isDirectory())
               // TODO: add support to read all mappings under a directory
               throw new MojoFailureException(file.getAbsolutePath() + " is a directory");
             if (tracker.track(filename, new FileInputStream(file)))
               getLog().debug("Found new or modified mapping-file: " + filename);
             else
               getLog().debug("Mapping-file unchanged: " + filename);
 
             sources.addFile(file);
           }
           else
             throw new MojoFailureException("File " + filename + " could not be found in any of the configured resource-directories!");
         }
       }
       catch (IOException e)
       {
         throw new MojoFailureException("Cannot calculate MD5 sums!", e);
       }
     }
   }
 
   private void addRoot(Set<URL> urls, String path) throws MojoFailureException
   {
     try
     {
       File dir = new File(path);
       if (dir.exists())
       {
         getLog().info("Adding " + dir.getAbsolutePath() + " to the list of roots to scan...");
         urls.add(dir.toURI().toURL());
       }
       else
         getLog().warn(
             "the directory cannot be scanned for annotated classes, " +
             "because it does not exist: " +
             dir.getAbsolutePath()
             );
     }
     catch (MalformedURLException e)
     {
       getLog().error("error while adding the project-root to the list of roots to scan!", e);
       throw new MojoFailureException(e.getMessage());
     }
   }
 
   private void addDependencies(Set<URL> urls) throws MojoFailureException
   {
     try
     {
       if (scanDependencies != null)
       {
         Matcher matcher = SPLIT.matcher(scanDependencies);
         while (matcher.find())
         {
           getLog().info("Adding dependencies from scope " + matcher.group() + " to the list of roots to scan");
           for (Artifact artifact : project.getDependencyArtifacts())
           {
             if (!artifact.getScope().equalsIgnoreCase(matcher.group()))
               continue;
             if (artifact.getFile() == null)
             {
               getLog().warn("Cannot add dependency " + artifact.getId() + ": no JAR-file available!");
               continue;
             }
             getLog().info("Adding dependencies from scope " + artifact.getId() + " to the list of roots to scan");
             urls.add(artifact.getFile().toURI().toURL());
           }
         }
       }
     }
     catch (MalformedURLException e)
     {
       getLog().error("Error while adding dependencies to the list of roots to scan!", e);
       throw new MojoFailureException(e.getMessage());
     }
   }
 
   private Set<String> scanUrls(Set<URL> scanRoots)
       throws
         MojoFailureException
   {
     try
     {
       AnnotationDB db = new AnnotationDB();
       for (URL root : scanRoots)
         db.scanArchives(root);
 
       Set<String> classes = new HashSet<String>();
       if (db.getAnnotationIndex().containsKey(Entity.class.getName()))
         classes.addAll(db.getAnnotationIndex().get(Entity.class.getName()));
       if (db.getAnnotationIndex().containsKey(MappedSuperclass.class.getName()))
         classes.addAll(db.getAnnotationIndex().get(MappedSuperclass.class.getName()));
       if (db.getAnnotationIndex().containsKey(Embeddable.class.getName()))
         classes.addAll(db.getAnnotationIndex().get(Embeddable.class.getName()));
 
       return classes;
     }
     catch (Exception e)
     {
       getLog().error("Error while scanning!", e);
       throw new MojoFailureException(e.getMessage());
     }
   }
 
   private void addAnnotated(
       String name,
       MetadataSources sources,
       ClassLoaderService classLoaderService,
       ModificationTracker tracker
       )
       throws
         MojoFailureException,
         MojoExecutionException
   {
     try
     {
       getLog().info("Adding annotated resource: " + name);
       String packageName = null;
 
       boolean error = false;
       try
       {
         Class<?> annotatedClass = classLoaderService.classForName(name);
         String resourceName = annotatedClass.getName();
         resourceName =
             resourceName.substring(
                 resourceName.lastIndexOf(".") + 1,
                 resourceName.length()
                 ) + ".class";
         InputStream is = annotatedClass.getResourceAsStream(resourceName);
         if (is != null)
         {
           if (tracker.track(name, is))
             getLog().debug("New or modified class: " + name);
           else
             getLog().debug("Unchanged class: " + name);
           sources.addAnnotatedClass(annotatedClass);
           packageName = annotatedClass.getPackage().getName();
         }
         else
         {
           getLog().error("cannot find ressource " + resourceName + " for class " + name);
           error = true;
         }
       }
       catch(ClassLoadingException e)
       {
         packageName = name;
       }
       if (error)
       {
         throw new MojoExecutionException("error while inspecting annotated class " + name);
       }
 
       while (packageName != null)
       {
         if (packages.contains(packageName))
           return;
         String resource = packageName.replace('.', '/') + "/package-info.class";
         InputStream is = classLoaderService.locateResourceStream(resource);
         if (is == null)
         {
           // No compiled package-info available: no package-level annotations!
           getLog().debug("Package " + packageName + " is not annotated.");
         }
         else
         {
           if (tracker.track(packageName, is))
             getLog().debug("New or modified package: " + packageName);
           else
            getLog().debug("Unchanged package: " + packageName);
           getLog().info("Adding annotations from package " + packageName);
           sources.addPackage(packageName);
         }
         packages.add(packageName);
         int i = packageName.lastIndexOf('.');
         if (i < 0)
           packageName = null;
         else
           packageName = packageName.substring(0,i);
       }
     }
     catch (Exception e)
     {
       getLog().error("Error while adding the annotated class " + name, e);
       throw new MojoFailureException(e.getMessage());
     }
   }
 
   private ParsedPersistenceXmlDescriptor loadPersistenceUnit(
       ClassLoaderService classLoaderService,
       Properties properties
       )
       throws
         MojoFailureException
   {
     PersistenceXmlParser parser =
         new PersistenceXmlParser(
             classLoaderService,
             PersistenceUnitTransactionType.RESOURCE_LOCAL
              );
 
     Map<String, ParsedPersistenceXmlDescriptor> units =
         parser.doResolve(properties);
 
     if (persistenceUnit == null)
     {
       Iterator<String> names = units.keySet().iterator();
       if (!names.hasNext())
       {
         getLog().info("Found no META-INF/persistence.xml.");
         return null;
       }
 
       String name = names.next();
       if (!names.hasNext())
       {
           getLog().info("Using persistence-unit " + name);
           return units.get(name);
       }
 
       StringBuilder builder = new StringBuilder();
       builder.append("No name provided and multiple persistence units found: ");
       builder.append(name);
       while(names.hasNext())
       {
         builder.append(", ");
         builder.append(names.next());
       }
       builder.append('.');
       throw new MojoFailureException(builder.toString());
     }
 
     if (units.containsKey(persistenceUnit))
     {
       getLog().info("Using configured persistence-unit " + persistenceUnit);
       return units.get(persistenceUnit);
     }
 
     throw new MojoFailureException("Could not find persistence-unit " + persistenceUnit);
   }
 
 
   public static void printStrackTrace(StringBuilder builder, Throwable t)
   {
     while (t != null)
     {
       builder.append("\n\tCause: ");
       builder.append(t.getMessage() == null ? "" : t.getMessage().replaceAll("\\s+", " "));
       for (StackTraceElement trace : t.getStackTrace())
       {
         builder.append("\n\t");
         builder.append(trace.getClassName());
         builder.append(".");
         builder.append(trace.getMethodName());
         builder.append("():");
         builder.append(trace.getLineNumber());
       }
       t = t.getCause();
     }
   }
 }