/*
 * JBoss, Home of Professional Open Source
 * Copyright 2005, JBoss Inc., and individual contributors as indicated
 * by the @authors tag. See the copyright.txt in the distribution for a
 * full listing of individual contributors.
 *
 * This is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * This software 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this software; if not, write to the Free
 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
 */
package org.jbpm.pvm.internal.processengine;

import java.io.Serializable;
import java.sql.Connection;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;

import javax.naming.InitialContext;
import javax.naming.NamingException;

import org.jbpm.api.ExecutionService;
import org.jbpm.api.HistoryService;
import org.jbpm.api.IdentityService;
import org.jbpm.api.JbpmException;
import org.jbpm.api.ManagementService;
import org.jbpm.api.ProcessEngine;
import org.jbpm.api.RepositoryService;
import org.jbpm.api.TaskService;
import org.jbpm.api.cmd.Command;
import org.jbpm.internal.log.Log;
import org.jbpm.pvm.internal.cfg.ConfigurationImpl;
import org.jbpm.pvm.internal.cmd.CheckDbCmd;
import org.jbpm.pvm.internal.cmd.CommandService;
import org.jbpm.pvm.internal.env.Context;
import org.jbpm.pvm.internal.env.EnvironmentFactory;
import org.jbpm.pvm.internal.env.EnvironmentImpl;
import org.jbpm.pvm.internal.env.PvmEnvironment;
import org.jbpm.pvm.internal.env.UserProvidedEnvironmentObject;
import org.jbpm.pvm.internal.jobexecutor.JobExecutor;
import org.jbpm.pvm.internal.wire.WireContext;
import org.jbpm.pvm.internal.wire.WireDefinition;

/**
 * an environment factory that also is the process-engine context.
 * 
 * <p>
 * This environment factory will produce environments with 2 contexts: the
 * process-engine context and the block context.
 * </p>
 * 
 * <p>
 * An process-engine context is build from two wire definitions: the
 * process-engine wire definition and the environment wire definition.
 * </p>
 * 
 * <p>
 * The process-engine context itself is build from the process-engine
 * wire definition. So all objects that are created in this context remain
 * cached for the lifetime of this process-engine context object.
 * </p>
 * 
 * <p>
 * This process-engine context is also a environment factory. The produced
 * environments contain 2 contexts: the process-engine context itself and a
 * new environment context, build from the environment wire definition. For each
 * created environment, a new environment context will be created from the same
 * environment wire definition. Objects in the environment context will live for
 * as long as the environment.
 * </p>
 * 
 * @author Tom Baeyens
 */
public class ProcessEngineImpl implements Context, ProcessEngine, EnvironmentFactory, Serializable {

  private static final long serialVersionUID = 1L;
  private static final Log log = Log.getLog(ProcessEngineImpl.class.getName());
  
  public static final String JBPM_LIBRARY_VERSION = "4.3";

  transient protected WireContext processEngineWireContext;
  transient protected WireDefinition transactionWireDefinition;
  
  transient protected ThreadLocal<List<UserProvidedEnvironmentObject>> userProvidedEnvironmentObjectsThreadLocal = new ThreadLocal<List<UserProvidedEnvironmentObject>>();
  transient protected ThreadLocal<String> authenticatedUserIdThreadLocal = new ThreadLocal<String>();
  
  transient protected CommandService userCommandService = null;
  
  public ProcessEngineImpl() {
  }

  public ProcessEngineImpl(ConfigurationImpl configuration) {
    initializeProcessEngine(configuration);
    checkDb(configuration);
  }

  protected void initializeProcessEngine(ConfigurationImpl configuration) {
    configuration.setProducedProcessEngine(this);
    this.processEngineWireContext = configuration.getProcessEngineWireContext();
    this.transactionWireDefinition = configuration.getTransactionWireDefinition();
    
    if (log.isTraceEnabled()) {
      log.trace("created ProcessEngine "+System.identityHashCode(this));
      if ( (processEngineWireContext!=null)
           && (processEngineWireContext.getWireDefinition()!=null)
           && (processEngineWireContext.getWireDefinition().getDescriptorTypes()!=null)
         ) {
        log.trace("  process-engine-context "+System.identityHashCode(processEngineWireContext));
        for (Class<?> descriptorType: processEngineWireContext.getWireDefinition().getDescriptorTypes()) {
          log.trace("    "+descriptorType.getName());
        }
      }
      if ( (transactionWireDefinition!=null)
           && (transactionWireDefinition.getDescriptorTypes()!=null)
         ) {
        log.trace("  transaction-context:");
        for (Class<?> descriptorType: transactionWireDefinition.getDescriptorTypes()) {
          log.trace("    "+descriptorType.getName());
        }
      }
    }

    processEngineWireContext.create();
    userCommandService = (CommandService) processEngineWireContext.get(CommandService.NAME_TX_REQUIRED_COMMAND_SERVICE);

    String jndiName = configuration.getJndiName();
    if (jndiName!=null) {
      try {
        log.debug("publishing jBPM ProcessEngine in jndi at "+jndiName);
        InitialContext initialContext = new InitialContext();
        initialContext.bind(jndiName, this);
      } catch (NamingException e) {
        throw new JbpmException("JNDI binding problem", e);
      }
    }

  }

