* This program is free software; you can redistribute it and/or modify it under the

* terms of the GNU General Public License, version 2 as published by the Free Software

* Foundation.

*

* You should have received a copy of the GNU General Public License along with this

* program; if not, you can obtain a copy at http://www.gnu.org/licenses/gpl-2.0.html

* or from the Free Software Foundation, Inc.,

* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

*

* This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;

* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

* See the GNU General Public License for more details.

*

*

* Copyright 2006 - 2013 Pentaho Corporation.  All rights reserved.

*/

/*

* Created on Jun 17, 2005

*

* TODO To change the template for this generated file go to

* Window - Preferences - Java - Code Style - Code Templates

*/

* @author James Dixon

*

*         TODO To change the template for this generated type comment go to Window - Preferences - Java - Code

*         Style - Code Templates

*/

  /**

   *

   */

  private static final long serialVersionUID = -1179016850860938879L;

  private IRuntimeElement runtimeData;

  private static final String LOG_NAME = "RUNTIME"; //$NON-NLS-1$

  private static final String PLUGIN_BUNDLE_NAME = "org.pentaho.platform.engine.services.runtime.plugins"; //$NON-NLS-1$

  protected static final String PARAMETER_FORM = "actionparam"; //$NON-NLS-1$

  private String logId;

  private IPentahoSession session;

  protected ISolutionEngine solutionEngine;

  protected StringBuffer xformHeader;

  protected StringBuffer xformBody;

  protected Map<String, String> xformFields;

  private static final String DEFAULT_PARAMETER_XSL = "DefaultParameterForm.xsl"; //$NON-NLS-1$

  protected String parameterXsl = RuntimeContext.DEFAULT_PARAMETER_XSL;

  protected String parameterTemplate = null;

  protected String parameterTarget;

  private String instanceId;

  private String processId;

  private String handle;

  protected IPentahoUrlFactory urlFactory;

  protected Map parameterProviders;

  protected static Map componentClassMap;

  protected IActionSequence actionSequence;

  public static final boolean debug = PentahoSystem.debug;

  private boolean audit = true;

  private int status;

  protected IOutputHandler outputHandler;

  protected IParameterManager paramManager;

  private String currentComponent;

  private int promptStatus = IRuntimeContext.PROMPT_NO;

  private int contentSequenceNumber; // = 0

  // Normally shouldn't need to synchronize. But, a bug in

  // pattern compilation results in the need to synchronize

  // a small block of code. If/when this problem is fixed, we

  // can remove this synchronization lock.

  private static final byte[] PATTERN_COMPILE_LOCK = new byte[0];

  private static final Log logger = LogFactory.getLog( RuntimeContext.class );

  private ICreateFeedbackParameterCallback createFeedbackParameterCallback;

  private IPluginManager pluginManager;

  static {

    RuntimeContext.getComponentClassMap();

  }

  @Override

  public Log getLogger() {

    return RuntimeContext.logger;

  }

  /*

   * public RuntimeContext( IApplicationContext applicationContext, String solutionName ) { this( null,

   * solutionName, applicationContext, null, null, null, null ); }

   */

  public RuntimeContext( final String instanceId, final ISolutionEngine solutionEngine, final String solutionName,

      final IRuntimeElement runtimeData, final IPentahoSession session, final IOutputHandler outputHandler,

      final String processId, final IPentahoUrlFactory urlFactory, final Map parameterProviders, final List messages,

      ICreateFeedbackParameterCallback createFeedbackParameterCallback ) {

    this.createFeedbackParameterCallback = createFeedbackParameterCallback;

    this.instanceId = instanceId;

    this.solutionEngine = solutionEngine;

    this.session = session;

    this.outputHandler = outputHandler;

    this.processId = processId;

    this.urlFactory = urlFactory;

    this.parameterProviders = parameterProviders;

    setMessages( messages );

    xformHeader = new StringBuffer();

    xformBody = new StringBuffer();

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

    // TODO - Throw invalid parameter error if these babies are null

    this.currentComponent = ""; //$NON-NLS-1$

    status = IRuntimeContext.RUNTIME_STATUS_NOT_STARTED;

    this.runtimeData = runtimeData;

    if ( runtimeData != null ) {

      this.instanceId = runtimeData.getInstanceId();

    }

    handle = "context-" + this.hashCode() + "-" + new Date().getTime(); //$NON-NLS-1$ //$NON-NLS-2$

    logId = ( ( instanceId != null ) ? instanceId : solutionName ) + ":" + RuntimeContext.LOG_NAME + ":" + handle + " "; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

    paramManager = new ParameterManager();

    // Set the default XSL for parameter forms

    // Proposed fix for bug BISERVER-97 by Ezequiel Cuellar

    // If the component-definition's action-definition does not have an xsl element it reuses the one already

    // set by its previous component-definition's action-definition peer.

    // If the xsl element is not present for the component-definition then reset to the default xsl value

    // specified in the Pentaho.xml tag "default-parameter-xsl"

    // Proposed fix for bug BISERVER-238 by Ezequiel Cuellar

    // Added a default value of DefaultParameterForm.xsl when getting the value of default-parameter-xsl

    String defaultParameterXsl = PentahoSystem.getSystemSetting( "default-parameter-xsl", null ); //$NON-NLS-1$

    if ( ( defaultParameterXsl != null ) && ( defaultParameterXsl.length() > 0 ) ) {

      setParameterXsl( defaultParameterXsl );

    }

    // Gets the plugin manager if it's there.

    if ( PentahoSystem.getObjectFactory().objectDefined( IPluginManager.class.getSimpleName() ) ) {

      pluginManager = PentahoSystem.get( IPluginManager.class, session );

    }

  }

  private IRuntimeElement createChild( boolean persisted ) {

    IRuntimeElement childRuntimeData = null;

    IRuntimeRepository runtimeRepository = PentahoSystem.get( IRuntimeRepository.class, session );

    // the runtime repository is optional

    if ( runtimeRepository != null ) {

      runtimeRepository.setLoggingLevel( loggingLevel );

      childRuntimeData = runtimeRepository.newRuntimeElement( instanceId, "instance", !persisted ); //$NON-NLS-1$

      String childInstanceId = childRuntimeData.getInstanceId();

      // audit the creation of this against the parent instance

      AuditHelper.audit( instanceId, session.getName(), getActionName(), getObjectName(), processId,

          MessageTypes.INSTANCE_START, childInstanceId, "", 0, this ); //$NON-NLS-1$

    }

    return childRuntimeData;

  }

  public String createNewInstance( final boolean persisted ) {

    String childInstanceId = null;

    IRuntimeElement childRuntimeData = createChild( persisted );

    if ( childRuntimeData != null ) {

      childInstanceId = childRuntimeData.getInstanceId();

    }

    return childInstanceId;

  }

  public String createNewInstance( final boolean persisted, final Map parameters ) {

    return createNewInstance( persisted, parameters, false );

  }

  public String createNewInstance( final boolean persisted, final Map parameters, final boolean forceImmediateWrite ) {

    String childInstanceId = null;

    IRuntimeElement childRuntimeData = createChild( persisted );

    if ( childRuntimeData != null ) {

      if ( parameters != null ) {

        Iterator parameterIterator = parameters.keySet().iterator();

        while ( parameterIterator.hasNext() ) {

          String parameterName = (String) parameterIterator.next();

          Object parameterValue = parameters.get( parameterName );

          if ( parameterValue instanceof String ) {

            childRuntimeData.setStringProperty( parameterName, (String) parameterValue );

          } else if ( parameterValue instanceof BigDecimal ) {

            childRuntimeData.setBigDecimalProperty( parameterName, (BigDecimal) parameterValue );

          } else if ( parameterValue instanceof Date ) {

            childRuntimeData.setDateProperty( parameterName, (Date) parameterValue );

          } else if ( parameterValue instanceof List ) {

            childRuntimeData.setListProperty( parameterName, (List) parameterValue );

          } else if ( parameterValue instanceof Long ) {

            childRuntimeData.setLongProperty( parameterName, (Long) parameterValue );

          }

        }

      }

      childInstanceId = childRuntimeData.getInstanceId();

      if ( forceImmediateWrite ) {

        childRuntimeData.forceSave();

      }

    }

    return childInstanceId;

  }

  public int getStatus() {

    return status;

  }

  public void promptNow() {

    promptStatus = IRuntimeContext.PROMPT_NOW;

  }

  /** Sets the prompt flag but continue processing Actions */

  public void promptNeeded() {

    if ( promptStatus < IRuntimeContext.PROMPT_WAITING ) { // Don't mask a Prompt_Now

      promptStatus = IRuntimeContext.PROMPT_WAITING;

    }

  }

  /**

   * Tells if a component is waiting for a prompt

   *

   * @return true if a prompt is pending

   */

  public boolean isPromptPending() {

    return ( promptStatus != IRuntimeContext.PROMPT_NO );

  }

  public IPentahoUrlFactory getUrlFactory() {

    return urlFactory;

  }

  public boolean feedbackAllowed() {

    return ( outputHandler != null ) && outputHandler.allowFeedback();

  }

  public IContentItem getFeedbackContentItem() {

    return outputHandler.getFeedbackContentItem();

  }

  @SuppressWarnings( "unused" )

  private int getContentSequenceNumber() {

    return contentSequenceNumber++;

  }

  public IContentItem getOutputItem( final String outputName, final String mimeType, final String extension ) {

    // TODO support content output versions in the action definition

    IActionParameter outputParameter = getOutputParameter( outputName );

    if ( outputParameter == null ) {

      warn( Messages.getInstance().getErrorString(

          "RuntimeContext.ERROR_0021_INVALID_OUTPUT_REQUEST", outputName, actionSequence.getSequenceName() ) ); //$NON-NLS-1$

      return null;

    }

    String filePath = "~/workspace/" + FilenameUtils.getBaseName( getSolutionPath() ) + extension; //$NON-NLS-1$

    String contentName = "contentrepo:" + filePath; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$

    if ( !IActionParameter.TYPE_CONTENT.equals( outputParameter.getType() ) ) {

      warn( Messages.getInstance().getErrorString( "RuntimeContext.ERROR_0023_INVALID_OUTPUT_STREAM", outputName ) ); //$NON-NLS-1$

      return null;

    }

    try {

      IContentOutputHandler output = PentahoSystem.getOutputDestinationFromContentRef( contentName, session );

      if ( output != null ) {

        // TODO get this info

        output.setInstanceId( instanceId );

        output.setSolutionPath( filePath );

        output.setMimeType( mimeType );

        output.setSession( session );

        IContentItem contentItem = output.getFileOutputContentItem();

        setOutputValue( outputName, contentItem );

        return contentItem;

      }

    } catch ( Exception e ) {

      //ignored

    }

    return null;

  }

  public IContentItem getOutputContentItem( final String mimeType ) {

    // TODO check the sequence definition to see where this should come from

    return outputHandler.getOutputContentItem( IOutputHandler.RESPONSE, IOutputHandler.CONTENT, instanceId, mimeType );

  }

  public IContentItem getOutputContentItem( final String outputName, final String mimeType ) {

    IContentItem contentItem = null;

    IActionParameter parameter = (IActionParameter) actionSequence.getOutputDefinitions().get( outputName );

    if ( parameter == null ) {

      warn( Messages.getInstance().getErrorString(

          "RuntimeContext.ERROR_0021_INVALID_OUTPUT_REQUEST", outputName, actionSequence.getSequenceName() ) ); //$NON-NLS-1$

    } else {

      List destinationsList = parameter.getVariables();

      Iterator destinationsIterator = destinationsList.iterator();

      if ( destinationsList.size() > 1 ) {

        contentItem = new MultiContentItem();

      }

      while ( destinationsIterator.hasNext() ) {

        ActionParameterSource destination = (ActionParameterSource) destinationsIterator.next();

        String objectName = destination.getSourceName();

        String contentName = destination.getValue();

        contentName = TemplateUtil.applyTemplate( contentName, this );

        outputHandler.setSession( session );

        IContentItem tmpContentItem =

            outputHandler.getOutputContentItem( objectName, contentName, instanceId, mimeType );

        if ( contentItem instanceof MultiContentItem ) {

          ( (MultiContentItem) contentItem ).addContentItem( tmpContentItem );

        } else {

          contentItem = tmpContentItem;

          break;

        }

      }

    }

    return contentItem;

  }

  public String getHandle() {

    return handle;

  }

  public IPentahoSession getSession() {

    return session;

  }

  public String getSolutionPath() {

    return ( ( actionSequence != null ) ? actionSequence.getSolutionPath() : null );

  }

  public String getCurrentComponentName() {

    if ( "".equals( currentComponent ) ) { //$NON-NLS-1$

      return this.getClass().getName();

    }

    return currentComponent;

  }

  public String getInstanceId() {

    return instanceId;

  }

  public int getErrorLevel() {

    return status;

  }

  public void setActionSequence( final IActionSequence sequence ) {

    this.actionSequence = sequence;

    paramManager = new ParameterManager( sequence );

  }

  public void validateSequence( final String sequenceName, final IExecutionListener execListener )

    throws ActionValidationException {

    paramManager.resetParameters();

    logId = instanceId + ":" + RuntimeContext.LOG_NAME + ":" + handle + ":" + sequenceName + " "; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$

    if ( audit ) {

      audit( MessageTypes.ACTION_SEQUENCE_START, MessageTypes.START, "", 0 ); //$NON-NLS-1$

    }

    if ( status != IRuntimeContext.RUNTIME_STATUS_NOT_STARTED ) {

      throw new IllegalStateException( Messages.getInstance().getErrorString(

          "RuntimeContext.ERROR_0001_RUNTIME_RUNNING" ) ); //$NON-NLS-1$

    }

    initFromActionSequenceDefinition();

    // validate component

    try {

      validateComponents( actionSequence, execListener );

      status = IRuntimeContext.RUNTIME_CONTEXT_VALIDATE_OK;

    } catch ( ActionValidationException ex ) {

      status = IRuntimeContext.RUNTIME_CONTEXT_VALIDATE_FAIL;

      throw ex;

    }

  }

  private void validateComponents( final IActionSequence sequence, final IExecutionListener execListener )

    throws ActionValidationException {

    List defList = sequence.getActionDefinitionsAndSequences();

    Object listItem;

    for ( Iterator it = defList.iterator(); it.hasNext(); ) {

      listItem = it.next();

      if ( listItem instanceof IActionSequence ) {

        validateComponents( (IActionSequence) listItem, execListener );

      } else if ( listItem instanceof ISolutionActionDefinition ) {

        ISolutionActionDefinition actionDef = (ISolutionActionDefinition) listItem;

        if ( RuntimeContext.debug ) {

          debug( Messages.getInstance().getString(

              "RuntimeContext.DEBUG_VALIDATING_COMPONENT", actionDef.getComponentName() ) ); //$NON-NLS-1$

        }

        IComponent component = null;

        try {

          component = resolveComponent( actionDef, instanceId, processId, session );

          component.setLoggingLevel( loggingLevel );

          // allow the ActionDefinition to cache the component

          actionDef.setComponent( component );

          paramManager.setCurrentParameters( actionDef );

          /*

           * We need to catch checked and unchecked exceptions here so we can create an ActionSequeceException with

           * contextual information, including the root cause. Allowing unchecked exceptions to pass through would

           * prevent valuable feedback in the log or response.

           */

        } catch ( Throwable ex ) {

          ActionDefinition actionDefinition = new ActionDefinition( (Element) actionDef.getNode(), null );

          throw new ActionValidationException( Messages.getInstance().getErrorString(

              "RuntimeContext.ERROR_0009_COULD_NOT_CREATE_COMPONENT", actionDef.getComponentName().trim() ), ex, //$NON-NLS-1$

              session.getName(), instanceId, getActionSequence().getSequenceName(), actionDefinition.getDescription(),

              actionDefinition.getComponentName() );

        }

        int validateResult = IRuntimeContext.RUNTIME_CONTEXT_VALIDATE_OK;

        try {

          validateResult = component.validate();

          /*

           * We need to catch checked and unchecked exceptions here so we can create an ActionSequeceException with

           * contextual information, including the root cause. Allowing unchecked exceptions to pass through would

           * prevent valuable feedback in the log or response.

           */

        } catch ( Throwable t ) {

          throw new ActionValidationException( Messages.getInstance().getErrorString(

              "RuntimeContext.ERROR_0035_ACTION_VALIDATION_FAILED" ), t, //$NON-NLS-1$

              session.getName(), instanceId, getActionSequence().getSequenceName(), component.getActionDefinition() );

        }

        if ( validateResult != IRuntimeContext.RUNTIME_CONTEXT_VALIDATE_OK ) {

          throw new ActionValidationException( Messages.getInstance().getErrorString(

              "RuntimeContext.ERROR_0035_ACTION_VALIDATION_FAILED" ), //$NON-NLS-1$

              session.getName(), instanceId, getActionSequence().getSequenceName(), component.getActionDefinition() );

        }

        paramManager.addOutputParameters( actionDef );

        setCurrentComponent( "" ); //$NON-NLS-1$

        setCurrentActionDef( null );

      }

    }

    if ( execListener != null ) {

      execListener.validated( this );

    }

  }

  public IPentahoStreamSource getDataSource( final String parameterName ) {

    IPentahoStreamSource dataSource = null;

    // TODO Temp workaround for content repos bug

    IActionParameter actionParameter = paramManager.getCurrentInput( parameterName );

    if ( actionParameter == null ) {

      throw new InvalidParameterException( Messages.getInstance().getErrorString(

          "RuntimeContext.ERROR_0019_INVALID_INPUT_REQUEST", parameterName, actionSequence.getSequenceName() ) ); //$NON-NLS-1$

    }

    Object locObj = actionParameter.getValue();

    if ( locObj != null ) {

      if ( locObj instanceof IContentItem ) { // At this point we have an IContentItem so why do anything else?

        dataSource = ( (IContentItem) locObj ).getDataSource();

      }

    }

    // This will return null if the locObj is null

    return dataSource;

  }

  @SuppressWarnings( { "unchecked" } )

  protected static Map getComponentClassMap() {

    if ( RuntimeContext.componentClassMap == null ) {

      RuntimeContext.componentClassMap = Collections.synchronizedMap( RuntimeContext.createComponentClassMap() );

    }

    return RuntimeContext.componentClassMap;

  }

  private static Map createComponentClassMap() {

    Properties knownComponents = new Properties();

    // First, get known plugin names...

    try {

      ResourceBundle pluginBundle = ResourceBundle.getBundle( RuntimeContext.PLUGIN_BUNDLE_NAME );

      if ( pluginBundle != null ) { // Copy the bundle here...

        Enumeration keyEnum = pluginBundle.getKeys();

        String bundleKey = null;

        while ( keyEnum.hasMoreElements() ) {

          bundleKey = (String) keyEnum.nextElement();

          knownComponents.put( bundleKey, pluginBundle.getString( bundleKey ) );

        }

      }

    } catch ( Exception ex ) {

      RuntimeContext.logger

          .warn( Messages.getInstance().getString( "RuntimeContext.WARN_NO_PLUGIN_PROPERTIES_BUNDLE" ) ); //$NON-NLS-1$

    }

    // Get overrides...

    //

    // Note - If the override wants to remove an existing "known" plugin,

    // simply adding an empty value will cause the "known" plugin to be removed.

    //

    InputStream is = null;

    try {

      File f = new File( PentahoSystem.getApplicationContext().getSolutionPath( "system/plugin.properties" ) );

      if ( f.exists() ) {

        is = new FileInputStream( f );

        Properties overrideComponents = new Properties();

        overrideComponents.load( is );

        knownComponents.putAll( overrideComponents ); // load over the top of the known properties

      }

    } catch ( FileNotFoundException ignored ) {

      RuntimeContext.logger.warn( Messages.getInstance().getString( "RuntimeContext.WARN_NO_PLUGIN_PROPERTIES" ) ); //$NON-NLS-1$

    } catch ( IOException ignored ) {

      RuntimeContext.logger.warn(

          Messages.getInstance().getString( "RuntimeContext.WARN_BAD_PLUGIN_PROPERTIES" ), ignored ); //$NON-NLS-1$

    } finally {

      try {

        if ( is != null ) {

          is.close();

        }

      } catch ( IOException e ) {

        //ignored

      }

    }

    return knownComponents;

  }

  protected void setCurrentComponent( final String componentClassName ) {

    currentComponent = componentClassName;

  }

  protected void setCurrentActionDef( final ISolutionActionDefinition actionDefinition ) {

  }

  protected static String getComponentClassName( final String rawClassName, final IRuntimeContext runtime ) {

    String mappedClassName = (String) RuntimeContext.getComponentClassMap().get( rawClassName );

    if ( mappedClassName != null ) {

      if ( mappedClassName.charAt( 0 ) == '!' ) {

        // this is deprecated, log a warning

        mappedClassName = mappedClassName.substring( 1 );

        runtime.warn( Messages.getInstance().getString(

            "RuntimeContext.WARN_DEPRECATED_COMPONENT_CLASS", rawClassName, mappedClassName ) ); //$NON-NLS-1$

        runtime.audit( MessageTypes.DEPRECATION_WARNING, rawClassName, mappedClassName, 0 );

      }

      return mappedClassName;

    }

    return rawClassName;

  }

  protected IComponent resolveComponent( final ISolutionActionDefinition actionDefinition,

      final String currentInstanceId, final String currentProcessId, final IPentahoSession currentSession )

    throws ClassNotFoundException, PluginBeanException, InstantiationException, IllegalAccessException {

    // try to create an instance of the component class specified in the

    // action document

    String componentAlias = actionDefinition.getComponentName().trim();

    String componentClassName = RuntimeContext.getComponentClassName( componentAlias, this );

    Element componentDefinition = (Element) actionDefinition.getComponentSection();

    setCurrentComponent( componentClassName );

    setCurrentActionDef( actionDefinition );

    IComponent component = null;

    Class componentClass = null;

    Object componentTmp = null;

    // Explicitly using the short name instead of the fully layed out class name

    if ( ( pluginManager != null ) && ( pluginManager.isBeanRegistered( componentAlias ) ) ) {

      if ( RuntimeContext.debug ) {

        this.debug( "Component alias " + componentAlias + " will be resolved by the plugin manager." ); //$NON-NLS-1$ //$NON-NLS-2$

      }

      componentTmp = pluginManager.getBean( componentAlias );

      if ( RuntimeContext.debug ) {

        this.debug( "Component found in a plugin, class is: " + componentTmp.getClass().getName() ); //$NON-NLS-1$

      }

    }

    if ( RuntimeContext.debug ) {

      this.debug( "Component alias " + componentAlias + " will be resolved by the platform" ); //$NON-NLS-1$ //$NON-NLS-2$

    }

    // Ok - the plugin didn't load - try the old route

    if ( componentTmp == null ) {

      componentClass = Class.forName( componentClassName );

      componentTmp = componentClass.newInstance();

    }

    if ( componentTmp instanceof IComponent ) {

      component = (IComponent) componentTmp;

    } else if ( componentTmp instanceof IAction ) {

      component = new ActionDelegate( componentTmp );

    } else {

      // Try this out...

      PojoComponent pc = new PojoComponent();

      pc.setPojo( componentTmp );

      component = pc;

    }

    component.setInstanceId( currentInstanceId );

    component.setActionName( getActionName() );

    component.setProcessId( currentProcessId );

    // This next conditional is used to allow components to use the new action sequence dom commons project. The

    // ActionFactory should return an object that wraps the action definition element to be processed by the component.

    // The component can then use the wrappers API to access the action definition rather than make explicit references

    // to the dom nodes.

    if ( component instanceof IParameterResolver ) {

      component.setActionDefinition( ActionFactory.getActionDefinition( (Element) actionDefinition.getNode(),

          new ActionSequenceParameterMgr( this, currentSession, (IParameterResolver) component ) ) );

    } else {

      component.setActionDefinition( ActionFactory.getActionDefinition( (Element) actionDefinition.getNode(),

          new ActionSequenceParameterMgr( this, currentSession ) ) );

    }

    // create a map of the top level component definition nodes and their text

    Map<String, String> componentDefinitionMap = new HashMap<String, String>();

    List elements = componentDefinition.elements();

    Element element;

    String name;

    String value;

    String customXsl = null;

    for ( int idx = 0; idx < elements.size(); idx++ ) {

      element = (Element) elements.get( idx );

      name = element.getName();

      value = element.getText();

      // see if we have a target window for the output

      if ( "target".equals( name ) ) { //$NON-NLS-1$

        setParameterTarget( value );

      } else if ( "xsl".equals( name ) ) { //$NON-NLS-1$

        customXsl = value; // setParameterXsl(value);

      }

      componentDefinitionMap.put( element.getName(), element.getText() );

    }

    if ( customXsl != null ) {

      setParameterXsl( customXsl );

    }

    component.setComponentDefinitionMap( componentDefinitionMap );

    component.setComponentDefinition( componentDefinition );

    component.setRuntimeContext( this );

    component.setSession( currentSession );

    component.setLoggingLevel( getLoggingLevel() );

    component.setMessages( getMessages() );

    return component;

  }

  public void executeSequence( final IActionCompleteListener doneListener, final IExecutionListener execListener,

      final boolean async ) throws ActionSequenceException {

    paramManager.resetParameters();

    long start = new Date().getTime();

    status = IRuntimeContext.RUNTIME_STATUS_RUNNING;

    // create an IActionDef object

    List actionDefinitions = actionSequence.getActionDefinitionsAndSequences();

    if ( actionDefinitions == null ) {

      audit( MessageTypes.ACTION_SEQUENCE_FAILED, MessageTypes.VALIDATION, Messages.getInstance().getErrorString(

          "RuntimeContext.ERROR_0011_NO_VALID_ACTIONS" ), 0 ); //$NON-NLS-1$

      status = IRuntimeContext.RUNTIME_STATUS_FAILURE;

      throw new ActionValidationException( Messages.getInstance().getErrorString(

          "RuntimeContext.ERROR_0011_NO_VALID_ACTIONS" ), //$NON-NLS-1$

          session.getName(), instanceId, getActionSequence().getSequenceName(), null );

    }

    setLoggingLevel( loggingLevel );

    if ( RuntimeContext.debug ) {

      debug( Messages.getInstance().getString( "RuntimeContext.DEBUG_EXECUTING_ACTIONS" ) ); //$NON-NLS-1$

    }

    paramManager.setCurrentParameters( null );

    try {

      resolveParameters();

      if ( execListener != null ) {

        execListener.loaded( this );

      }

      executeSequence( actionSequence, doneListener, execListener, async );

      if ( this.feedbackAllowed()

          && ( ( promptStatus != IRuntimeContext.PROMPT_NO ) || ( xformBody.length() > 0 )

        || ( parameterTemplate != null ) ) ) {

        sendFeedbackForm();

      }

      paramManager.setCurrentParameters( null );

      if ( audit ) {

        audit( MessageTypes.ACTION_SEQUENCE_END, MessageTypes.END, "", (int) ( new Date().getTime() - start ) ); //$NON-NLS-1$

      }

      if ( !isPromptPending() ) {

        Map returnParamMap = paramManager.getReturnParameters();

        for ( Iterator it = returnParamMap.entrySet().iterator(); it.hasNext(); ) {

          Map.Entry mapEntry = (Map.Entry) it.next();

          String paramName = (String) mapEntry.getKey();

          ParameterManager.ReturnParameter returnParam = (ParameterManager.ReturnParameter) mapEntry.getValue();

          if ( returnParam == null ) {

            error( Messages.getInstance().getErrorString( "RuntimeContext.ERROR_0029_SAVE_PARAM_NOT_FOUND", paramName ) ); //$NON-NLS-1$

          } else {

            if ( IParameterProvider.SCOPE_SESSION.equals( returnParam.destinationName ) ) {

              session.setAttribute( returnParam.destinationParameter, returnParam.value );

              if ( RuntimeContext.debug ) {

                debug( paramName + " - session - " + returnParam.destinationParameter ); //$NON-NLS-1$

              }

            } else if ( "response".equals( returnParam.destinationName ) ) { //$NON-NLS-1$

              if ( outputHandler != null ) {

                outputHandler.setOutput( returnParam.destinationParameter, returnParam.value );

              } else {

                info( Messages.getInstance().getString( "RuntimeContext.INFO_NO_OUTPUT_HANDLER" ) ); //$NON-NLS-1$

              }

              if ( RuntimeContext.debug ) {

                debug( paramName + " - response - " + returnParam.destinationParameter ); //$NON-NLS-1$

              }

            } else if ( PentahoSystem.SCOPE_GLOBAL.equals( returnParam.destinationName ) ) {

              PentahoSystem.putInGlobalAttributesMap( returnParam.destinationParameter, returnParam.value );

              if ( RuntimeContext.debug ) {

                debug( paramName + " - global - " + returnParam.destinationParameter ); //$NON-NLS-1$

              }

            } else { // Unrecognized scope

              warn( Messages

                  .getInstance()

                  .getString(

                      "RuntimeContext.WARN_UNRECOGNIZED_SCOPE", returnParam.destinationName, returnParam.destinationParameter ) ); //$NON-NLS-1$

            }

          }

        }

      }

    } catch ( UnresolvedParameterException ex ) {

      status = IRuntimeContext.RUNTIME_STATUS_FAILURE;

      audit( MessageTypes.ACTION_SEQUENCE_FAILED, MessageTypes.VALIDATION, Messages.getInstance().getErrorString(

          "RuntimeContext.ERROR_0013_BAD_PARAMETERS" ), 0 ); //$NON-NLS-1$

      throw ex;

    } catch ( ActionSequenceException ex ) {

      status = IRuntimeContext.RUNTIME_STATUS_FAILURE;

      audit( MessageTypes.ACTION_SEQUENCE_FAILED, MessageTypes.EXECUTION, "", (int) ( new Date().getTime() - start ) ); //$NON-NLS-1$

      throw ex;

    } catch ( IOException ex ) {

      status = IRuntimeContext.RUNTIME_STATUS_FAILURE;

      audit( MessageTypes.ACTION_SEQUENCE_FAILED, MessageTypes.EXECUTION, "", (int) ( new Date().getTime() - start ) ); //$NON-NLS-1$

      throw new ActionSequenceException( ex );

    }

  }

  public void setPromptStatus( final int status ) {

    promptStatus = status;

  }

  @SuppressWarnings( { "unchecked" } )

  public void executeSequence( final IActionSequence sequence, final IActionCompleteListener doneListener,

      final IExecutionListener execListener, final boolean async ) throws ActionSequenceException {

    String loopParamName = sequence.getLoopParameter();

    boolean peekOnly = sequence.getLoopUsingPeek();

    Object loopList;

    IActionParameter loopParm = null;

    if ( loopParamName == null ) {

      loopList = new ArrayList<Integer>();

      ( (ArrayList) loopList ).add( new Integer( 0 ) );

    } else {

      loopParm = getLoopParameter( loopParamName );

      loopList = loopParm.getValue();

      // If the loop list is an array, convert it to an array list for processing

      if ( loopList instanceof Object[] ) {

        loopList = Arrays.asList( (Object[]) loopList );

      }

    }

    if ( loopList instanceof List ) {

      executeLoop( loopParm, (List) loopList, sequence, doneListener, execListener, async );

      if ( loopParm != null ) {

        addInputParameter( loopParm.getName(), loopParm ); // replace the loop param in case the last loop muggled

                                                           // it

      }

    } else if ( loopList instanceof IPentahoResultSet ) {

      executeLoop( loopParm, (IPentahoResultSet) loopList, sequence, doneListener, execListener, async, peekOnly );

    }

  }

  private void executeLoop( final IActionParameter loopParm, final IPentahoResultSet loopSet,

      final IActionSequence sequence, final IActionCompleteListener doneListener,

      final IExecutionListener execListener, final boolean async, boolean peekOnly ) throws ActionSequenceException {

    // execute the actions

    int loopCount = -1;

    // TODO handle results sets directly instead of using Properties maps

    // Only if the result set is scrollable that is we CAN go back to the first record should we reset

    // to the first record. This is to resolve multiple levels of looping on resultset.

    if ( loopSet.isScrollable() ) {

      loopSet.beforeFirst();

    }

    if ( peekOnly && !( loopSet instanceof IPeekable ) ) {

      throw new ActionExecutionException( Messages.getInstance().getErrorString(

          "RuntimeContext.ERROR_0033_NOT_PEEKABLE" ), //$NON-NLS-1$

          session.getName(), instanceId, getActionSequence().getSequenceName(), null );

    }

    Object[] row = peekOnly ? ( (IPeekable) loopSet ).peek() : loopSet.next();

    Object[][] headerSet = loopSet.getMetaData().getColumnHeaders();

    // TODO handle OLAP result sets

    Object[] headers = headerSet[0];

    while ( row != null ) {

      loopCount++;

      if ( RuntimeContext.debug ) {

        debug( Messages.getInstance()

            .getString( "RuntimeContext.DEBUG_EXECUTING_ACTION", Integer.toString( loopCount ) ) ); //$NON-NLS-1$

      }

      if ( execListener != null ) {

        execListener.loop( this, loopCount );

      }

      if ( loopParm != null ) {

        IActionParameter ap;

        for ( int columnNo = 0; columnNo < headers.length; columnNo++ ) {

          String name = headers[columnNo].toString();

          Object value = row[columnNo];

          String type = null;

          if ( value instanceof String ) {

            type = IActionParameter.TYPE_STRING;

          } else if ( value instanceof Date ) {

            type = IActionParameter.TYPE_DATE;

          } else if ( ( value instanceof Long ) || ( value instanceof Integer ) ) {

            type = IActionParameter.TYPE_INTEGER;

          } else if ( ( value instanceof BigDecimal ) || ( value instanceof Double ) || ( value instanceof Float ) ) {

            type = IActionParameter.TYPE_DECIMAL;

          } else if ( value instanceof String[] ) {

            type = IActionParameter.TYPE_STRING;

          } else if ( value == null ) {

            warn( Messages.getInstance().getString( "RuntimeContext.WARN_VARIABLE_IN_LOOP_IS_NULL", name ) ); //$NON-NLS-1$

          } else {