/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.
 */
package org.apache.uima.pear.tools;

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Properties;
import java.util.Set;

import org.apache.commons.io.FileUtils;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.logging.Log;
import org.apache.maven.plugins.annotations.Component;
import org.apache.maven.plugins.annotations.LifecyclePhase;
import org.apache.maven.plugins.annotations.Mojo;
import org.apache.maven.plugins.annotations.Parameter;
import org.apache.maven.project.MavenProject;
import org.apache.uima.UIMAFramework;
import org.apache.uima.util.Level;

/**
 * PearPackagingMojo which generates an UIMA PEAR package. All the necessary
 * information from the UIMA nature is gathered and added to the PEAR package.
 * Additionally the generated jar file from the Maven build is added with the
 * according classpath information.
 */
@Mojo(name = "package", defaultPhase = LifecyclePhase.PACKAGE)
public class PearPackagingMojo extends AbstractMojo {

  /**
   * Main component directory of the UIMA project that contains the UIMA nature.
   */
  @Parameter(defaultValue = "${basedir}", property = "basedir", required = true)
  private String            mainComponentDir  = null;

  /**
   * Required classpath settings for the PEAR package.
   */
  @Parameter(defaultValue = "${pear.classpath}", property = "pear.classpath")
  private String            classpath         = null;

  /**
   * Main Component Descriptor path relative to the main component directory
   */
  @Parameter(defaultValue = "${pear.mainComponentDesc}", property = "pear.mainComponentDesc", required = true)
  private String            mainComponentDesc = null;

  /**
   * PEAR package component ID
   */
  @Parameter(defaultValue = "${pear.componentId}", property = "pear.componentId", required = true)
  private String            componentId       = null;

  /**
   * Target directory for the PEAR package
   */
  @Parameter(defaultValue = "${basedir}/target", required = true)
  private String            targetDir         = null;

  /**
   * Required UIMA datapath settings for the PEAR package
   */
  @Parameter(defaultValue = "$main_root/resources")
  private String            datapath          = null;

  /**
   * Required environment variables for the PEAR package
   * 
   * 
   */
  @Parameter
  private Properties        props             = null;

  /**
   * The maven project.
   */
  @Component
  private MavenProject      project;

  // the PEAR packaging directory contains all the stuff that is added to
  // the PEAR
  private File              pearPackagingDir;

  private ArrayList<String> classpathsInOrder;

  private Set<String> classpathsDefined;

  private Log log;

