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

 import java.io.ByteArrayInputStream;

 import java.io.File;

 import java.io.StringReader;

 import java.util.List;

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

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

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

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

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

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

 import com.sonicsw.deploy.IArtifact;

 import com.sonicsw.deploy.IArtifactStorage;

 import com.sonicsw.deploy.artifact.ESBArtifact;

 import commonj.sdo.DataObject;

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

 public class SnippetsProcessor {

   private XarAnalyzer  xarAnalyser;

   /**

    * name of the xml node attribute containing the hint details.

    */

   public static final String HINT_ATTRIBUTE = "hint";

   /**

    * Initialize the analyzer wih a given storage.

    * 

    * @param _as

    *          The storage to be used in this instance

    */

   public SnippetsProcessor(final IArtifactStorage _as) {

     setXarAnalyser(new XarAnalyzer(_as));

   }

   /**

    * Initialize the analyzer with a file. If the file is a directory the we assume that this is an unzipped xar archive

    * and create a FileArtifactStorage. If the file is a single file we assume that this file is a xar archive and we

    * create a ZipArtifactStorage.

    * 

    * @param _f

    *          The file to be used as Artifact Storage

    */

   public SnippetsProcessor(final File _f) {

     setXarAnalyser(new XarAnalyzer(_f));

   }

   /**

    * Convenience constructor accepting a file name as String.

    * 

    * @param _fileName

    *          The file name

    */

   public SnippetsProcessor(final String _fileName) {

     setXarAnalyser(new XarAnalyzer(_fileName));

   }

   /**

    * Initialize the analyzer with a Sonic Domain storage. The access to the domain is encapsulated in the MFUtils

    * library.

    * 

    * @param _utils

    *          An initialized MFUtils object

    * @throws Exception

    *           if the XarAnalyzer can't be instantiated

    */

   public SnippetsProcessor(final MFUtils _utils) throws Exception {

     setXarAnalyser(new XarAnalyzer(_utils));

   }

   /**

    * This calculates the tailoring rules that are needed for a service type. Suppose we want to deploy a xar file and

    * that xar file contains custom service types. These service types may contain initialization parameters. Potentially

    * these parameters change from environment to environment, so that they need to be included n a tailoring file for

    * the xar file. Therefore this method iterates over the service types of the xar archive and examines the parameter

    * settings. Each parameter that matches at least one of the regular expressions that are passed in as a method

    * parameter, will be recorded in an xml snippet.

    * 

    * That xml snippet can be picked up by other components for insertion in a tailoring rules file, so that the the

    * initialization paramters of the custom services will appear in the tailoring map as well.

    * 

    * The xml fragment will look like

    * 

    * <pre>

    *  <ServiceRules>

    *    <ServiceRule type="ParserDecoratorService">

    *      <Param name="springconf"/>

    *      <Param name="mainbean"/>

    *    </ServiceRule>

    *  </ServiceRules>

    * </pre>

    * 

    * @param _paramPatterns

    *          _paramPatterns

    * @return An xml fragment that can be inserted in a tailoring rules files.

    */

   @SuppressWarnings("unchecked")

   public final String getTailorSnippet(final List<String> _paramPatterns) {

     Xpp3Dom result = new Xpp3Dom("ServiceRules");

     try {

       List<IArtifact> sTypes = xarAnalyser.getArtifacts(ESBArtifact.SERVICE_TYPE);

       for (IArtifact sTypeArtifact : sTypes) {

         IServiceType sType = new DefaultServiceType();

         byte[] bytes = xarAnalyser.getStorage().getContentsAsBytes(sTypeArtifact);

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

         String temp = new String(bytes);

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

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

         List<DataObject> params = sType.getDataObject().getList("validParams/init/stringParam");

         if (params != null) {

           Xpp3Dom svcRule = Xpp3Utils.createXpp3Dom("ServiceRule", null, "type="

               + sType.getDataObject().getString("name"));

           for (DataObject param : params) {

             String pName = param.getString("name");

             for (String paramPattern : _paramPatterns) {

               if (pName.matches(paramPattern)) {

                 svcRule.addChild(Xpp3Utils.createXpp3Dom("Param", null, "name=" + pName));

                 break;

               }

             }

           }

           if (svcRule.getChildCount() > 0) {

             result.addChild(svcRule);

           }

         }

       }

     } catch (Exception e) {

       // log_.error("Error creating Service rule set, empty set returned", e);

       // if (log_.isDebugEnabled()) {

       // e.printStackTrace();

       // }

     }

    // System.out.println("TBO LEFT THE BUILDING");

     return result.toString();

   }

   /**

    * @return String

    */

   public final String getQueuesSnippet() {

     Xpp3Dom result = new Xpp3Dom("Queues");

     try {

       List<IArtifact> endpoints = xarAnalyser.getArtifacts(ESBArtifact.ENDPOINT);

       for (IArtifact a : endpoints) {

         Xpp3Dom artifactDom = Xpp3DomBuilder.build(new StringReader(xarAnalyser.getStorage().getContentsAsString(a)));

         List<Xpp3Dom> params = Xpp3Utils.collectElements(artifactDom, "(xq:)?params/(xq:)?stringParam");

         boolean isQueue = false;

         String destName = null;

         for (Xpp3Dom param : params) {

           if ("destination".equals(param.getAttribute("name"))) {

             destName = param.getValue();

           }

           if ("type".equals(param.getAttribute("name"))) {

             isQueue = ("QUEUE".equals(param.getValue()));

           }

         }

         /*

          * Queue names containing "::" are references to remote queues. They should not be present in a queues snippet

          * because the real queue will be included by the project containing the process listening on that queue.

          * 

          * The same applies to reference to SonicMQ.deadMessage & SonicMQ.routingQueue.

          */

         if (isQueue && destName != null && !destName.contains("::") && !destName.equals("SonicMQ.deadMessage")

             && !destName.equals("SonicMQ.routingQueue")) {

           Xpp3Dom q = new Xpp3Dom("Queue");

           Xpp3Dom id = new Xpp3Dom("Id");

           id.setValue(destName);

           q.addChild(id);

           result.addChild(q);

         }

       }

     } catch (Exception e) {

       // log_.error("Error creating Queue set, empty set returned", e);

       // if (log_.isDebugEnabled()) {

       // e.printStackTrace();

       // }

     }

     return result.toString();

   }

   /**

    * @param _containerHint

    *          containerHint

    * @return String

    */

   public final String getSvcInstancesSnippet(final String _containerHint) {

     Xpp3Dom result = new Xpp3Dom("ServiceInstances");

     try {

       for (IArtifact svcInstance : xarAnalyser.getArtifacts(ESBArtifact.SERVICE)) {

         String svcName = svcInstance.getName();

         result.addChild(Xpp3Utils.createXpp3Dom("ServiceInstance", null, "name=" + svcName

             + Xpp3Utils.PROPERTY_SEPARATOR + HINT_ATTRIBUTE + "=" + _containerHint + "." + svcName));

       }

       for (IArtifact procInstance : xarAnalyser.getArtifacts(ESBArtifact.PROCESS)) {

         String procName = procInstance.getName();

         Xpp3Dom procDOM = Xpp3DomBuilder.build(new StringReader(xarAnalyser.getStorage().getContentsAsString(

             procInstance)));

         if (procDOM.getAttribute("entry_ref") != null) {

           result.addChild(Xpp3Utils.createXpp3Dom("ServiceInstance", null, "name=BPEType"

               + Xpp3Utils.PROPERTY_SEPARATOR + "hint=" + _containerHint + ".process." + procName

               + Xpp3Utils.PROPERTY_SEPARATOR + "process=" + procName));

         }

       }

     } catch (Exception e) {

       // log_.error("Error creating Service Instance set, empty set returned", e);

       // if (log_.isDebugEnabled()) {

       // e.printStackTrace();

       // }

     }

     return result.toString();

   }

   /**

    * @return the xarAnalyser

    */

   public final XarAnalyzer getXarAnalyser() {

     return xarAnalyser;

   }

   /**

    * @param _xarAnalyser

    *          the xarAnalyser to set

    */

   public final void setXarAnalyser(final XarAnalyzer _xarAnalyser) {

     this.xarAnalyser = _xarAnalyser;

   }

 }