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

 import java.io.ByteArrayOutputStream;

 import java.io.File;

 import java.io.FileInputStream;

 import java.io.FileNotFoundException;

 import java.io.FileOutputStream;

 import java.io.FilenameFilter;

 import java.io.IOException;

 import java.io.ObjectInputStream;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.Collections;

 import java.util.Enumeration;

 import java.util.HashMap;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Map;

 import java.util.Properties;

 import java.util.SortedSet;

 import java.util.TreeSet;

 import java.util.regex.Matcher;

 import java.util.regex.Pattern;

 import javax.xml.XMLConstants;

 import javax.xml.transform.stream.StreamSource;

 import javax.xml.validation.Schema;

 import javax.xml.validation.SchemaFactory;

 import no.geosoft.cc.util.SmartTokenizer;

 import org.apache.maven.execution.MavenSession;

 import org.apache.maven.plugin.BuildPluginManager;

 import org.apache.maven.plugin.MojoExecutionException;

 import org.apache.maven.plugin.MojoFailureException;

 import org.codehaus.plexus.archiver.Archiver;

 import org.codehaus.plexus.archiver.manager.ArchiverManager;

 import org.codehaus.plexus.util.StringUtils;

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

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

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

 import org.codehaus.plexus.util.xml.pull.XmlPullParserException;

 import org.twdata.maven.mojoexecutor.MojoExecutor;

 import org.xml.sax.SAXException;

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

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

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

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

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

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

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

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

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

 import com.aurea.maven.plugins.sonic.topology.utils.ParameterHandlingException;

 import com.aurea.maven.plugins.sonic.topology.utils.TopologyHolder;

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

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

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

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

 import commonj.sdo.DataObject;

 /**

  * This Mojo is responsible for generating the SDM Model, by collecting the xar

  * files and analysing them to update the Model.xml file appropriately.

  * 

  * @goal sdm-generate-model

  */

 // TODO: Implement a SDM SDO ????

 public class SdmGenerateModelMojo extends AbstractSdmMojo {

         /**

          * The Maven Session Object.

          * 

          * @parameter default-value="${session}"

          * @required

          * @readonly

          */

         private MavenSession session;

         /**

          * The Maven PluginManager Object.

          * 

          * @component

          * @required

          */

         protected BuildPluginManager pluginManager;

         /**

          * The Sonic Target Version Definition. (not used)

          * 

          * @parameter default-value="2015"

          * @required

          */

         protected String sonicTarget;

         /**

          * The Sonic ESB Container Definition.

          * 

          * @parameter default-value="src/main/sonicesb/ContainerProperties.xml"

          * @required

          */

         protected File containerPropFile;

         /**

          * The parameter to manipulate in-line ESB Container generation

          * 

          * @parameter property="sonicesb.isInlineGeneration"

          *            default-value="true"

          * @required

          */

         protected boolean isInlineGeneration;

         /**

          * The parameter to manipulate in-line ESB Container generation

          * 

          * @parameter property="sonicesb.ESBContainerClasspathOverride"

          *            default-value=""

          */

         protected String eSBContainerClasspathOverride;

         /**

          * Queue mappings file, to map queues to Queues elements in the model.

          * 

          * @parameter default-value="src/main/sonicesb/QueueMappings.xml"

          * @required

          */

         protected File queueMappingsFile;

         /**

          * Booelan to determine the extra generation of a properties file .....

          * 

          * @parameter property="sonicesb.forcePropertyGeneration"

          *            default-value="false"

          * @required

          */

         protected boolean forcePropertyGeneration;

         /**

          * To look up Archiver/UnArchiver implementations.

          * 

          * @component

          * @required

          */

         protected ArchiverManager archiverManager;

         /**

          * CSV File location in order to generate topology files based from an

          * external file.

          * 

          * @parameter default-value="topology"

          * @required

          */

         protected File topogenDir;

         /**

          * @parameter

          * @required

          */

         protected DefaultContainerMap containerMap;

         private Collection<IESBContainer> esbContainers, cleanEsbContainer;

         private DependencyAnalyzer depAnalyzer = null;

         private HashMap<String, String> ContainerIncludeFiles;

         private ArrayList<String> containerSubst;

         private static final String DEFAULT_SDM_HOST_VALUE = "ESBHost";

         private static final String DEFAULT_XAR_HOST_VALUE = "XARHost";

         HashMap <String, ArrayList<String>>  ESBtoMFMapping = new HashMap<String,ArrayList<String>>(); 

         /**

          * This method is called from the framework to actually perform the work.

          * 

          * @throws MojoExecutionException

          *             MojoExecutionException

          * @throws MojoFailureException

          *             MojoFailureException

          */

         @Override

         protected void doExecute() throws MojoExecutionException,

                         MojoFailureException {

                 try {

                         getLog().info("Generating updated SDM model ...");

                         getTargetSDMDir().mkdirs();

                         // Now create the xar archive that will contain the Container

                         // definitions

                         // generateContainerXar();

                         // Check if topology project output is present.

                         File depdir = new File(getDependencyDirectory(),

                                         topogenDir.getName());

                         if (!depdir.exists()) {

                                 // Now we generate a generated tailoring file as a template for

                                 // environment specific properties

                                 performOldResourceHandling();

                                 // Now we need to rewrite the Model.xml file in order to reflect

                                 // the

                                 // additional settings for

                                 // containers, queues and xar archives.

                                 createSDMModel();

                                 //if (sonicTarget.equals("8")) {

                                         createTopology();

                                         generateMasterTopology();

                                         if (forcePropertyGeneration) {

                                                 createProperties();

                                         }

 //                                } else {

 //                                        createProperties();

 //                                }

                         } else {

                                 performNewResourceHandling();

                                 createSDMModel();

                                 createTopologyWithDefault();

                                 generateMasterTopologyFromDefaultTopology();

                                 if (forcePropertyGeneration) {

                                         createProperties();

                                 }

                                 // createTopology();

                                 // generateMasterTopology();

                         }

                 } catch (final MojoExecutionException e) {

                         e.printStackTrace();

                         throw new MojoExecutionException("Error creating SDM Model - "

                                         + e.getMessage(), e.getCause());

                 } catch (final Exception e) {

                         e.printStackTrace();

                         throw new MojoExecutionException("Error creating SDM Model - "

                                         + e.getMessage(), e);

                 }

         }

         private void updateTailoringProperties() throws MojoExecutionException {

                 Properties generatedProperties = null;

                 Properties updateProperties = null;

                 try {

                         generatedProperties = new Properties();

                         FileInputStream fis = new FileInputStream(getGeneratedPropertiesFile());

                         generatedProperties.load(fis);

                         fis.close();

                 } catch (Exception e) {

                         throw new MojoExecutionException("Could not read generated properties files: "

                                         + getGeneratedPropertiesFile());

                 }

                 for (String toUpdate : FileUtilities.getFileList(getTargetSDMDir().getAbsolutePath(), "*.tailoring.properties",

                                 "generated.tailoring.properties")) {

                         try {

                                 getLog().info("------------------------------------------------------------------------");

                                 getLog().info("Updating property file: " + toUpdate);

                                 updateProperties = new Properties();

                                 FileInputStream fis = new FileInputStream(getTargetSDMDir() + "/" + toUpdate);

                                 updateProperties.load(fis);

                                 fis.close();

                                 boolean updated = false;

                                 for (final Object parameter : generatedProperties.keySet()) {

                                         final String parameterName = parameter.toString();

                                         if (!updateProperties.containsKey(parameterName)) {

                                                 if (getLog().isDebugEnabled()) { 

                                                         getLog().debug("Found "+parameterName+" property with value "+generatedProperties.getProperty(parameterName));

                                                 }

                                                 updateProperties.put(parameterName, generatedProperties.getProperty(parameterName));

                                                 updated = true;

                                         }

                                 }

                                 if (updated) {

                                         @SuppressWarnings("serial")

                         final Properties sortedProperties = new Properties() {

                                 @Override

                                 public synchronized Enumeration<Object> keys() {

                                         return Collections.enumeration(new TreeSet<Object>(super.keySet()));

                                 }

                         };

                         sortedProperties.putAll(updateProperties);

                         try (FileOutputStream fos = new FileOutputStream(getTargetSDMDir() + "/" + toUpdate)) {

                                 sortedProperties.store(fos, "Generated by maven-sonicesb-plugin:sdm-generate-model");

                         }

                                 }

                         } catch (Exception e) {

                                 getLog().warn("Could not read " + getTargetSDMDir() + "/" + toUpdate);

                         }

                 }

         }

         private void generateMasterTopologyFromDefaultTopology() throws Exception {

                 // Check for existing Topology File

                 final File topo = getMasterTopologyFile();

                 if (topo.exists()) {

                         getLog().info("Topology file is existing ... will NOT Override");

                         return;

                 }

                 final Properties props = assemblePropertyList();

                 TopologyHolder tHolder = getTopologyHolder(new File(

                                 getDependencyDirectory(), getTargetTopologyDir().getName()

                                                 + File.separator + defaultTopologyPrefix + ".topo.ser"));

                 final SortedSet<String> propNames = new TreeSet<String>();

                 for (final Enumeration<Object> en = props.keys(); en.hasMoreElements();) {

                         propNames.add((String) en.nextElement());

                 }

                 getLog().info(

                                 "Topology File not found ... Generating new Master Topology File");

                 // Build up the Tree

                 final Xpp3Dom topology = new Xpp3Dom("Topology");

                 Xpp3Dom includeDom = new Xpp3Dom("Id");

                 final Xpp3Dom parameters = new Xpp3Dom("Parameters");

                 // Xpp3Dom child = null;

                 Xpp3Dom paramId = null;

                 Xpp3Dom defaultValue = null;

                 Xpp3Dom parameter = null;

                 topology.setAttribute("xmlns:xsi",

                                 "http://www.w3.org/2001/XMLSchema-instance");

                 topology.setAttribute("xsi:noNamespaceSchemaLocation", "Topology.xsd");

                 topology.setAttribute("xmlns:xi", "http://www.w3.org/2001/XInclude");

                 for (final String key : propNames) {

                         // bos.write((key + "=" + props.get(key) + "\n").getBytes());

                         parameter = new Xpp3Dom("Parameter");

                         paramId = new Xpp3Dom("Id");

                         paramId.setValue(key);

                         defaultValue = new Xpp3Dom("DefaultValue");

                         try {

                                 defaultValue.setValue(tHolder.getPholder().getParameter(key));

                                 getLog().debug("Master Topo Parameter found ...  " + key);

                         } catch (ParameterHandlingException e) {

                                 getLog().debug(

                                                 "Master Topo Parameter not found ... setting default from xml : "

                                                                 + key);

                                 final String keyValue = props.getProperty(key);

                                 if (keyValue == null) {

                                         //defaultValue.setValue("54321");

                                 } else {

                                         defaultValue.setValue(props.getProperty(key));

                                 }

                         }

                         parameter.addChild(paramId);

                         parameter.addChild(defaultValue);

                         parameters.addChild(parameter);

                 }

                 topology.addChild(parameters);

                 for (final String toCompare : FileUtilities.getFileList(

                                 getTargetSDMDir().getAbsolutePath(), "*.Topology.xml",

                                 "generated.Topology.xml")) {

                         includeDom = new Xpp3Dom("xi:include");

                         includeDom.setAttribute("href", toCompare);

                         topology.addChild(includeDom);

                 }

                 final Xpp3Dom environment = new Xpp3Dom("Environment");

                 final Xpp3Dom envId = new Xpp3Dom("Id");

                 envId.setValue("default");

                 environment.addChild(envId);

                 final Xpp3Dom machines = new Xpp3Dom("Machines");

                 final Xpp3Dom machine = new Xpp3Dom("Machine");

                 final Xpp3Dom machineId = new Xpp3Dom("Id");

                 machineId.setValue("localhost");

                 machine.addChild(machineId);

                 final Xpp3Dom altId = new Xpp3Dom("AlternateId");

                 altId.setValue("127.0.0.1");

                 machine.addChild(altId);

                 final Xpp3Dom altId2 = new Xpp3Dom("AlternateId");

                 altId2.setValue("::1");

                 machine.addChild(altId2);

                 machines.addChild(machine);

                 environment.addChild(machines);

                 topology.addChild(environment);

                 FileUtilities.writeFile(topology.toString().getBytes(),

                                 getMasterTopologyFile());

         }

         private Properties assemblePropertyList() throws Exception {

                 Properties props = new Properties();

                 // Get the variable names from the model

                 final List<String> varNames = new ArrayList<String>();

                 final XmlStreamReader reader = new XmlStreamReader(new File(

                                 getTargetSDMDir(), "Model.xml"));

                 final Xpp3Dom modelDom = Xpp3DomBuilder.build(reader);

                 getVariableNamesFromModel(modelDom, varNames);

                 // TBO: Stripping the parameters from the defaultTuning.xml

                 File propfile = new File(getTargetSDMDir(), "DefaultTuning.xml");

                 if (propfile.exists()) {

                         final XmlStreamReader propreader = new XmlStreamReader(new File(

                                         getTargetSDMDir(), "DefaultTuning.xml"));

                         final Xpp3Dom propmodelDom = Xpp3DomBuilder.build(propreader);

                         getVariableNamesFromModel(propmodelDom, varNames);

                 }

                 // TBO: Stripping the parameters from the Tuning.xml

                 File tunefile = new File(getTargetSDMDir(), "Tuning.xml");

                 if (tunefile.exists()) {

                         final XmlStreamReader tunereader = new XmlStreamReader(new File(

                                         getTargetSDMDir(), "Tuning.xml"));

                         final Xpp3Dom tunemodelDom = Xpp3DomBuilder.build(tunereader);

                         getVariableNamesFromModel(tunemodelDom, varNames);

                 }

                 // TBO: Stripping the parameters from the ContainerProperties.xml

                 // File containerfile = containerPropFile;

                 if (containerPropFile.exists()) {

                         getLog().debug("CHECKING THE CONTAINER PROPERTIES FILE");

                         final XmlStreamReader tunereader = new XmlStreamReader(

                                         containerPropFile);

                         final Xpp3Dom tunemodelDom = Xpp3DomBuilder.build(tunereader);

                         getVariableNamesFromModel(tunemodelDom, varNames);

                 }

                 for (final String varName : varNames) {

                         getLog().info("Found Variable Name: " + varName);

                         props.put(varName, "");

                 }

                 // Get the variable resolution from the dependencies

                 for (final Xpp3Dom variable : Xpp3Utils.collectElements(

                                 getDependencyDirectory(), "**/*.variables.snippet")) {

                         final String name = variable.getAttribute("name");

                         final String value = variable.getValue();

                         getLog().debug("Setting variable: [" + name + "] = [" + value + "]");

                         props.put(name, value != null ? value : "");

                 }

                 return props;

         }

         private TopologyHolder getTopologyHolder(File fileName) throws Exception {

                 TopologyHolder tHolder = null;

                 ObjectInputStream ois = null;

                 File topoDefault = fileName;

                 try {

                         ois = new ObjectInputStream(new FileInputStream(topoDefault));

                         tHolder = (TopologyHolder) ois.readObject();

                         // ois.close();

                 } catch (FileNotFoundException e) {

                         // TODO Auto-generated catch block

                         e.printStackTrace();

                         throw new MojoExecutionException(

                                         "Error creating SDM Model - Default topology file not found");

                 } catch (IOException e) {

                         // TODO Auto-generated catch block

                         e.printStackTrace();

                         throw new MojoExecutionException(

                                         "Error creating SDM Model - File Handling Issues");

                 } catch (ClassNotFoundException e) {

                         // TODO Auto-generated catch block

                         e.printStackTrace();

                         throw new MojoExecutionException(

                                         "Error creating SDM Model - Topology Classes not found");

                 } finally {

                         ois.close();

                 }

                 return tHolder;

         }

         private void createTopologyWithDefault() throws Exception {

                 // find the topology serialized default value

                 TopologyHolder tHolder = getTopologyHolder(new File(

                                 getDependencyDirectory(), getTargetTopologyDir().getName()

                                                 + File.separator + defaultTopologyPrefix + ".topo.ser"));

                 getLog().info("Creating generated.Topology.xml");

                 final Properties props = assemblePropertyList();

                 final SortedSet<String> propNames = new TreeSet<String>();

                 for (final Enumeration<Object> en = props.keys(); en.hasMoreElements();) {

                         propNames.add((String) en.nextElement());

                 }

                 final Xpp3Dom topology = new Xpp3Dom("Environment");

                 final Xpp3Dom id = new Xpp3Dom("Id");

                 final Xpp3Dom machines = new Xpp3Dom("Machines");

                 final Xpp3Dom machine = new Xpp3Dom("Machine");

                 final Xpp3Dom parameters = new Xpp3Dom("Parameters");

                 id.setValue("GeneratedTopology");

                 topology.addChild(id);

                 machines.addChild(machine);

                 Xpp3Dom element = null;

                 Xpp3Dom child = null;

                 Xpp3Dom paramId = null;

                 Xpp3Dom defaultValue = null;

                 Xpp3Dom parameter = null;

                 element = new Xpp3Dom("Id");

                 element.setValue("Generated_Machine");

                 machine.addChild(element);

                 element = new Xpp3Dom("AlternateId");

                 element.setValue("Generated_Alternate");

                 machine.addChild(element);

                 element = new Xpp3Dom("LogicalHosts");

                 machine.addChild(element);

                 child = new Xpp3Dom("LogicalHost");

                 child.setValue("GeneratedHost");

                 element.addChild(child);

                 element = new Xpp3Dom("Settings");

                 topology.addChild(machines);

                 topology.addChild(element);

                 topology.addChild(parameters);

                 for (final String key : propNames) {

                         // bos.write((key + "=" + props.get(key) + "\n").getBytes());

                         parameter = new Xpp3Dom("Parameter");

                         paramId = new Xpp3Dom("Id");

                         paramId.setValue(key);

                         defaultValue = new Xpp3Dom("Value");

                         // defaultValue.setValue(props.getProperty(key));

                         try {

                                 defaultValue.setValue(tHolder.getPholder().getParameter(key));

                                 getLog().debug("Parameter found ...  " + key);

                         } catch (ParameterHandlingException e) {

                                 getLog().debug(

                                                 "Parameter not found ... setting default from xml : "

                                                                 + key);

                                 defaultValue.setValue(props.getProperty(key));

                         }

                         parameter.addChild(paramId);

                         parameter.addChild(defaultValue);

                         parameters.addChild(parameter);

                 }

                 FileUtilities.writeFile(topology.toString().getBytes(),

                                 getGeneratedTopologyFile());

                 getLog().info(

                                 "Building the remaining Topology Files as they are found in the /toplogy Directory");

                 File topodir = new File(getDependencyDirectory(),

                                 getTargetTopologyDir().getName());

                 FilenameFilter myFileNameFilter = new FilenameFilter() {

                         public boolean accept(File dir, String name) {

                                 if (name.endsWith(".topo.ser")

                                                 && !name.equals(defaultTopologyPrefix + ".topo.ser")) {

                                         return true;

                                 }

                                 return false;

                         }

                 };

                 File[] topoFiles = topodir.listFiles(myFileNameFilter);

                 for (File file : topoFiles) {

                         getLog().info("Topo Ser File Found: " + file.getName());

                         TopologyHolder envTopoHolder = getTopologyHolder(new File(

                                         getDependencyDirectory(), getTargetTopologyDir().getName()

                                                         + File.separator + file.getName()));

                         getLog().info("Creating " + file.getName() + ".Topology.xml files");

                         String topoenv = envTopoHolder.createEnvironmentTopology(tHolder,

                                         propNames);

                         FileUtilities.writeFile(topoenv.getBytes(), getTargetSDMDir()

                                         + File.separator + envTopoHolder.getTopologyId()

                                         + ".Topology.xml");

                 }

         }

         private void performNewResourceHandling() throws MojoExecutionException {

                 getLog().info(

                                 "Copying resources from " + getSonicEsbSourceDirectory()

                                                 + " to " + getTargetSDMDir().getAbsolutePath());

                 MojoExecutor

                                 .executeMojo(

                                                 MojoExecutor.plugin(MojoExecutor

                                                                 .groupId("org.apache.maven.plugins"),

                                                                 MojoExecutor

                                                                                 .artifactId("maven-resources-plugin"),

                                                                 MojoExecutor.version("2.4.3")),

                                                 MojoExecutor.goal("copy-resources"),

                                                 MojoExecutor.configuration(new MojoExecutor.Element[] {

                                                                 MojoExecutor.element(

                                                                                 MojoExecutor.name("outputDirectory"),

                                                                                 getTargetSDMDir().getAbsolutePath()),

                                                                 MojoExecutor.element(

                                                                                 "resources",

                                                                                 MojoExecutor

                                                                                                 .element(

                                                                                                                 "resource",

                                                                                                                 MojoExecutor

                                                                                                                                 .element(

                                                                                                                                                 "directory",

                                                                                                                                                 getSonicEsbSourceDirectory()

                                                                                                                                                                 .getAbsolutePath()),

                                                                                                                 MojoExecutor

                                                                                                                                 .element(

                                                                                                                                                 "excludes",

                                                                                                                                                 new MojoExecutor.Element[] {

                                                                                                                                                                 MojoExecutor

                                                                                                                                                                                 .element(

                                                                                                                                                                                                 "exclude",

                                                                                                                                                                                                 containerPropFile

                                                                                                                                                                                                                 .getName()),

                                                                                                                                                                 MojoExecutor

                                                                                                                                                                                 .element(

                                                                                                                                                                                                 "exclude",

                                                                                                                                                                                                 queueMappingsFile

                                                                                                                                                                                                                 .getName()),

                                                                                                                                                                 MojoExecutor

                                                                                                                                                                                 .element(

                                                                                                                                                                                                 "exclude",

                                                                                                                                                                                                 "*.Topology.xml") }),

                                                                                                                 MojoExecutor.element(

                                                                                                                                 "filtering",

                                                                                                                                 "false"))) }),

                                                 MojoExecutor.executionEnvironment(project, session,

                                                                 pluginManager));

                 getLog().info("Filtering the following resources: " + "Model.xml");

                 MojoExecutor.executeMojo(MojoExecutor.plugin(

                                 MojoExecutor.groupId("org.apache.maven.plugins"),

                                 MojoExecutor.artifactId("maven-resources-plugin"),

                                 MojoExecutor.version("2.4.3")), MojoExecutor

                                 .goal("copy-resources"), MojoExecutor

                                 .configuration(new MojoExecutor.Element[] {

                                                 MojoExecutor.element(

                                                                 MojoExecutor.name("outputDirectory"),

                                                                 getTargetSDMDir().getAbsolutePath()),

                                                 MojoExecutor.element(MojoExecutor.name("overwrite"),

                                                                 "true"),

                                                 MojoExecutor.element("escapeString", "\\"),

                                                 MojoExecutor.element("resources", MojoExecutor.element(

                                                                 "resource", MojoExecutor.element("directory",

                                                                                 getSonicEsbSourceDirectory()

                                                                                                 .getAbsolutePath()),

                                                                 MojoExecutor.element(

                                                                                 "includes",

                                                                                 new MojoExecutor.Element[] {

                                                                                                 MojoExecutor.element("include",

                                                                                                                 "Model.xml"),

                                                                                                 MojoExecutor.element("include",

                                                                                                                 "*.properties"),

                                                                                                 MojoExecutor.element("include",

                                                                                                                 "*Deletes.xml"),

                                                                                                 MojoExecutor.element("include",

                                                                                                                 "*Rollback.xml") }),

                                                                 MojoExecutor.element("filtering", "true"))) }),

                                 MojoExecutor.executionEnvironment(project, session,

                                                 pluginManager));

                 getLog().info("Filtering the following resources: " + "Tuning.xml");

                 MojoExecutor

                                 .executeMojo(

                                                 MojoExecutor.plugin(MojoExecutor

                                                                 .groupId("org.apache.maven.plugins"),

                                                                 MojoExecutor

                                                                                 .artifactId("maven-resources-plugin"),

                                                                 MojoExecutor.version("2.4.3")),

                                                 MojoExecutor.goal("copy-resources"),

                                                 MojoExecutor.configuration(new MojoExecutor.Element[] {

                                                                 MojoExecutor.element(

                                                                                 MojoExecutor.name("outputDirectory"),

                                                                                 getTargetSDMDir().getAbsolutePath()),

                                                                 MojoExecutor.element(

                                                                                 MojoExecutor.name("overwrite"), "true"),

                                                                 MojoExecutor.element("escapeString", "\\"),

                                                                 MojoExecutor.element(

                                                                                 "resources",

                                                                                 MojoExecutor

                                                                                                 .element(

                                                                                                                 "resource",

                                                                                                                 MojoExecutor

                                                                                                                                 .element(

                                                                                                                                                 "directory",

                                                                                                                                                 getSonicEsbSourceDirectory()

                                                                                                                                                                 .getAbsolutePath()),

                                                                                                                 MojoExecutor

                                                                                                                                 .element(

                                                                                                                                                 "includes",

                                                                                                                                                 new MojoExecutor.Element[] { MojoExecutor

                                                                                                                                                                 .element(

                                                                                                                                                                                 "include",

                                                                                                                                                                                 "Tuning.xml") }),

                                                                                                                 MojoExecutor.element(

                                                                                                                                 "filtering",

                                                                                                                                 "false"))) }),

                                                 MojoExecutor.executionEnvironment(project, session,

                                                                 pluginManager));

         }

         private void performOldResourceHandling() throws MojoExecutionException {

                 getLog().info(

                                 "Copying resources from " + getSonicEsbSourceDirectory()

                                                 + " to " + getTargetSDMDir().getAbsolutePath());

                 MojoExecutor

                                 .executeMojo(

                                                 MojoExecutor.plugin(MojoExecutor

                                                                 .groupId("org.apache.maven.plugins"),

                                                                 MojoExecutor

                                                                                 .artifactId("maven-resources-plugin"),

                                                                 MojoExecutor.version("2.4.3")),

                                                 MojoExecutor.goal("copy-resources"),

                                                 MojoExecutor.configuration(new MojoExecutor.Element[] {

                                                                 MojoExecutor.element(

                                                                                 MojoExecutor.name("outputDirectory"),

                                                                                 getTargetSDMDir().getAbsolutePath()),

                                                                 MojoExecutor.element(

                                                                                 MojoExecutor.name("overwrite"), "true"),

                                                                 MojoExecutor.element(

                                                                                 "resources",

                                                                                 MojoExecutor

                                                                                                 .element(

                                                                                                                 "resource",

                                                                                                                 MojoExecutor

                                                                                                                                 .element(

                                                                                                                                                 "directory",

                                                                                                                                                 getSonicEsbSourceDirectory()

                                                                                                                                                                 .getAbsolutePath()),

                                                                                                                 MojoExecutor

                                                                                                                                 .element(

                                                                                                                                                 "excludes",

                                                                                                                                                 new MojoExecutor.Element[] {

                                                                                                                                                                 MojoExecutor

                                                                                                                                                                                 .element(

                                                                                                                                                                                                 "exclude",

                                                                                                                                                                                                 containerPropFile

                                                                                                                                                                                                                 .getName()),

                                                                                                                                                                 MojoExecutor

                                                                                                                                                                                 .element(

                                                                                                                                                                                                 "exclude",

                                                                                                                                                                                                 queueMappingsFile

                                                                                                                                                                                                                 .getName()) }),

                                                                                                                 MojoExecutor.element(

                                                                                                                                 "filtering",

                                                                                                                                 "false"))) }),

                                                 MojoExecutor.executionEnvironment(project, session,

                                                                 pluginManager));

                 getLog().info("Filtering the following resources: " + "Model.xml");

                 MojoExecutor.executeMojo(MojoExecutor.plugin(

                                 MojoExecutor.groupId("org.apache.maven.plugins"),

                                 MojoExecutor.artifactId("maven-resources-plugin"),

                                 MojoExecutor.version("2.4.3")), MojoExecutor

                                 .goal("copy-resources"), MojoExecutor

                                 .configuration(new MojoExecutor.Element[] {

                                                 MojoExecutor.element(

                                                                 MojoExecutor.name("outputDirectory"),

                                                                 getTargetSDMDir().getAbsolutePath()),

                                                 MojoExecutor.element(MojoExecutor.name("overwrite"),

                                                                 "true"),

                                                 MojoExecutor.element("escapeString", "\\"),

                                                 MojoExecutor.element("resources", MojoExecutor.element(

                                                                 "resource", MojoExecutor.element("directory",

                                                                                 getSonicEsbSourceDirectory()

                                                                                                 .getAbsolutePath()),

                                                                 MojoExecutor.element(

                                                                                 "includes",

                                                                                 new MojoExecutor.Element[] {

                                                                                                 MojoExecutor.element("include",

                                                                                                                 "Model.xml"),

                                                                                                 MojoExecutor.element("include",

                                                                                                                 "*.properties"),

                                                                                                 MojoExecutor.element("include",

                                                                                                                 "*Deletes.xml"),

                                                                                                 MojoExecutor.element("include",

                                                                                                                 "*Rollback.xml") }),

                                                                 MojoExecutor.element("filtering", "true"))) }),

                                 MojoExecutor.executionEnvironment(project, session,

                                                 pluginManager));

         }

         /**

    * 

    */

         private void createSDMModel() throws Exception {

                 getLog().info("Relocating the Xar Generation code ...");

                 if (isInlineGeneration) {

                         // Generate the includes for the model and tuning.xml files

                         generateESBContainerIncludes();

                         generateCleanESBContainerXar();

                         //generateContainerXar();

                 } else {

                         generateContainerXar();

                 }

                 getLog().debug("Creating SDM model from the sources...");

                 final File sdmDir = new File(getTargetSDMDir().getAbsolutePath());

                 sdmDir.mkdirs();

                 getLog().debug("Collecting XAR archives from dependencies...");

                 copyXarArchives();

                 getLog().debug("Rewriting SDM Model to reflect dependencies...");

                 injectSDMSettings();

         }

         private void generateCleanESBContainerXar() throws Exception {

                 getLog().info("Creating Clean xar archive for the ESBContainers");

                 final String xarDirectory = getPackageXarDir();

                 new File(xarDirectory, "ESB/Containers").mkdirs();

                 new File(xarDirectory, "SonicFS").mkdirs();

                 HashMap <String,String> instanceReplaceMaps = new  HashMap<String,String>();

                 for (final IESBContainer container : getCleanESBContainerSettings(false, instanceReplaceMaps)) {

                         final String fileName = container.getName() + ".xml";

                         FileUtilities.writeFile(container.toString().getBytes(),

                                         xarDirectory + "/ESB/Containers/" + fileName);

                 }

                 final File xarFile = new File(getTargetSDMDir(), "xars/"

                                 + getFinalAssemblyBaseName() + ".xar");

                 final Archiver archiver = archiverManager.getArchiver("zip");

                 archiver.setDestFile(xarFile);

                 archiver.addDirectory(new File(xarDirectory));

                 getLog().error("Creating the archive " + xarFile.getAbsolutePath());

                 archiver.createArchive();

                 //Generating the ReplaceMaps file

                 //reading the instanceReplaceMaps

                 for (Iterator iterator = instanceReplaceMaps.keySet().iterator(); iterator.hasNext();) {

                         String key = (String) iterator.next();

                         getLog().error("TBO --- Replacing: " + key + " with: " + instanceReplaceMaps.get(key));

                 }

                 if(! instanceReplaceMaps.isEmpty()){                        

                         createCleanESBContainerTailoring(instanceReplaceMaps);

                 }

         }

         private void createCleanESBContainerTailoring(HashMap<String,String> instanceReplaceMaps) {

 //                String tailorFile = getOutputDirectory() +  File.separatorChar + "sonicesb" + File.separatorChar + "assembly" + File.separatorChar + XARS_DIR_NAME + File.separatorChar + TAILOR_DIR_NAME + File.separatorChar + getFinalAssemblyBaseName() + ".xar.xml";

 //                String tailorFile = getOutputDirectory() + File.separatorChar + getFinalAssemblyBaseName() + ".xar.xml";

                 File outputFile =  new File(getTargetSDMDir(), "xars" + File.separatorChar + "tailor" + File.separatorChar + getFinalAssemblyBaseName() + ".xar.xml");

                 File outputDir = new File(getTargetSDMDir(), "xars" + File.separatorChar + "tailor");

                 if(!outputDir.exists()){

                         outputDir.mkdirs();

                         getLog().error("TBO ---- CREATED DIRECTORY for TAILORING");

                 }

                 //create the xml

                 final Xpp3Dom tailorMap = new Xpp3Dom("TailoringMaps");

                 tailorMap.setAttribute("xmlns", "http://www.sonicsw.com/sonicxq");

                 tailorMap.setAttribute("version", "TailorMap8.0");

                 tailorMap.addChild(new Xpp3Dom("ProcessMaps"));

                 tailorMap.addChild(new Xpp3Dom("ServiceMaps"));

                 tailorMap.addChild(new Xpp3Dom("EndpointMaps"));

                 tailorMap.addChild(new Xpp3Dom("ConnectionMaps"));

                 Xpp3Dom stringReplaceMaps = new Xpp3Dom("StringReplaceMaps");

                 stringReplaceMaps.setAttribute("xmlns:xi", "http://www.w3.org/2001/XMLSchema-instance");

                 for (Iterator iterator = instanceReplaceMaps.keySet().iterator(); iterator.hasNext();) {

                         String key = (String) iterator.next();

                         Xpp3Dom map = new Xpp3Dom("stringReplaceMap");

                         map.setAttribute("updatedName", instanceReplaceMaps.get(key));

                         map.setAttribute("name", key);

                         stringReplaceMaps.addChild(map);

                 }

                 tailorMap.addChild(stringReplaceMaps);

                 //write the xml to the file

                 getLog().error("TBO --- WRITING FILE " + outputFile);

                 FileUtilities.writeFile(tailorMap.toString().getBytes(),

                                 outputFile);

                 //System.exit(0);

         }

         @SuppressWarnings({ "unchecked", "rawtypes" })

         private Collection<IESBContainer> getCleanESBContainerSettings(boolean inLine, HashMap <String,String> instanceReplaceMaps)

                         throws Exception {

                 if (cleanEsbContainer == null) {

                         final ArrayList[] configs = readESBContainerConfiguration();

                         getLog().debug("Adding Clean External ESB Configuration - Start");

                         // Adding external Configuration

                         final ArrayList<IContainerSetting> esbConfig = configs[0];

                         for (final Iterator<IContainerSetting> iterator = esbConfig

                                         .iterator(); iterator.hasNext();) {

                                 final IContainerSetting container = iterator.next();

                                 // Remove and re-add the element to make sure the newer setting

                                 // (from ContainerProperties.xml) overrides any settings in

                                 // pom.xml

                                 containerMap.getESBContainerSettings().remove(container);

                                 containerMap.getESBContainerSettings().add(container);

                         }

                         getLog().info(

                                         "ESB Clean container mapping: "

                                                         + containerMap.getESBContainerSettings());

                         final ArrayList<IContainerSetting> mfConfig = configs[1];

                         for (final Iterator<IContainerSetting> iterator = mfConfig

                                         .iterator(); iterator.hasNext();) {

                                 final IContainerSetting container = iterator.next();

                                 // Remove and re-add the element to make sure the newer setting

                                 // (from ContainerProperties.xml) overrides any settings in

                                 // pom.xml

                                 containerMap.getMFContainerSettings().remove(container);

                                 containerMap.getMFContainerSettings().add(container);

                         }

                         getLog().debug(

                                         "MF container mapping: "

                                                         + containerMap.getMFContainerSettings());

                         getLog().debug("Adding External ESB Configuration - Done");

                         final HashMap<String, IESBContainer> esbContainerMap = new HashMap<String, IESBContainer>();

                         getLog().info("---------------------------------------------");

                         getLog().debug("Building Container settings for SDM model...");

                         final List<Xpp3Dom> serviceInstances = Xpp3Utils.collectElements(

                                         getDependencyDirectory(), "**/*.instances.snippet");

                         for (final Xpp3Dom serviceInstance : serviceInstances) {

                                 final String containerHint = serviceInstance

                                                 .getAttribute(SnippetsProcessor.HINT_ATTRIBUTE);

                                 getLog().debug(

                                                 "Matching service instance "

                                                                 + serviceInstance.getAttribute("name") + "/"

                                                                 + serviceInstance.getAttribute("process")

                                                                 + "\r\n\t(containerHint: " + containerHint

                                                                 + ")");

                                 if (containerMap == null) {

                                         throw new Exception(

                                                         "containerMap not specified in plugin configuration");

                                 }

                                 final Map<String, Properties> matches = containerMap

                                                 .matchESBContainerSettings(containerHint);

                                 if (matches.size() == 0

                                                 && containerMap.isUseESBDefaultIncludes()) {

                                         getLog().warn(

                                                         "No matching ESBContainer setting found...will use default...");

                                         matches.put(containerMap.getDefaultESBContainerSetting()

                                                         .getName(), new Properties());

                                 }

                                 for (final Iterator<String> it = matches.keySet().iterator(); it

                                                 .hasNext();) {

 //                                        HashMap <String,String> ctValues = new HashMap<String,String>();

 //                                        instanceReplaceMaps.put(container.getName(), ctValues);

                                         final String matchedName = it.next();

                                         addCleanServiceInstance(esbContainerMap, matchedName,

                                                         serviceInstance, matches.get(matchedName), inLine, instanceReplaceMaps);

                                 }

                         }

                         cleanEsbContainer = esbContainerMap.values();

                 }

                 return cleanEsbContainer;

         }

         /**

          * Copy the xar files and the generated snippets over to the target

          * directory.

          */

         private void copyXarArchives() throws Exception {

                 // only copy XARs which are not provided

                 final String xarBaseDirectory = getDepAnalyzer().getXarDependencyDir()

                                 + "/compile";

                 final String[] xarFiles = FileUtilities.getFileList(xarBaseDirectory,

                                 "**/*.xar", null);

                 for (final String xarFileName : xarFiles) {

                         final File xarDir = new File(xarBaseDirectory, xarFileName)

                                         .getParentFile();

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

                                         + "/xars", null, "sdm-snippets/*.snippet", null, false);

                 }

         }

         /**

          * This method is simply the controller for the modification of the SDM

          * model.

          */

         private void injectSDMSettings() throws Exception {

                 // Get the SDM Model as a DOM tree for manipulation

                 final File sdmFile = new File(getTargetSDMDir(), "Model.xml");

                 final XmlStreamReader sdmReader = new XmlStreamReader(sdmFile);

                 final Xpp3Dom sdmDom = Xpp3DomBuilder.build(sdmReader);

                 // if (isInlineGeneration) {

                 // getLog().info("PERFORMING IN-LINE SUBSTITUTION OF SDM ARTIFACTS");

                 // // Finding the XML Container files ...

                 //

                 // // Parsing the containers

                 //

                 // // Creating Model XML Includes

                 //

                 // // Creating Tuning XML Includes

                 //

                 // } else {

                 // getLog().info("Generating the container.xml old fashion style");

                 // }

                 // Set the version number in the model

                 setModelVersion(sdmDom);

                 // Assign the queues from the dependencies to their queues sections.

                 assignQueues(sdmDom);

                 // Now we will iterate over the xar archives and add them to the SDM

                 // package

                 for (final String xarAchive : FileUtilities.getFileList(

                                 getTargetSDMDir() + "/xars", "**/*.xar", null)) {

                         final Xpp3Dom elem = new Xpp3Dom("ESBArchive");

                         final String archiveName = new File(getTargetSDMDir(), xarAchive)

                                         .getName();

                         getLog().info("Adding XAR archive SDM package: " + archiveName);

                         //if (sonicTarget.equals("8")) {

                                 final Xpp3Dom hosts = new Xpp3Dom("LogicalHosts");

                                 hosts.addChild(Xpp3Utils.createXpp3Dom("LogicalHost",

                                                 DEFAULT_XAR_HOST_VALUE));

                                 elem.addChild(hosts);

                                 elem.addChild(Xpp3Utils.createXpp3Dom("Id", archiveName));

 //                        } else {

 //                                final Xpp3Dom hosts = new Xpp3Dom("Hosts");

 //                                hosts.addChild(Xpp3Utils.createXpp3Dom("Host",

 //                                                DEFAULT_XAR_HOST_VALUE));

 //                                elem.addChild(hosts);

 //                                elem.addChild(Xpp3Utils.createXpp3Dom("Id", archiveName));

 //                        }

                         sdmDom.addChild(elem);

                 }

                 if (isInlineGeneration) {

                         getLog().info("Lookup of the Includes for the Model.xml file");

                         File includeDir = new File(getTargetSDMDir() + File.separator

                                         + "modelincludes");

                         if (!includeDir.exists()) {

                                 // no includes used ... skip this

                         } else {

                                 sdmDom.setAttribute("xmlns:xi",

                                                 "http://www.w3.org/2001/XInclude");

                                 getLog().debug("TBO2 ------------ INCLUDES DIR FOUND .... TEST");

                                 File[] content = includeDir.listFiles(new FilenameFilter() {

                                         @Override

                                         public boolean accept(File dir, String name) {

                                                 if (name.endsWith("_inc_model.xml")) {

                                                         return true;

                                                 } else {

                                                         return false;

                                                 }

                                         }

                                 });

                                 // Here I want to find a list of include files that are already

                                 // included ...

                                 getLog().debug("FINDING THE FILES AND THE KEYS");

                                 Iterator<String> it = this.ContainerIncludeFiles.keySet()

                                                 .iterator();

                                 while (it.hasNext()) {

                                         String key = it.next();

                                         String value = this.ContainerIncludeFiles.get(key);

                                         getLog().debug("Found key " + key + " : " + value);

                                 }

                                 getLog().debug("END FINDING THE FILES AND THE KEYS");

                                 getLog().debug("FINDING THE Model AND THE KEYS");

                                 replaceMFESBContainers(sdmDom);

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

                                         getLog().debug(

                                                         "Filename Found: " + content[i].getName() + " --- "

                                                                         + content[i].getPath());

                                         // check if it is already included

                                         if (containerSubst != null

                                                         && containerSubst.contains(content[i].getName())) {

                                                 getLog().info(

                                                                 "href already included ... "

                                                                                 + content[i].getName()

                                                                                 + " Will skip generic include");

                                         } else {

                                                 Xpp3Dom includeDom = new Xpp3Dom("xi:include");

                                                 includeDom.setAttribute("href", "modelincludes/"

                                                                 + content[i].getName());

                                                 sdmDom.addChild(includeDom);

                                         }

                                 }

                                 // Adding files to the Tuning.xml file

                                 final File tuningFile = new File(getTargetSDMDir(),

                                                 "Tuning.xml");

                                 final XmlStreamReader tuningReader = new XmlStreamReader(

                                                 tuningFile);

                                 final Xpp3Dom tuningDom = Xpp3DomBuilder.build(tuningReader);

                                 tuningDom.setAttribute("xmlns:xi",

                                                 "http://www.w3.org/2001/XInclude");

                                 File[] tuningctnt = includeDir.listFiles(new FilenameFilter() {

                                         @Override

                                         public boolean accept(File dir, String name) {

                                                 if (name.endsWith("_inc_tuning.xml")) {

                                                         return true;

                                                 } else {

                                                         return false;

                                                 }

                                         }

                                 });

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

                                         getLog().debug(

                                                         "Filename Found: " + tuningctnt[i].getName()

                                                                         + " --- " + tuningctnt[i].getPath());

                                         Xpp3Dom includeDom = new Xpp3Dom("xi:include");

                                         includeDom.setAttribute("href", "modelincludes/"

                                                         + tuningctnt[i].getName());

                                         tuningDom.addChild(includeDom);

                                 }

                                 FileUtilities.writeFile(tuningDom.toString().getBytes(),

                                                 tuningFile.getAbsolutePath());

                         }

                 } else {

                         getLog().info("Generating the container.xml old fashion style");

                         // Finally we need to add MFContainer Elements for all the ESB

                         // containers

                         for (final Xpp3Dom mfContainer : getMFContainerSettings()) {

                                 Map<String, Properties> map = containerMap

                                                 .matchMFContainerSettings(mfContainer.getChild("Id")

                                                                 .getValue());

                                 Properties props = map.get(mfContainer.getChild(

                                                 "TargetContainer").getValue());

                                 String segment = (String) props.get("Segment");

                                 if (segment != null && !segment.equals("")) {

                                         final Xpp3Dom segmentElement = new Xpp3Dom("Segment");

                                         final Xpp3Dom segID = new Xpp3Dom("Id");

                                         segID.setValue(segment);

                                         segmentElement.addChild(segID);

                                         segmentElement.addChild(mfContainer);

                                         sdmDom.addChild(segmentElement);

                                 } else {

                                         sdmDom.addChild(mfContainer);

                                 }

                         }

                 }

                 // And spit out the modified SDM DOM

                 FileUtilities.writeFile(sdmDom.toString().getBytes(),

                                 sdmFile.getAbsolutePath());

         }

         private void replaceMFESBContainers(Xpp3Dom sdmDom) {

                 // Finding all the children and look for the include ref ...

                 final Xpp3Dom[] elements = sdmDom.getChildren();

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

                         handleESBIncludeElements(elements[i]);

                 }

         }

         private void handleESBIncludeElements(Xpp3Dom element) {

                 // TODO Auto-generated method stub

                 // First Print the Elements

                 getLog().debug("Element Name: " + element.getName());

                 if (element.getName().equals("xi:include")) {

                         String ref = element.getAttribute("href");

                         if (ref != null) {

                                 if (ref.startsWith("mfesbcontainer/")) {

                                         getLog().debug("Found a substitute");

                                         String mykey = ref.substring("mfesbcontainer/".length());

                                         getLog().debug("Finding the key value " + mykey);

                                         //Here we need to implement the new logic for ESB Containers

                                         if(! ESBtoMFMapping.containsKey(mykey)){

                                                 element.setAttribute("href", "ERROR: No Containers found for key " + mykey);

                                         }

                                         else{

                                                 boolean primFlag = true;

                                                 //final Xpp3Dom merge = new Xpp3Dom("Segment");

                                                 ArrayList <String> esbContainers = ESBtoMFMapping.get(mykey);

                                                 for(String ctn : esbContainers){

                                                         getLog().info("Found Containers for " + mykey + " : " + ctn);

                                                         if(primFlag){

                                                                 element.setAttribute("href", "modelincludes/" + ctn + "_" + mykey + "_inc_model.xml");

                                                                 primFlag = false;

                                                         } else{

                                                                 //This is the second element ... as such we need to create a new element to be added to the domtree

                                                                 //fasdf

                                                                 final Xpp3Dom newref = new Xpp3Dom("xi:include");

                                                                 newref.setAttribute("href",  "modelincludes/" + ctn + "_" + mykey + "_inc_model.xml");