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

 import java.io.File;

 import java.io.IOException;

 import java.util.List;

 import org.apache.maven.plugin.BuildPluginManager;

 import org.apache.maven.plugin.MojoExecutionException;

 import org.apache.maven.plugin.MojoFailureException;

 import org.codehaus.plexus.util.FileUtils;

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

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

 import com.aurea.maven.plugins.sonic.utils.xmlsorter.XMLSort;

 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.ProcessAdmin;

 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.ArtifactFactory;

 import com.sonicsw.deploy.artifact.ESBArtifact;

 import com.sonicsw.deploy.artifact.SonicFSArtifact;

 import com.sonicsw.deploy.storage.DSArtifactStorage;

 import com.sonicsw.deploy.storage.FileArtifactStorage;

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

 /**

  * 

  */

 public abstract class AbstractExportGeneratedSrcMojo extends AbstractESBConnectMojo {

         /**

          * The Maven PluginManager Object.

          * 

          * @component

          * @required

          */

         protected BuildPluginManager pluginManager;

         private static final int DOMAIN_PING_TIMEOUT = 1000;

         /**

          * Defines whether Maven should fail if the esb export failed.

          * 

          * @parameter property="sonicesb.failOnExportError" default-value="true"

          * @required

          */

         protected boolean failOnExportError;

         /**

          * Defines whether the export from the directory Service shall be skipped.

          * 

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

          * @required

          */

         protected boolean skipExport;

         /**

          * File containing definition of additional artifacts to be exported from

          * the Sonic Domain.

          * 

          * @parameter default-value="ExportProperties.xml"

          * @required

          */

         protected String exportPropFileName;

         /**

          * @return the directory for storing the generated-src (endpoints,

          *         connections, etc. Eg. /deploy/generated-src/xar)

          */

         protected abstract File getDeployGenSrcDir();

         /**

          * @return the directory containing the Processes xar structure for the

          *         current project.

          */

         protected abstract String getProjectProcessesXarDir();

         /**

          * @return the temporaroy directory to export to from the Sonic Domain,

          *         before moving it to the deploy/generated-src location.

          */

         protected abstract String getTmpExportToGeneratedSrcDir();

         /**

          * {@inheritDoc}

          */

         protected final void doExecute() throws MojoExecutionException, MojoFailureException {

                 super.doExecute();

                 try {

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

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

                                 // At this place we should inject the esbdl and lib files into

                                 // the generated source directory ....

                                 return;

                         }

                         if (!skipExport) {

                                 // export the latest version of artifacts from the Domain to the

                                 // deploy generated-src direcotry

                                 exportToDeployGeneratedSrc();

                         } else {

                                 getLog().info("Skipping export of resources from the directory Service");

                         }

                         validateGeneratedSrc();

                 } finally {

                         // cleanup/free DS resources

                         getMFUtils().cleanup();

                 }

         }

         private void validateGeneratedSrc() throws MojoExecutionException {

                 // Check for the existing of the generated sources directory

                 if (!getDeployGenSrcDir().exists() || !getDeployGenSrcDir().isDirectory()) {

                         throw new MojoExecutionException("The generated directory " + getDeployGenSrcDir()

                                         + " does not exist. Build cannot continue.");

                 }

                 // perhaps other things like the process definitions, etc could also be

                 // validated

         }

         /**

          * exports the local process files to the /deploy/generated-src directory.

          * 

          * @return true if the export succeeded.

          */

         protected void exportToDeployGeneratedSrc() throws MojoExecutionException {

                 try {

                         String tmpExportDir = getOutputDirectory() + getTmpExportToGeneratedSrcDir();

                         File tmpExportDirFile = new File(tmpExportDir);

                         tmpExportDirFile.mkdirs();

                         // export to a temporary location, so that if the export fails, the

                         // generatedSrc location isn't broken

                         FileArtifactStorage destStorage = new FileArtifactStorage();

                         destStorage.addNotificationListener(new NullArtifactNotificationListener());

                         destStorage.setRoot(tmpExportDir);

                         // get the list of artifacts to be exported

                         ExportPropertiesArtifact expProps = getExportProperties();

                         // add the list of things to ignore

                         addExportIgnores(expProps);

                         // prepare to copy from local DS to the esb export directory

                         // (filesystem)

                         DSArtifactStorage storage = getMFUtils().getDSArtifactStorage();

                         ESBArtifactCopyJob copyJob = new ESBArtifactCopyJob(storage, destStorage, expProps, failOnExportError);

                         // make sure that the destination store gets cleaned before copy

                         copyJob.setCleanBeforeCopy(true);

                         getLog().info("Exporting resources from Sonic Domain ...");

                         // "execute" the copy job

                         copyJob.copy();

                         // // tailor any SonicConnect paths

                         // tailorSonicConnectConfigs();

                         File dxsiExtractDir = new File(getDependencyDirectory(), "dxsi");

                         // File dependencyTmpDir = new File(dxsiExtractDir,

                         // "dependencyTmp");

                         File xarTmpDir = new File(dxsiExtractDir, "xarTmp");

                         FileUtilities.copyFiles(xarTmpDir.getPath(), tmpExportDir, null, null, null, false);

                         // beautify the various Sonic files

                         beautifyXarDirectory(tmpExportDirFile);

                         // copy files to the generatedSrc directory

                         // delete all files first to make sure that the resulting XAR

                         // structure does not contain any old artifacts.

                         // exclude hidden files e.g. .svn

                         getLog().info("Deleting all files from " + getDeployGenSrcDir().getPath() + " directory.");

                         FileUtilities.deleteFilesInDir(getDeployGenSrcDir().getPath(), "**/*", "**/.*");

                         // copy the exported ESB files into place

                         new File(getDeployGenSrcDir().getPath()).mkdirs();

                         getLog().info("Copying files to " + getDeployGenSrcDir().getPath() + " directory.");

                         // SFR removed +"/ESB" restriction whcih was introduced in rev 9744

                         // we have to copy SonicFS as well if there are dependencies to

                         // SonicFS artifacts

                         // this at least shows the developer that he has a missing

                         // dependency

                         // otherwise you only knwo after deployment test!

                         FileUtilities.copyFiles(tmpExportDir, getDeployGenSrcDir().getPath(), null, null, null, false);

                 } catch (Exception e) {

                         getLog().error("Export of resources failed", e);

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

                 } finally {

                         getMFUtils().cleanup();

                 }

         }

         /**

          * adds any Sonic artifacts from dependent maven artifacts to the export

          * ignores.

          * 

          * @param _expProps

          *            the export properties to be updated.

          */

         protected void addExportIgnores(final ExportPropertiesArtifact _expProps) {

                 addExportIgnoresForDependencies(_expProps);

                 // add system resources

                 IArtifact sonicfs = ArtifactFactory

                                 .createArtifact(SonicFSArtifact.TYPE, "System/SonicESB/jsHelperFunctions.js");

                 _expProps.addIgnore(sonicfs);

                 sonicfs = ArtifactFactory.createArtifact(SonicFSArtifact.TYPE, "System/SonicESB/7.6/jsHelperFunctions.js");

                 _expProps.addIgnore(sonicfs);

                 sonicfs = ArtifactFactory.createArtifact(SonicFSArtifact.TYPE,

                                 "System/SonicESB/7.6/Common/jsHelperFunctions.js");

                 _expProps.addIgnore(sonicfs);

                 // // Ignore Sonic Connect Service Type

                 // sonicfs = ArtifactFactory.createArtifact(ESBArtifact.SERVICE_TYPE,

                 // "SonicConnect");

                 // _expProps.addIgnore(sonicfs);

                 //

                 // Finally add our own Sonicfs root to the ignores

                 sonicfs = ArtifactFactory.createArtifact(SonicFSArtifact.TYPE, "workspace/" + getProjectName() + "/");

                 _expProps.addIgnore(sonicfs);

                 getLog().info("Done...Building Artifact ignore List from Dependencies : ...");

         }

         /**

          * @return the export properties for the pending export, by reading any

          *         ExportProperties.xml file (if one is defined) and adding the

          *         local processes.

          */

         protected ExportPropertiesArtifact getExportProperties() throws MojoExecutionException {

                 ExportPropertiesArtifact expProps = new ExportPropertiesArtifact();

                 File expPropFile = getExportPropFile();

                 try {

                         getLog().debug("TBO ---- File Information: " + expPropFile.getAbsolutePath());

                         if (expPropFile.exists() && expPropFile.isFile() && expPropFile.canRead()) {

                                 expProps.init(expPropFile);

                                 // expProps.addIgnore(ExportPropertiesArtifact.DEFAULT_IGNORE);

                                 expProps.addIgnore(ExportPropertiesArtifact.getDefaultIgnore());

                                 getLog().info("Using existing property file : " + getExportPropFile());

                         }

                 } catch (Exception e) {

                         getLog().warn("Error reading " + getExportPropFile() + "! Will not use it.");

                         expProps = new ExportPropertiesArtifact();

                 }

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

                 final ProcessAdmin processAdmin = new ProcessAdmin(esbAdmin.getEsbApi());

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

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

                 try {

                         getLog().info("Scan for local service configurations to be included in domain export...");

                         for (File serviceFile : ProjectAnalyzer.getServiceConfigSourceFiles(getSonicEsbSourceDirectory()

                                         .getAbsolutePath())) {

                                 String serviceConfigName = ProjectAnalyzer.getServiceConfigNameFromFile(serviceFile);

                                 getLog().info("Found ESB Service Configuration : " + serviceConfigName);

                                 getLog().info("Importing '" + serviceConfigName + "' service config in Sonic Domain");

                                 serviceAdmin.importServiceConfig(serviceFile, true);

                                 String endpoint = ProjectAnalyzer.getServiceConfigEntryRefFromFile(serviceFile);

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

                                         getLog().info(

                                                         "Creating '" + endpoint + "' endpoint in Sonic Domain for ESB Service " + serviceConfigName);

                                         endpointAdmin.createTopicEndpoint(endpoint);

                                 }

                                 IArtifact artifact = new ESBArtifact(ESBArtifact.SERVICE, serviceConfigName);

                                 expProps.addRoot(artifact);

                         }

                         getLog().info("Scan for Sonic Connect service configuration to be included in domain export...");

                         File defaultSonicConnectServiceConfig = new File(project.getBasedir(), connectServiceLocation);

                         if (defaultSonicConnectServiceConfig.exists()) {

                                 String serviceConfigName = ProjectAnalyzer

                                                 .getServiceConfigNameFromFile(defaultSonicConnectServiceConfig);

                                 getLog().info("Found ESB Service Configuration : " + serviceConfigName);

                                 getLog().info("Importing '" + serviceConfigName + "' service config in Sonic Domain");

                                 serviceAdmin.importServiceConfig(defaultSonicConnectServiceConfig, true);

                                 String endpoint = ProjectAnalyzer.getServiceConfigEntryRefFromFile(defaultSonicConnectServiceConfig);

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

                                         getLog().info(

                                                         "Creating '" + endpoint + "' endpoint in Sonic Domain for ESB Service " + serviceConfigName);

                                         endpointAdmin.createTopicEndpoint(endpoint);

                                 }

                                 IArtifact artifact = new ESBArtifact(ESBArtifact.SERVICE, serviceConfigName);

                                 expProps.addRoot(artifact);

                         }

                         getLog().info("Scan for local processes to be included in domain export...");

                         for (File processFile : ProjectAnalyzer.getProcessSourceFiles(getSonicEsbSourceDirectory()

                                         .getAbsolutePath())) {

                                 String processName = ProjectAnalyzer.getProcessNameFromFile(processFile);

                                 getLog().info("Found ESB Process : " + processName);

                                 getLog().info("Importing '" + processName + "' process in Sonic Domain");

                                 processAdmin.importProcess(processFile, true);

                                 IArtifact artifact = new ESBArtifact(ESBArtifact.PROCESS, processName);

                                 expProps.addRoot(artifact);

                         }

                 } catch (Exception e) {

                         getLog().warn("Using empty root list as export properties");

                         getLog().debug(e);

                         expProps = new ExportPropertiesArtifact();

                 }

                 return expProps;

         }

         /**

          * @return the file containing the definition of any addition artifacts to

          *         be exported from the Sonic Domain.

          */

         protected File getExportPropFile() {

                 return new File(getSonicEsbSourceDirectory(), exportPropFileName);

         }

         private void beautifyXarDirectory(final File xarDir) {

                 getLog().info("Beautifying ESB artifacts");

                 String[] dirsToBeautify = { "ESB/Endpoints", "ESB/Services" };

                 for (String dir : dirsToBeautify) {

                         File workDir = new File(xarDir, dir);

                         if (workDir.canRead()) {

                                 try {

                                         List<File> workFiles = FileUtils.getFiles(workDir, "*.xml", "", true);

                                         for (File workFile : workFiles) {

                                                 getLog().debug("Beautifying file " + workFile.getName());

                                                 XMLSort.sortXMLFile(workFile);

                                         }

                                 } catch (IOException e) {

                                         getLog().error(e);

                                 }

                         }

                 }

         }

 }