/*******************************************************************************
    *  Imixs Workflow 
    *  Copyright (C) 2001, 2011 Imixs Software Solutions GmbH,  
    *  http://www.imixs.com
    *  
    *  This program is free software; you can redistribute it and/or 
    *  modify it under the terms of the GNU General Public License 
    *  as published by the Free Software Foundation; either version 2 
    *  of the License, or (at your option) any later version.
   *  
   *  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.
   *  
   *  You can receive a copy of the GNU General Public
   *  License at http://www.gnu.org/licenses/gpl.html
   *  
   *  Project: 
   *  	http://www.imixs.org
   *  	http://java.net/projects/imixs-workflow
   *  
   *  Contributors:  
   *  	Imixs Software Solutions GmbH - initial API and implementation
   *  	Ralph Soika - Software Developer
   *******************************************************************************/
  
  package org.imixs.workflow;
  
  import java.text.DateFormat;
  import java.util.Date;
  import java.util.List;
  import java.util.Vector;
  import java.util.logging.Logger;
  
  import org.imixs.workflow.exceptions.ModelException;
  import org.imixs.workflow.exceptions.PluginException;
  import org.imixs.workflow.exceptions.ProcessingErrorException;
  
  /**
   * The Workflowkernel is the core component of this Framework to control the
   * processing of a workitem. A <code>Workflowmanager</code> loads an instance of
   * a Workflowkernel and hand over a <code>Model</code> and register
   * <code>Plugins</code> for processing one or many workitems.
   * 
   * @author Ralph Soika
   * @version 1.1
   * @see org.imixs.workflow.WorkflowManager
   */
  
  public class WorkflowKernel {
  
  	/** Log-Levels **/
  	public static final int LOG_LEVEL_SEVERE = 0;
  	public static final int LOG_LEVEL_WARNING = 1;
  	public static final int LOG_LEVEL_FINE = 2;
  
  	/** Plugin objects **/
  	private Vector vectorPluginsClassNames = null;
  	private Vector vectorPlugins = null;
  	private WorkflowContext ctx = null;
  	private ItemCollection documentContext = null;
  	private ItemCollection documentActivity = null;
  	// private ItemCollection documentProcess = null;
  	private Vector vectorEdgeHistory = new Vector();
  
  	private static Logger logger = Logger.getLogger("org.imixs.workflow");
  
  	/**
  	 * Constructor initialize the contextObject and plugin vectors
  	 */
  	public WorkflowKernel(WorkflowContext actx) {
  		ctx = actx;
  
  		vectorPluginsClassNames = new Vector();
  		vectorPlugins = new Vector();
  	}
  
  	public void registerPlugin(String aClassName) {
  		vectorPluginsClassNames.addElement(aClassName);
  		if (ctx.getLogLevel() == LOG_LEVEL_FINE)
  			logger.info("[WorkflowKernel] register Plugin: " + aClassName);
  	}
  
  	/**
  	 * Processes a workitem. The Workitem have at least provide the properties
  	 * "$processid" and "$activityid"
  	 * 
  	 * @param document
  	 * @throws ProcessingErrorException
  	 */
  	public void process(ItemCollection document)
  			throws ProcessingErrorException {
  
  		vectorEdgeHistory = new Vector();
  		documentContext = document;
  
  		// check document context
  		if (document == null)
 			throw new ProcessingErrorException(
 					"[WorkflowKernel] processing error: document==null");
 
 		// check processID
 		if (document.getItemValueInteger("$processid") <= 0)
 			throw new ProcessingErrorException(
 					"[WorkflowKernel] processing error: $processid undefined ("
 							+ document.getItemValueInteger("$processid") + ")");
 
 		// check activityid
 
 		if (document.getItemValueInteger("$activityid") <= 0)
 			throw new ProcessingErrorException(
 					"[WorkflowKernel] processing error: $activityid undefined ("
 							+ document.getItemValueInteger("$activityid") + ")");
 
 		// Check if $UniqueID is available
 		if ("".equals(documentContext.getItemValueString("$UniqueID"))) {
 			// generating a new one
 			documentContext.replaceItemValue("$UniqueID", generateUniqueID());
 		}
 
 		// log the general processing message
 		String msg = "[WorkflowKernel] processing="
 				+ documentContext.getItemValueString("$UniqueID")
 				+ ", $modelversion="
 				+ document.getItemValueString("$modelversion")
 				+ ", $processid=" + document.getItemValueInteger("$processid")
 				+ ", $activityid="
 				+ document.getItemValueInteger("$activityid");
 
 		if (ctx.getLogLevel() == LOG_LEVEL_FINE)
 			msg += ", Log-Level=FINE ";
 		else if (ctx.getLogLevel() == LOG_LEVEL_WARNING)
 			msg += ", Log-Level=WARNING ";
 		else
 			msg += ", Log-Level=SEVERE ";
 
 		logger.info(msg);
 
 		// Check if $WorkItemID is available
 		if ("".equals(documentContext.getItemValueString("$WorkItemID"))) {
 			documentContext.replaceItemValue("$WorkItemID", generateUniqueID());
 		}
 
 		// now process all activites defined by the model
 		while (hasMoreActivities())
 			processActivity();
 
 	}
 
 	/**
 	 * This method controls the Process-Chain The method returns true if a) a
 	 * valid $activityid exists b) the attribute $activityidlist has more valid
 	 * ActivityIDs
 	 * 
 	 **/
 	private boolean hasMoreActivities() {
 		int integerID;
 
 		// is $activityid provided?
 		integerID = documentContext.getItemValueInteger("$activityid");
 
 		if ((integerID > 0))
 			return true;
 		else {
 			// no - test for property $ActivityIDList
 			List v = documentContext.getItemValue("$activityidlist");
 
 			// remove 0 values if contained!
 			while (v.indexOf(Integer.valueOf(0)) > -1) {
 				v.remove(v.indexOf(Integer.valueOf(0)));
 			}
 
 			// test if an id is found....
 			if (v.size() > 0) {
 				// yes - load next ID from activityID List
 				int iNextID = 0;
 				Object oA = v.get(0);
 				if (oA instanceof Integer)
 					iNextID = ((Integer) oA).intValue();
 				if (oA instanceof Double)
 					iNextID = ((Double) oA).intValue();
 
 				if (iNextID > 0) {
 					// load activity
 					if (ctx.getLogLevel() == LOG_LEVEL_FINE)
 						logger.info("[WorkflowKernel] loading next activityID from $activityidlist="
 								+ iNextID);
 					v.remove(0);
 					// update document context
 					documentContext.replaceItemValue("$activityid",
 							Integer.valueOf(iNextID));
 					documentContext.replaceItemValue("$activityidlist", v);
 					return true;
 				}
 			}
 			// no more Activities defined
 			return false;
 		}
 
 	}
 
 	/**
 	 * This method creates a unique key which can be used as a primary key. The
 	 * method is used by the 'checkWorkItemID()' method and the checkUniqueID()
 	 * method.
 	 * <p>
 	 * The uniqueid consits of two parts containing a random unique char
 	 * sequence
 	 * 
 	 * @return
 	 */
 	public static String generateUniqueID() {
 		String sIDPart1 = Long.toHexString(System.currentTimeMillis());
 		double d = Math.random() * 900000000;
 		int i = new Double(d).intValue();
 		String sIDPart2 = Integer.toHexString(i);
 		String id = sIDPart1 + "-" + sIDPart2;
 
 		return id;
 	}
 
 	/**
 	 * This method process a activity instance by loading and running all
 	 * plugins.
 	 * 
 	 * If an FollowUp Activity is defined (keyFollowUp="1" &
 	 * numNextActivityID>0) it will be attached at the $ActiviyIDList.
 	 * 
 	 * @throws ProcessingErrorException
 	 */
 	private void processActivity() throws ProcessingErrorException {
 
 		loadActivity();
 
 		// run plugins - PluginExceptions will bubble up....
 		loadPlugins();
 		int iStatus = runPlugins();
 		closePlugins(iStatus);
 
 		if (iStatus == Plugin.PLUGIN_ERROR) {
 			throw new ProcessingErrorException(
 					"[WorkflowKernel] Error in Plugin detected.");
 		}
 
 		writeLog();
 
 		// put current edge in history
 		vectorEdgeHistory.addElement(documentActivity
 				.getItemValueInteger("numprocessid")
 				+ "."
 				+ documentActivity.getItemValueInteger("numactivityid"));
 
 		/*** get Next Task **/
 		int iNewProcessID = documentActivity
 				.getItemValueInteger("numnextprocessid");
 		if (ctx.getLogLevel() == LOG_LEVEL_FINE)
 			logger.info("[WorkflowKernel] next $processid=" + iNewProcessID
 					+ "");
 
 		// NextProcessID will only be set if NextTask>0
 		if (iNewProcessID > 0) {
 			documentContext.replaceItemValue("$processid",
 					Integer.valueOf(iNewProcessID));
 		}
 
 		// clear ActivityID and create new workflowActivity Instance
 		documentContext.replaceItemValue("$activityid", Integer.valueOf(0));
 
 		// FollowUp Activity ?
 		String sFollowUp = documentActivity.getItemValueString("keyFollowUp");
 		int iNextActivityID = documentActivity
 				.getItemValueInteger("numNextActivityID");
 		if ("1".equals(sFollowUp) && iNextActivityID > 0) {
 			this.appendActivityID(iNextActivityID);
 		}
 
 	}
 
 	/**
 	 * This method adds a new ActivityID into the current activityList
 	 * ($ActivityIDList) The activity list may not contain 0 values.
 	 * 
 	 */
 	@SuppressWarnings("unchecked")
 	private void appendActivityID(int aID) {
 
 		// check if activityidlist is available
 		List v = documentContext.getItemValue("$ActivityIDList");
 		if (v == null)
 			v = new Vector();
 		// clear list?
 		if ((v.size() == 1) && ("".equals(v.get(0).toString())))
 			v = new Vector();
 
 		v.add(Integer.valueOf(aID));
 
 		// remove 0 values if contained!
 		while (v.indexOf(Integer.valueOf(0)) > -1) {
 			v.remove(v.indexOf(Integer.valueOf(0)));
 		}
 
 		documentContext.replaceItemValue("$ActivityIDList", v);
 		if (ctx.getLogLevel() == LOG_LEVEL_FINE)
 			logger.info("[WorkflowKernel]  append new Activity ID=" + aID);
 
 	}
 
 	/**
 	 * This method is responsible for the internal workflow log. The attribute
 	 * txtworkflowactivitylog logs the work-flow from one process to another.
 	 * 
 	 */
 	private void writeLog() {
 
 		String sLog = DateFormat.getDateTimeInstance(DateFormat.MEDIUM,
 				DateFormat.MEDIUM).format(new Date());
 
 		// 22.9.2004 13:50:41|1000.90:=1000
 		sLog = sLog + "|"
 				+ documentActivity.getItemValueInteger("numprocessid") + "."
 				+ documentActivity.getItemValueInteger("numactivityid") + ":="
 				+ documentActivity.getItemValueInteger("numnextprocessid");
 
 		List vLog =  documentContext
 				.getItemValue("txtworkflowactivitylog");
 		if (vLog == null)
 			vLog = new Vector();
 
 		vLog.add(sLog);
 		documentContext.replaceItemValue("txtworkflowactivitylog", vLog);
 		documentContext
 				.replaceItemValue("numlastactivityid", Integer
 						.valueOf(documentActivity
 								.getItemValueInteger("numactivityid")));
 
 	}
 
 	/**
 	 * This Method loads the current Activity Entity from the provides Model
 	 * 
 	 * The method also verifies the activity to be valid
 	 * 
 	 * @throws ProcessingErrorException
 	 */
 	private void loadActivity() throws ProcessingErrorException {
 
 		int aProcessID = documentContext.getItemValueInteger("$processid");
 		int aActivityID = documentContext.getItemValueInteger("$activityid");
 
 		// determine model version
 		String sModelVersion = documentContext
 				.getItemValueString("$modelversion");
 
 		// depending of the provided Workflow Context call different methods
 		if (ctx instanceof ExtendedWorkflowContext)
 			documentActivity = ((ExtendedWorkflowContext) ctx)
 					.getExtendedModel().getActivityEntityByVersion(aProcessID,
 							aActivityID, sModelVersion);
 		else
 			documentActivity = ctx.getModel().getActivityEntity(aProcessID,
 					aActivityID);
 
 		if (documentActivity == null)
 			throw new ProcessingErrorException("[WorkflowKernel] model entry "
 					+ aProcessID + "." + aActivityID + " not found");
 
 		if (ctx.getLogLevel() == LOG_LEVEL_FINE)
 			logger.info("[WorkflowKernel] loadActivity: " + aProcessID + "."
 					+ aActivityID + " successfully");
 
 		// Check for loop in edge history
 		if (vectorEdgeHistory != null) {
 			if (vectorEdgeHistory.indexOf((aProcessID + "." + aActivityID)) != -1)
 				throw new ModelException("[WorkflowKernel] loop detected "
 						+ aProcessID + "." + aActivityID + ","
 						+ vectorEdgeHistory.toString());
 		}
 
 	}
 
 	/**
 	 * loads all plugins
 	 * 
 	 * @throws ProcessingErrorException
 	 */
 	private void loadPlugins() throws PluginException {
 
 		// Warning if no plugins registerd!
 		if (vectorPluginsClassNames.size() == 0
 				&& ctx.getLogLevel() >= LOG_LEVEL_FINE)
 			logger.info("[WorkflowKernel] Warning loadPlugins: no plugins defined!");
 
 		for (int i = 0; i < vectorPluginsClassNames.size(); i++) {
 			/**** Pluglin laden ***/
 			String sPluginClass = vectorPluginsClassNames.elementAt(i)
 					.toString();
 
 			if ((sPluginClass != null) && (!"".equals(sPluginClass))) {
 				if (ctx.getLogLevel() == LOG_LEVEL_FINE) {
 					logger.info("[WorkflowKernel] loading Plugin "
 							+ sPluginClass + "...");
 				}
 				Class clazz = null;
 				try {
 					clazz = Class.forName(sPluginClass);
 					Plugin plugin = (Plugin) clazz.newInstance();
 					plugin.init(ctx);
 					vectorPlugins.add(plugin);
 
 				} catch (ClassNotFoundException e) {
 					throw new PluginException(
 							"[WorkflowKernel] Could not create Plugin: "
 									+ sPluginClass + " Reason: " + e.toString(),
 							e);
 				} catch (InstantiationException e) {
 					throw new PluginException(
 							"[WorkflowKernel] Could not create Plugin: "
 									+ sPluginClass + " Reason: " + e.toString(),
 							e);
 				} catch (IllegalAccessException e) {
 					throw new PluginException(
 							"[WorkflowKernel] Could not create Plugin: "
 									+ sPluginClass + " Reason: " + e.toString(),
 							e);
 				}
 
 			}
 
 		}
 
 	}
 
 	/**
 	 * This method runs all registered plugins until the run method of a plugin
 	 * breaks with an error In this case the method stops The attribute
 	 * txtWorkflowPluginLog will store the list of process plugins with a
 	 * timestamp
 	 * 
 	 * @throws ProcessingErrorException
 	 */
 	private int runPlugins() throws PluginException {
 		int iStatus;
 		String sPluginName = null;
 		List<String> localPluginLog = new Vector<String>();
 		List<String> vectorPluginLog;
 
 		try {
 
 			vectorPluginLog = documentContext
 					.getItemValue("txtWorkflowPluginLog");
 			for (int i = 0; i < vectorPlugins.size(); i++) {
 				Plugin plugin = (Plugin) vectorPlugins.elementAt(i);
 				sPluginName = plugin.getClass().getName();
 				if (ctx.getLogLevel() == LOG_LEVEL_FINE)
 					logger.info("[WorkflowKernel] running Plugin: "
 							+ sPluginName + "...");
 
 				try {
 					iStatus = plugin.run(documentContext, documentActivity);
 				} catch (PluginException e) {
 					throw new PluginException(
 							"[WorkflowKernel] Error running Plugin: "
 									+ sPluginName + " Reason: " + e.toString(),
 							e);
 				}
 				// write PluginLog
 				String sLog = DateFormat.getDateTimeInstance(DateFormat.LONG,
 						DateFormat.MEDIUM).format(new Date());
 
 				sLog = sLog + " " + plugin.getClass().getName() + "=" + iStatus;
 
 				localPluginLog.add(sLog);
 				vectorPluginLog.add(sLog);
 
 				if (iStatus == Plugin.PLUGIN_ERROR) {
 					// write PluginLog into workitem
 					documentContext.replaceItemValue("txtWorkflowPluginLog",
 							vectorPluginLog);
 
 					// log error....
 					logger.severe("[WorkflowKernel] Error processing Plugin: "
 							+ sPluginName);
 					logger.severe("[WorkflowKernel] Plugin-Log: ");
 					for (String sLogEntry : localPluginLog)
 						logger.severe("[WorkflowKernel]   " + sLogEntry);
 
 					return Plugin.PLUGIN_ERROR;
 				}
 			}
 			// write PluginLog into workitem
 			documentContext.replaceItemValue("txtWorkflowPluginLog",
 					vectorPluginLog);
 			return Plugin.PLUGIN_OK;
 
 		} catch (PluginException e) {
 			// log plugin stack!....
 			logger.severe("[WorkflowKernel] Plugin-Stack: ");
 			for (String sLogEntry : localPluginLog)
 				logger.severe("[WorkflowKernel]   " + sLogEntry);
 			// re throw the PluginException !
 			throw e;
 		}
 
 	}
 
 	private void closePlugins(int astatus) throws PluginException {
 
 		for (int i = 0; i < vectorPlugins.size(); i++) {
 			Plugin plugin = (Plugin) vectorPlugins.elementAt(i);
 			if (ctx.getLogLevel() == LOG_LEVEL_FINE)
 				logger.info("[WorkflowKernel] closing Plugin: "
 						+ plugin.getClass().getName() + "...");
 			try {
 				plugin.close(astatus);
 			} catch (PluginException e) {
 				throw new PluginException(
 						"[WorkflowKernel] Could not close Plugin: "
 								+ plugin.getClass().getName() + " Reason: "
 								+ e.toString(), e);
 			}
 		}
 		// reset Plugins
 		vectorPlugins = new Vector();
 
 	}
 
 }