   /*
    * (non-Javadoc)
    * 
    * @see org.apache.maven.plugin.AbstractMojo#execute()
    */
   public void execute() throws MojoExecutionException {

      // create the PEAR packaging directory in the target directory
      this.pearPackagingDir = new File(this.targetDir, "pearPackaging");

      // save current UIMA log level
      Level level = getCurrentUIMALogLevel();
      // change UIMA log level to only log warnings and errors
      UIMAFramework.getLogger().setLevel(Level.WARNING);

      // create final PEAR file object
      File finalPearFileName = new File(this.targetDir, this.componentId
            + ".pear");

      log = getLog();
      log.info("Start building PEAR package for component " + this.componentId);
      log.debug("UIMA PEAR INFORMATION ");
      log.debug("======================");
      log.debug("main component dir:   " + this.mainComponentDir);
      log.debug("main component desc:  " + this.mainComponentDesc);
      log.debug("component id:         " + this.componentId);
      log.debug("classpath:            " + this.classpath);
      log.debug("datapath:             " + this.datapath);
      log.debug("target dir:           " + this.targetDir);
      log.debug("pear packaging dir:   "
            + this.pearPackagingDir.getAbsolutePath());
      log.debug("final PEAR file:      " + finalPearFileName.getAbsolutePath());

      // check Maven project packaging type - only jar packaging is supported
      if (!this.project.getPackaging().equals("jar")) {
         throw new MojoExecutionException(
               "Wrong packaging type, only 'jar' packaging is supported");
      }

      try {
         // copies all PEAR data to the PEAR packaging directory
         copyPearData();

         // copy created jar package to the PEAR packaging lib directory
         // get jar file name
         String jarFileName = this.project.getBuild().getFinalName() + ".jar";
         // get jar file location
         File finalJarFile = new File(this.project.getBuild().getDirectory(),
               jarFileName);
         // check if the jar file exist
         if (finalJarFile.exists()) {
            // specify the target directory for the jar file
            File target = new File(this.pearPackagingDir,
                  InstallationController.PACKAGE_LIB_DIR);
            File targetFile = new File(target, jarFileName);
            // copy the jar file to the target directory
            FileUtils.copyFile(finalJarFile, targetFile);
         } else {
            // jar file does not exist - build was not successful
            String errorMessage = "Jar package "
                  + finalJarFile.getAbsolutePath() + " not found";
            log.debug(errorMessage);
            throw new IOException(errorMessage);
         }

         // classpath handling:  
         //   1) keep order: 
         //      jar for this artifact if it exists, 
         //      followed by user-specified,
         //      followed by jars in lib
         //   2) remove duplicates
         //   3) paths that are generated are in form $main_root/lib/jar-name
         
         classpathsInOrder = new ArrayList<String>();
         classpathsDefined = new HashSet<String>();
         
         String pathToLib = String.format("$main_root/%s", InstallationController.PACKAGE_LIB_DIR);
         log.debug("pear pathToLib = " + pathToLib);
         String mainJar = String.format("%s/%s.jar", pathToLib, this.project.getBuild().getFinalName());
         
         maybeAddClasspath(mainJar);
         
         if (classpath != null && !classpath.equals("")) {
           if (classpath.indexOf(':') != -1) {
             throw new MojoExecutionException(
             "classpath: " + classpath + " must use semicolons as separators.");
           }
           String[] userClasspath = classpath.split(";");
           for (String ucp : userClasspath) {
             maybeAddClasspath(ucp);
           }
         }
         
         File libDir = new File(this.pearPackagingDir, InstallationController.PACKAGE_LIB_DIR);
         if (libDir.isDirectory()) {
           FileFilter jarFilter = new FileFilter() {
             public boolean accept(File pathname) {
               return pathname.isFile() && pathname.getAbsolutePath().toLowerCase().endsWith(".jar");
             }
           };
           File[] jars = libDir.listFiles(jarFilter);
           if (null != jars) {
             for (File jar : jars) {
               maybeAddClasspath(String.format("%s/%s", pathToLib, jar.getName()));
             }
           }
         }

         StringBuffer buffer = new StringBuffer();
         for (String cp : classpathsInOrder) {
           buffer.append(cp).append(";");
         }
         
         // add compiled jar to the PEAR classpath
         // not done here - done as part of next step
//         buffer.append(";$main_root/");
//         buffer.append(InstallationController.PACKAGE_LIB_DIR);
//         buffer.append("/");
//         buffer.append(this.project.getBuild().getFinalName());
//         buffer.append(".jar");
       
         // add lib jars to the PEAR classpath
         
         classpath = buffer.substring(0, buffer.length()-1);

//         if (this.classpath != null) {
//           this.classpath = this.classpath + ";" + classpathExtension;
//           } else {
//             this.classpath = classpathExtension.substring(1,classpathExtension.length());
//           }

         // create the PEAR package
         createPear();

         // log success message
         log.info("PEAR package for component " + this.componentId
               + " successfully created at: "
               + finalPearFileName.getAbsolutePath());

         // set UIMA logger back to the original log level
         UIMAFramework.getLogger().setLevel(level);

      } catch (PackageCreatorException e) {
         log.debug(e.getMessage());
         throw new MojoExecutionException(e.getMessage());
      } catch (IOException e) {
         log.debug(e.getMessage());
         throw new MojoExecutionException(e.getMessage());
      }

   }

