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

 import java.io.File;

 import java.io.FileInputStream;

 import java.util.ArrayList;

 import java.util.List;

 import java.util.Properties;

 import no.geosoft.cc.util.SmartTokenizer;

 import org.apache.maven.artifact.handler.ArtifactHandler;

 import org.apache.maven.plugin.MojoExecutionException;

 import org.apache.maven.plugin.MojoFailureException;

 import org.apache.maven.project.MavenProjectHelper;

 import org.codehaus.plexus.archiver.Archiver;

 import org.codehaus.plexus.util.xml.XmlStreamReader;

 import org.codehaus.plexus.util.xml.Xpp3Dom;

 import org.codehaus.plexus.util.xml.Xpp3DomBuilder;

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

 import com.aurea.maven.plugins.sonic.utils.FileUtilities;

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

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

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

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

 import com.progress.sonic.utilities.mfutils.MFUtils;

 import com.progress.sonic.utilities.mfutils.NullArtifactNotificationListener;

 import com.sonicsw.deploy.IArtifact;

 import com.sonicsw.deploy.artifact.ESBArtifact;

 import com.sonicsw.deploy.artifact.SonicFSArtifact;

 import com.sonicsw.deploy.storage.FileArtifactStorage;

 import com.sonicsw.deploy.tools.common.ExportPropertiesArtifact;

 import com.sonicsw.esb.mgmtapi.config.IEndpointConfig;

 /**

  * packages a Service Type project as a .zip file.

  * 

  * <ol>

  * <li>creates a .jar file containing the implementation of the Custom Service

  * and any resources</li>

  * <li>packages the ESB Service type into a xar file containing</li>

  * <li>Service Type implementation .jar</li>

  * <li>Service Type definition</li>

  * <li>Any dependent artifacts</li>

  * <li>sets the classpath for the service type appropriately</li>

  * <li>imports the service type into the local domain if present</li>

  * </ol>

  * 

  * @goal esbstyp-package

  */

 public class MavenEsbSvcPackageMojo extends EsbPackageMojo {

         private static final int DOMAIN_PING_TIMEOUT = 1000;

         /**

          * @component

          * @readonly

          */

         MavenProjectHelper projectHelper;

         /**

          * @component

          */

         ArtifactHandler handler;

         /**

          * @parameter property="sonicesb.classpathSeparator" default-value=";"

          */

         private String classpathSeparator;

         /**

          * @parameter property="sonicesb.ctClasspathPattern"

          */

         private String ctClasspathPattern = null;

         /**

          * @parameter property="sonicesb.ctPrependClasspath"

          */

         private String ctPrependClasspath = null;

         /**

          * @parameter property="sonicesb.typeClasspathPattern"

          */

         private String typeClasspathPattern = null;

         /**

          * @parameter property="sonicesb.typePrependClasspath"

          */

         private String typePrependClasspath = null;

         /**

          * @parameter property="sonicesb.instancePrependClasspath"

          */

         private String instancePrependClasspath = null;

         /**

          * @parameter property="sonicesb.instanceSelfFirst" default-value="false"

          */

         private boolean instanceSelfFirst;

         /**

          * @parameter property="sonicesb.typeSelfFirst" default-value="false"

          */

         private boolean typeSelfFirst;

         /**

          * {@inheritDoc}

          */

         protected void doExecute() throws MojoExecutionException, MojoFailureException {

                 getLog().info("Packaging ESB ServiceType ...");

                 project.getArtifact().setArtifactHandler(handler);

                 getLog().debug(project.getArtifact().getArtifactHandler().getLanguage());

                 try {

                         // File jarFile = createJarFile();

                         createJarFile();

                         super.doExecute();

                         // we don't need to publish the .jar as well as the .zip

                         // projectHelper.attachArtifact(project, "jar", null, jarFile);

                 } catch (MojoExecutionException e) {

                         getLog().error("Error packaging ESB Service Type : " + e.getMessage(), e);

                         throw new MojoExecutionException("Error packaging ESB Service Type : ", e);

                 }

         }

         private File createJarFile() throws MojoExecutionException {

                 File jarFile;

                 try {

                         String jarFileName = getPackageXarDir() + "/SonicFS/" + getSonicFSResourcesDir() + "/"

                                         + getGroupId().replaceAll("\\.", "/") + "/" + getArtifactId() + "/" + getVersion() + "/"

                                         + getFinalAssemblyBaseName() + ".jar";

                         jarFile = new File(jarFileName);

                         jarFile.getParentFile().mkdirs();

                         // arguably, the following should be done by the

                         // maven-resoruces-plugin and certainly not with a hard coded source

                         FileUtilities.copyFiles(project.getBasedir() + "/src/main/resources", getOutputDirectory() + "/classes");

                         Archiver archiver = archiverManager.getArchiver(jarFile);

                         archiver.setDestFile(jarFile);

                         archiver.addDirectory(new File(getOutputDirectory() + "/classes"));

                         archiver.createArchive();

                 } catch (Exception e) {

                         throw new MojoExecutionException("Error creating ESB Servicetype Jar file", e);

                 }

                 return jarFile;

         }

         /**

          * {@inheritDoc}

          */

         protected File createXarFile() throws Exception {

                 String xarDir = getPackageXarDir();

                 new File(xarDir).mkdirs();

                 try {

                         boolean connectedToDS = false;

                         EndpointAdmin endpointAdmin = null;

                         ServiceAdmin serviceAdmin = null;

                         if (!MFUtils.pingDomain(getManagementUrl(), DOMAIN_PING_TIMEOUT)) {

                                 getLog().warn("Could not connect to Sonic Domain at " + getManagementUrl());

                         } else {

                                 connectedToDS = true;

                                 final ESBAdmin esbAdmin = getMFUtils().getESBAdmin();

                                 serviceAdmin = new ServiceAdmin(esbAdmin.getEsbApi());

                                 endpointAdmin = new EndpointAdmin(esbAdmin.getEsbApi());

                         }

                         ArrayList<IArtifact> serviceTypes = new ArrayList<IArtifact>();

                         try {

                                 StringBuffer buf = new StringBuffer();

                                 buf.append("SonicFS/System/SonicESB/7.0/properties/servicetypes");

                                 buf.append(",");

                                 buf.append("SonicFS/System/SonicESB/7.5/properties/servicetypes");

                                 buf.append(",");

                                 buf.append("SonicFS/System/SonicESB/properties/servicetypes");

                                 FileUtilities.copyFiles(getSonicEsbSourceDirectory().getAbsolutePath(), xarDir,

                                                 "**/*.properties,**/*.gif,**/*.xml", null, buf.toString(), true);

                                 FileUtilities.copyFiles(getSonicEsbSourceDirectory().getAbsolutePath(), xarDir, "**/*.esbstyp", null,

                                                 "ESB/ServiceTypes", true);

                                 for (String srcFile : FileUtilities.getFileList(xarDir, "**/*.esbstyp", null)) {

                                         File svcFile = new File(xarDir, srcFile);

                                         Xpp3Dom svcDom = Xpp3DomBuilder.build(new XmlStreamReader(svcFile));

                                         String svcName = svcDom.getAttribute("name");

                                         serviceTypes.add(new ESBArtifact(ESBArtifact.SERVICE_TYPE, svcName));

                                         File destFile = new File(svcFile.getParentFile(), svcName + ".xml");

                                         svcFile.renameTo(destFile);

                                         if (connectedToDS) {

                                                 File serviceTypePropertiesFile = new File(xarDir

                                                                 + "/SonicFS/System/SonicESB/properties/servicetypes", svcName + ".properties");

                                                 Properties serviceTypeProperties = new Properties();

                                                 serviceTypeProperties.load(new FileInputStream(serviceTypePropertiesFile));

                                                 String serviceTypeInstance = serviceTypeProperties.getProperty("type.defaultInstance", svcName);

                                                 getLog().info("Importing '" + svcName + "' ESB Service Type in Sonic Domain");

                                                 serviceAdmin.importServiceType(destFile, serviceTypePropertiesFile, true);

                                                 String endpoint = serviceTypeInstance + ".Entry";

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

                                                         if (!endpointAdmin.isEndpointExisting(endpoint)) {

                                                                 getLog().info(

                                                                                 "Creating '" + endpoint + "' endpoint in Sonic Domain for ESB Service Type "

                                                                                                 + svcName);

                                                         }

                                                         final IEndpointConfig endpointConfig = endpointAdmin.createTopicEndpoint(endpoint);

                                                         if (!serviceAdmin.isServiceConfigExisting(serviceTypeInstance)) {

                                                                 getLog().info(

                                                                                 "Creating '" + serviceTypeInstance

                                                                                                 + "' service config in Sonic Domain for ESB Service Type " + svcName);

                                                         }

                                                         serviceAdmin.createServiceTypeConfig(serviceTypeInstance, svcName, endpointConfig, false);

                                                 }

                                         }

                                 }

                         } catch (Exception e) {

                                 throw new MojoExecutionException("Error copying files", e);

                         }

                         injectServiceClasspath(xarDir);

                         // register the esbstyps locally! reuse xar directory

                         if (serviceTypes.size() > 0) {

                                 try {

                                         FileArtifactStorage fas = new FileArtifactStorage();

                                         fas.addNotificationListener(new NullArtifactNotificationListener());

                                         fas.setRoot(xarDir);

                                         ExportPropertiesArtifact expProperties = new ExportPropertiesArtifact();

                                         // resources root e.g. JARs

                                         expProperties.addRoot(new SonicFSArtifact("/"));

                                         expProperties.addRoot(serviceTypes.toArray(new ESBArtifact[] {}));

                                         // just to make sure that no workspace related files get

                                         // imported, although that should never happen

                                         expProperties.addIgnore(new SonicFSArtifact("workspace/"));

                                         if (connectedToDS) {

                                                 new ESBArtifactCopyJob(fas, getMFUtils().getDSArtifactStorage(), expProperties, false).copy();

                                                 getLog().info("ESB Service type imported into local DS");

                                         }

                                 } catch (Exception e) {

                                         getLog().error("Failed to import ESB Service Type into local DS", e);

                                 }

                         }

                 } finally {

                         getMFUtils().cleanup();

                 }

                 return super.createXarFile();

         }

         /**

          * Get the xar exclude patterns.

          * 

          * @return xar exclude patterns

          */

         @Override

         protected String getXarExcludePatterns() {

                 if (xarExcludes != null) {

                         return xarExcludes;

                 }

                 return super.getXarExcludePatterns() + ",**/ServiceTypes/*";

         }

         private void injectServiceClasspath(final String _xarDir) throws MojoExecutionException {

                 getLog().info("Setting Service Type classpath ...");

                 String[] jarFiles = FileUtilities.getFileList(_xarDir + "/SonicFS", "**/*.jar", null);

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

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

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

                 if (typePrependClasspath != null) {

                         SmartTokenizer st = new SmartTokenizer(typePrependClasspath, classpathSeparator);

                         while (st.hasMoreTokens()) {

                                 typeJars.add(st.nextToken());

                         }

                 }

                 if (instancePrependClasspath != null) {

                         SmartTokenizer st = new SmartTokenizer(instancePrependClasspath, classpathSeparator);

                         while (st.hasMoreTokens()) {

                                 instanceJars.add(st.nextToken());

                         }

                 }

                 if (ctPrependClasspath != null) {

                         SmartTokenizer st = new SmartTokenizer(ctPrependClasspath, classpathSeparator);

                         while (st.hasMoreTokens()) {

                                 ctJars.add(st.nextToken());

                         }

                 }

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

                         String jar = jarFiles[i].replaceAll("\\\\", "/");

                         getLog().debug("TBO: Jar File: " + jar);

                         if (typeClasspathPattern != null) {

                                 getLog().debug("The Type Classpath Pattern = " + typeClasspathPattern);

                                 if (jar.matches(typeClasspathPattern)) {

                                         getLog().debug("there is a match");

                                         typeJars.add("sonicfs:///" + jar);

                                         jar = null;

                                 } else {

                                         getLog().debug("THERE IS NO MATCH");

                                 }

                         }

                         if (jar != null && ctClasspathPattern != null) {

                                 if (jar.matches(ctClasspathPattern)) {

                                         ctJars.add("sonicfs:///" + jar);

                                         jar = null;

                                 }

                         }

                         if (jar != null) {

                                 instanceJars.add("sonicfs:///" + jar);

                         }

                 }

                 String svcTypeDir = getPackageXarDir() + "/ESB/ServiceTypes";

                 String[] stFiles = FileUtilities.getFileList(svcTypeDir, "*.xml", null);

                 for (String stFileName : stFiles) {

                         getLog().debug("TBO: File Name: " + stFileName);

                         DefaultServiceType st = new DefaultServiceType();

                         File stFile = new File(svcTypeDir, stFileName);

                         try {

                                 st.load(new FileInputStream(stFile));

                                 getLog().debug("TBO: File Loaded");

                                 st.setInstanceClasspath(instanceJars, instanceSelfFirst);

                                 getLog().debug("TBO: Instance Classpath Set");

                                 st.setTypeClasspath(typeJars, typeSelfFirst);

                                 getLog().debug("TBO: Type Classpath Set");

                                 st.setContainerClasspath(ctJars);

                                 getLog().debug("TBO: File Container Path Set");

                                 st.save(stFile);

                         } catch (Exception e) {

                                 throw new MojoExecutionException(e.getMessage(), e);

                         }

                 }

         }

 }