package com.aurea.maven.plugins.sonic.utils;

 import java.io.ByteArrayInputStream;

 import java.io.File;

 import java.util.ArrayList;

 import java.util.List;

 import com.aurea.maven.plugins.sonic.sdm.container.IServiceType;

 import com.aurea.maven.plugins.sonic.sdm.container.impl.DefaultServiceType;

 import com.progress.sonic.utilities.esb.admin.XarAnalyzer;

 import com.sonicsw.deploy.IArtifact;

 import com.sonicsw.deploy.artifact.ESBArtifact;

 import com.sonicsw.deploy.artifact.SonicFSArtifact;

 /**

  * This class povides some convenience methods to analyze the dependencies that have been copied the the dependency

  * directory.

  * 

  * @author Andreas Gies

  */

 public class DependencyAnalyzer {

   private String       baseDir           = null;

   private List<String> serviceJarFiles   = null;

   /**

    * Jar files on the ServiceType 'container' classpath

    */

   private List<String> serviceCtJarFiles = null;

   private List<String> packagedJarFiles  = null;

   /**

    * Create the analyzer with the location of the dependency directory. The dependency directory contains two sub

    * directories <b>jar</b> and <b>xar</b> that contain the jar respective the xar dependencies.

    * 

    * @param _baseDir

    *          _baseDir

    */

   public DependencyAnalyzer(final String _baseDir) {

     baseDir = _baseDir;

   }

   /**

    * Calculate the file names of the dependency jar files.

    * 

    * @return An array of Strings that contains the names of the jar file locations relative to the jar-subdirectory of

    *         the dependency directory.

    */

   public final String[] getDependencyJars() {

     return FileUtilities.getFileList(getJarDependencyDir(), "**/*.jar", null);

   }

   /**

    * Calculate the list of jar files are referenced in the classpath settings of the servicetypes that occurr in the

    * dependent xar archives. The result is a list of jar files as they are stored in the directory service (i.e.

    * <b>SonicFS/ESBResources/log4j/log4j-1.2.13.jar</b>)

    * 

    * @return The list of jar files referenced by service types in the dependcy tree.

    */

   public final List<String> getServiceJarFiles() {

     // Only calculate the list once

     if (serviceJarFiles == null) {

       serviceJarFiles = new ArrayList<String>();

       serviceCtJarFiles = new ArrayList<String>();

       // Iterate over the xar archives

       for (String xarFile : FileUtilities.getFileList(getXarDependencyDir(), "**/*.xar", null)) {

         try {

           XarAnalyzer analyzer = new XarAnalyzer(new File(getXarDependencyDir() + "/" + xarFile));

           // now get the servicetypes in the xar file and record all refrenced jar files from the claspath

           for (IArtifact sTypeArtifact : analyzer.getArtifacts(ESBArtifact.SERVICE_TYPE)) {

             IServiceType sType = new DefaultServiceType();

             byte[] bytes = analyzer.getContent(sTypeArtifact);

             // in Sonic 7.6 the self first flag is not set corrctly: <xq:selfFirst/> --> bug 351

             String temp = new String(bytes);

             temp = temp.replace("<xq:selfFirst/>", "<xq:selfFirst>false</xq:selfFirst>");

             sType.load(new ByteArrayInputStream(temp.getBytes()));

             serviceJarFiles.addAll(sType.getInstanceClasspath());

             serviceJarFiles.addAll(sType.getTypeClasspath());

             serviceJarFiles.addAll(sType.getContainerClasspath());

             serviceCtJarFiles.addAll(sType.getContainerClasspath());

           }

         } catch (Exception e) {

           e.printStackTrace();

         }

       }

     }

     return serviceJarFiles;

   }

   /**

    * Get the list of jar files that are on dependent ServiceType 'container' classpath.

    * 

    * @return list of service container jar files

    */

   public final List<String> getServiceCtJarFiles() {

     if (serviceCtJarFiles == null) {

       getServiceJarFiles();

     }

     return serviceCtJarFiles;

   }

   /**

    * Calculate the list of unpackaged jar files. These are the jar files that occurr in the dependency directory, but

    * not in the list of packaged jar files.

    * 

    * @return The list of jar files that are not yet packaged.

    */

   public final List<String> getUnpackagedJarFiles() {

     List<String> result = new ArrayList<String>();

     // SF changed from SonicFS:/... to /SonicFS/ESBResources/... as that is what is returned by the SonicFSArtifact

     for (String jarFile : getDependencyJars()) {

       String toCompare = "/SonicFS/ESBResources/" + jarFile.replaceAll("\\\\", "/");

       if (!getPackagedJarFiles().contains(toCompare)) {

         result.add(jarFile);

       }

     }

     return result;

   }

   /**

    * Calculate a list of jar files that are already packaged in the dependent xar files. This will help us to avoid

    * duplpicate packaging of jars and keep the deliverables small. For now we assume that the jar files reside in the

    * <b>ESBResources</b> directory of the domain storage.

    * 

    * @return the list of packaged jar files.

    */

   public final List<String> getPackagedJarFiles() {

     if (packagedJarFiles == null) {

       packagedJarFiles = new ArrayList<String>();

       for (String xarFile : FileUtilities.getFileList(getXarDependencyDir(), "**/*.xar", null)) {

         XarAnalyzer analyzer = new XarAnalyzer(new File(getXarDependencyDir() + "/" + xarFile));

         try {

           for (IArtifact jarFile : analyzer.getArtifacts(new SonicFSArtifact("ESBResources/"))) {

             packagedJarFiles.add(jarFile.getArchivePath());

           }

         } catch (Exception e) {

           e.printStackTrace();

         }

       }

     }

     return packagedJarFiles;

   }

   /**

    * Calculate an additional ESB Container classpath. That classpath consists of the jar files that occurr in the

    * dependency directory, but are not referenced in the servicetypes of the dependent xar archives. We will only add

    * those jar files to the classpath that match a given regular expression.

    * 

    * @param _cpPattern

    *          The regular expression to select the jar files that need to be on the classpath

    * 

    * @param _existingClasspath

    *          The existing classpath as a List<String>. Any jars on this list will not be added again.

    * 

    * @param _ignoreServiceTypeDeps

    *          Whether or not to ignore

    * 

    * @return a list of urls, that can be set as the classpath attribute of an ESB Container

    */

   public final List<String> additionalContainerClassPath(final String _cpPattern,

       final List<String> _existingClasspath, final boolean _ignoreServiceTypeDeps) {

     List<String> result = new ArrayList<String>();

     if (_existingClasspath != null) {

       result.addAll(_existingClasspath);

     }

     for (String jarFile : getDependencyJars()) {

       String jarURL = "sonicfs:///ESBResources/" + jarFile.replaceAll("\\\\", "/");

       if (!(_ignoreServiceTypeDeps && getServiceJarFiles().contains(jarURL)) && !result.contains(jarURL)) {

         if (jarFile.matches(_cpPattern)) {

           result.add(jarURL);

         }

       }

     }

     /**

      * If not ignoring service type jars, also attempt to match service type jars that are on the service type level

      * container classpath.

      */

     if (!_ignoreServiceTypeDeps) {

       for (String jarURL : getServiceCtJarFiles()) {

         String jarFile = jarURL.substring(jarURL.lastIndexOf('/') + 1);

         if (jarFile.matches(_cpPattern) && !result.contains(jarURL)) {

           result.add(jarURL);

         }

       }

     }

     return result;

   }

   /**

    * Convenience method to calculate the xar file dependency location.

    * 

    * @return the xar file dependency location

    */

   public final String getXarDependencyDir() {

     return baseDir + "/xar";

   }

   /**

    * Convenience method to calculate the jar file dependency location.

    * 

    * @return the jar file dependency location

    */

   public final String getJarDependencyDir() {

     return baseDir + "/jar";

   }

 }