// Version: $Id: $

 // Copyright: Copyright(c) 2007 Trace Financial Limited

 package org.liquibase.maven.plugins;

 import java.io.File;

 import java.net.*;

 import java.sql.*;

 import java.util.*;

 import java.lang.reflect.Field;

 import liquibase.exception.LiquibaseException;

 import org.apache.maven.artifact.Artifact;

 import org.apache.maven.plugin.logging.Log;

 import org.apache.maven.project.MavenProject;

 /**

  * A Utilities class for Maven plugins.

  * 

  * @author Peter Murray

  */

 public class MavenUtils {

     public static final String LOG_SEPARATOR = "------------------------------------------------------------------------";

     /**

      * Obtains a {@link ClassLoader} that can load from the Maven project dependencies. If the dependencies have not be

      * resolved (or there are none) then this will just end up delegating to the parent {@link ClassLoader} of this

      * class.

      * 

      * @return The ClassLoader that can load the resolved dependencies for the Maven project.

      * @throws java.net.MalformedURLException

      *             If any of the dependencies cannot be resolved into a URL.

      */

     public static ClassLoader getArtifactClassloader(MavenProject project, boolean includeArtifact,

             boolean includeTestOutputDirectory, Class clazz, Log log, boolean verbose) throws MalformedURLException {

         if (verbose) {

             log.info("Loading artfacts into URLClassLoader");

         }

         Set<URL> urls = new HashSet<URL>();

         Set dependencies = project.getDependencyArtifacts();

         if (dependencies != null && !dependencies.isEmpty()) {

             for (Iterator it = dependencies.iterator(); it.hasNext();) {

                 addArtifact(urls, (Artifact) it.next(), log, verbose);

             }

         } else {

             log.info("there are no resolved artifacts for the Maven project.");

         }

         // Include the artifact for the actual maven project if requested

         if (includeArtifact) {

             // If the actual artifact can be resolved, then use that, otherwise use the build

             // directory as that should contain the files for this project that we will need to

             // run against. It is possible that the build directy could be empty, but we cannot

             // directly include the source and resources as the resources may require filtering

             // to replace any placeholders in the resource files.

             Artifact a = project.getArtifact();

             if (a.getFile() != null) {

                 addArtifact(urls, a, log, verbose);

             } else {

                 addFile(urls, new File(project.getBuild().getOutputDirectory()), log, verbose);

             }

         }

         if (includeTestOutputDirectory) {

             addFile(urls, new File(project.getBuild().getTestOutputDirectory()), log, verbose);

         }

         if (verbose) {

             log.info(LOG_SEPARATOR);

         }

         URL[] urlArray = urls.toArray(new URL[urls.size()]);

         return new URLClassLoader(urlArray, clazz.getClassLoader());

     }

     /**

      * Adds the artifact file into the set of URLs so it can be used in a URLClassLoader.

      * 

      * @param urls

      *            The set to add the artifact file URL to.

      * @param artifact

      *            The Artifiact to resolve the file for.

      * @throws MalformedURLException

      *             If there is a problem creating the URL for the file.

      */

     private static void addArtifact(Set<URL> urls, Artifact artifact, Log log, boolean verbose)

             throws MalformedURLException {

         File f = artifact.getFile();

         if (f == null) {

             log.warn("Artifact with no actual file, '" + artifact.getGroupId() + ":" + artifact.getArtifactId() + "'");

         } else {

             addFile(urls, f, log, verbose);

         }

         // if (f != null) {

         // URL fileURL = f.toURI().toURL();

         // if (verbose) {

         // log.info("  artifact: " + fileURL);

         // }

         // urls.add(fileURL);

         // } else {

         // log.warn("Artifact with no actual file, '" + artifact.getGroupId()

         // + ":" + artifact.getArtifactId() + "'");

         // }

     }

     private static void addFile(Set<URL> urls, File f, Log log, boolean verbose) throws MalformedURLException {

         if (f != null) {

             URL fileURL = f.toURI().toURL();

             if (verbose) {

                 log.info("  artifact: " + fileURL);

             }

             urls.add(fileURL);

         }

     }

     public static Connection getDatabaseConnection(ClassLoader classLoader, String driver, String url, String username,

             String password) throws LiquibaseException {

         Driver dbDriver = null;

         try {

             dbDriver = (Driver) Class.forName(driver, true, classLoader).newInstance();

         } catch (InstantiationException e) {

             throw new LiquibaseException("Failed to load JDBC driver, " + driver, e);

         } catch (IllegalAccessException e) {

             throw new LiquibaseException("Failed to load JDBC driver, " + driver, e);

         } catch (ClassNotFoundException e) {

             throw new LiquibaseException("Missing Class '" + e.getMessage() + "'. Database "

                     + "driver may not be included in the project " + "dependencies or with wrong scope.");

         }

         Properties info = new Properties();

         info.put("user", username);

         info.put("password", password);

         try {

             Connection connection = dbDriver.connect(url, info);

             if (connection == null) {

                 throw new LiquibaseException("Connection could not be created to " + url + " with driver "

                         + dbDriver.getClass().getName() + ".  Possibly the wrong driver for the given "

                         + "database URL");

             }

             return connection;

         } catch (SQLException e) {

             throw new LiquibaseException(e);

         }

     }

     /**

      * Recursively searches for the field specified by the fieldName in the class and all the super classes until it

      * either finds it, or runs out of parents.

      * 

      * @param clazz

      *            The Class to start searching from.

      * @param fieldName

      *            The name of the field to retrieve.

      * @return The {@link Field} identified by the field name.

      * @throws NoSuchFieldException

      *             If the field was not found in the class or any of its super classes.

      */

     public static Field getDeclaredField(Class clazz, String fieldName) throws NoSuchFieldException {

         Field f = getField(clazz, fieldName);

         if (f == null) {

             // Try the parent class

             Class parent = clazz.getSuperclass();

             if (parent != null) {

                 return getDeclaredField(parent, fieldName);

             } else {

                 throw new NoSuchFieldException("The field '" + fieldName + "' could not be "

                         + "found in the class of any of its parent " + "classes.");

             }

         } else {

             return f;

         }

     }

     private static Field getField(Class clazz, String fieldName) {

         Field[] fields = clazz.getDeclaredFields();

         for (int i = 0; i < fields.length; i++) {

             if (fields[i].getName().equals(fieldName)) {

                 return fields[i];

             }

         }

         return null;

     }

 }