  protected void checkDb(ConfigurationImpl configuration) {
    if (configuration.isCheckDb()) {
      userCommandService.execute(new CheckDbCmd());
    }
  }

  public ExecutionService getExecutionService() {
    return get(ExecutionService.class);
  }
  public HistoryService getHistoryService() {
    return get(HistoryService.class);
  }
  public ManagementService getManagementService() {
    return get(ManagementService.class);
  }
  public TaskService getTaskService() {
    return get(TaskService.class);
  }
  public IdentityService getIdentityService() {
    return get(IdentityService.class);
  }
  public RepositoryService getRepositoryService() {
    return get(RepositoryService.class);
  }

  public EnvironmentImpl openEnvironment() {
    PvmEnvironment environment = new PvmEnvironment(this);

    if (log.isTraceEnabled()) log.trace("opening " + environment);

    installAuthenticatedUserId(environment);
    installProcessEngineContext(environment);
    installTransactionContext(environment);

    return environment;
  }

  protected void installAuthenticatedUserId(EnvironmentImpl environment) {
    String authenticatedUserId = authenticatedUserIdThreadLocal.get();
    if (authenticatedUserId!=null) {
      environment.setAuthenticatedUserId(authenticatedUserId);
      authenticatedUserIdThreadLocal.set(null);
    }
  }

  protected void installTransactionContext(PvmEnvironment environment) {
    WireContext transactionContext = new WireContext(transactionWireDefinition, Context.CONTEXTNAME_TRANSACTION, true);
    // add the environment block context to the environment
    environment.setContext(transactionContext);

    EnvironmentImpl.pushEnvironment(environment);
    try {
      // finish the creation of the environment wire context
      transactionContext.create();

    } catch (RuntimeException e) {
      EnvironmentImpl.popEnvironment();
      throw e;
    }
  }

  protected void installProcessEngineContext(PvmEnvironment environment) {
    // add the process-engine context
    environment.setContext(processEngineWireContext);
  }

  public void close() {
    JobExecutor jobExecutor = get(JobExecutor.class);
    if (jobExecutor!=null) {
      // stop the job executor and wait till all job executor threads have stopped.
      jobExecutor.stop(true);
    }
    processEngineWireContext.fire(WireContext.EVENT_CLOSE, null);
  }

  // process-engine context delegation methods
  // ///////////////////////////////////

  public Object get(String key) {
    return processEngineWireContext.get(key);
  }

  public <T> T get(Class<T> type) {
    return processEngineWireContext.get(type);
  }

  public String getName() {
    return processEngineWireContext.getName();
  }

  public boolean has(String key) {
    return processEngineWireContext.has(key);
  }

  public Set<String> keys() {
    return processEngineWireContext.keys();
  }

  public Object set(String key, Object value) {
    return processEngineWireContext.set(key, value);
  }
  
  public void addProcessEngineWireDefinition(WireDefinition wireDefinition) {
    processEngineWireContext.getWireDefinition().addWireDefinition(wireDefinition);
  }

  public void addTransactionWireDefinition(WireDefinition wireDefinition) {
    transactionWireDefinition.addWireDefinition(wireDefinition);
  }

  // getters and setters //////////////////////////////////////////////////////

  public void setTransactionWireDefinition(WireDefinition transactionWireDefinition) {
    this.transactionWireDefinition = transactionWireDefinition;
  }
  public WireContext getProcessEngineWireContext() {
    return processEngineWireContext;
  }
  public void setProcessEngineWireContext(WireContext processEngineWireContext) {
    this.processEngineWireContext = processEngineWireContext;
  }
  public WireDefinition getTransactionWireDefinition() {
    return transactionWireDefinition;
  }

  public ProcessEngine setAuthenticatedUserId(String authenticatedUserId) {
    authenticatedUserIdThreadLocal.set(authenticatedUserId);
    return this;
  }

  public ProcessEngine setHibernateSession(Object hibernateSession) {
    addUserProvidedEnvironmentObject(new UserProvidedEnvironmentObject(hibernateSession, null, true));
    return this;
  }

  public ProcessEngine setJdbcConnection(Connection jdbcConnection) {
    addUserProvidedEnvironmentObject(new UserProvidedEnvironmentObject(jdbcConnection, null, true));
    return this;
  }

  protected synchronized void addUserProvidedEnvironmentObject(UserProvidedEnvironmentObject userProvidedEnvironmentObject) {
    List<UserProvidedEnvironmentObject> environmentObjects = userProvidedEnvironmentObjectsThreadLocal.get();
    if (environmentObjects==null) {
      environmentObjects = new ArrayList<UserProvidedEnvironmentObject>();
      userProvidedEnvironmentObjectsThreadLocal.set(environmentObjects);
    }
    environmentObjects.add(userProvidedEnvironmentObject);
  }

  public <T> T execute(Command<T> command) {
    return userCommandService.execute(command);
  }

  // left in for legacy test code
  public static EnvironmentFactory parseXmlString(String jbpmConfigurationXml) {
    return (EnvironmentFactory) new ConfigurationImpl()
        .setXmlString(jbpmConfigurationXml)
        .skipDbCheck()
        .buildProcessEngine();
  }
}