  private void maybeAddClasspath(String acp) {
//    System.out.println("TEST maybeAddClasspath: " + acp);
    log.debug("pear maybe add classpath: " + acp);
    if (!classpathsDefined.contains(acp)) {
      classpathsInOrder.add(acp);
      classpathsDefined.add(acp);
    } else {
//      System.out.println("TEST duplicate found");
      log.debug("pear maybe add classpath: duplicate found");
    }
  }

   /**
    * Returns the current UIMA log level for the UIMA root logger
    * 
    * @return the current UIMA log level
    */
   private Level getCurrentUIMALogLevel() {
      if (UIMAFramework.getLogger().isLoggable(Level.ALL)) {
         return Level.ALL;
      } else if (UIMAFramework.getLogger().isLoggable(Level.FINEST)) {
         return Level.FINEST;
      } else if (UIMAFramework.getLogger().isLoggable(Level.FINER)) {
         return Level.FINER;
      } else if (UIMAFramework.getLogger().isLoggable(Level.FINE)) {
         return Level.FINE;
      } else if (UIMAFramework.getLogger().isLoggable(Level.CONFIG)) {
         return Level.CONFIG;
      } else if (UIMAFramework.getLogger().isLoggable(Level.INFO)) {
         return Level.INFO;
      } else if (UIMAFramework.getLogger().isLoggable(Level.WARNING)) {
         return Level.WARNING;
      } else if (UIMAFramework.getLogger().isLoggable(Level.SEVERE)) {
         return Level.SEVERE;
      } else {
         return Level.OFF;
      }
   }

   /**
    * Copies the given directory when available to the PEAR packaging directory
    * 
    * @param directory
    *           directory to copy
    * 
    * @throws IOException
    */
   private void copyDirIfAvailable(String directory) throws IOException {

      // check if directory exist
      File dirToCopy = new File(this.mainComponentDir, directory);
      if (dirToCopy.exists()) {
         File target = new File(this.pearPackagingDir, directory);
         FileUtils.copyDirectory(dirToCopy, target);
         // remove directories that begins with a "." -> e.g. .SVN
         removeDotDirectories(target);
      }
   }

   /**
    * Removes recursively all directories that begins with a "." e.g. ".SVN"
    * 
    * @param dir
    *           directory to check for Dot-directories
    * 
    * @throws IOException
    */
   private void removeDotDirectories(File dir) throws IOException {
      ArrayList<File> subdirs = org.apache.uima.util.FileUtils.getSubDirs(dir);

      for (int i = 0; i < subdirs.size(); i++) {
         File current = subdirs.get(i);
         if (current.getName().startsWith(".")) {
            org.apache.uima.util.FileUtils.deleteRecursive(current);
         } else {
            removeDotDirectories(current);
         }
      }
   }

   /**
    * Copies all the necessary PEAR directories (UIMA nature) to the PEAR
    * packaging directory
    * 
    * @throws IOException
    */
   private void copyPearData() throws IOException {

      // select all necessary PEAR package directories that have to be copied
      String[] dirsToCopy = new String[] {
            InstallationController.PACKAGE_CONF_DIR,
            InstallationController.PACKAGE_DATA_DIR,
            InstallationController.PACKAGE_DESC_DIR,
            InstallationController.PACKAGE_DOC_DIR,
            InstallationController.PACKAGE_LIB_DIR,
            InstallationController.PACKAGE_METADATA_DIR,
            InstallationController.PACKAGE_RESOURCES_DIR,
            /* InstallationController.PACKAGE_SOURCES_DIR , */InstallationController.PACKAGE_BIN_DIR, };

      // copies the selected directories if they exists
      for (int i = 0; i < dirsToCopy.length; i++) {
         copyDirIfAvailable(dirsToCopy[i]);
      }
   }

   /**
    * create a PEAR package with
    * 
    * @throws PackageCreatorException
    */
   private void createPear() throws PackageCreatorException {
      //generates the PEAR packages with the given information
      PackageCreator
            .generatePearPackage(this.componentId, this.mainComponentDesc,
                  this.classpath, this.datapath, this.pearPackagingDir
                        .getAbsolutePath(), this.targetDir, this.props);
   }
}
