package org.jbpm.pvm.internal.hibernate;

import java.io.Serializable;
import java.lang.reflect.Method;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;
import java.util.Properties;

import org.hibernate.HibernateException;
import org.hibernate.usertype.ParameterizedType;
import org.hibernate.usertype.UserType;
import org.jbpm.api.Execution;
import org.jbpm.internal.log.Log;
import org.jbpm.pvm.internal.model.ExecutionImpl;
import org.jbpm.pvm.internal.model.ActivityImpl;
import org.jbpm.pvm.internal.model.ProcessDefinitionImpl;
import org.jbpm.pvm.internal.util.ReflectUtil;

public class ExecutionType implements UserType, ParameterizedType {

  private static final long serialVersionUID = 1L;
  private static final Log log = Log.getLog(ExecutionType.class.getName());
  
  int[] sqlTypes = new int[]{Types.VARCHAR};
  
  protected String processResource;
  protected ProcessDefinitionImpl processDefinition;

  public void setParameterValues(Properties properties) {
  }

  public int[] sqlTypes() {
    return sqlTypes;
  }

  // JDBC - object translation 
  
  public Object nullSafeGet(ResultSet rs, String[] names, Object owner) throws HibernateException, SQLException {
    ExecutionImpl execution = createExecution(owner);
    String activityName = rs.getString(names[0]);
    ActivityImpl activity = (ActivityImpl) execution.getProcessDefinition().getActivity(activityName);
    execution.setActivity(activity);
    execution.setState(Execution.STATE_ACTIVE_ROOT);
    return execution;
  }

  private ExecutionImpl createExecution(Object owner) {
    ExecutionImpl execution = new ExecutionImpl();
    execution.setProcessDefinition(getProcessDefinition(owner));
    return execution;
  }

  private synchronized ProcessDefinitionImpl getProcessDefinition(Object owner) {
    if (processDefinition!=null) {
      return processDefinition;
    }
    Class<?> ownerClass = owner.getClass();
    try {
      Method method = ownerClass.getDeclaredMethod("getProcessDefinition");
      processDefinition = (ProcessDefinitionImpl) ReflectUtil.invoke(method, null, null);
    } catch (Exception e) {
      throw new RuntimeException("couldn't get process definition for "+owner, e);
    }
    
    return processDefinition;
  }

  public void nullSafeSet(PreparedStatement st, Object owner, int index) throws HibernateException, SQLException {
    if (owner!=null) {
      ExecutionImpl execution = (ExecutionImpl) owner;
      String activityName = execution.getActivity().getName();
      log.trace("binding 'execution-state{"+activityName+"}' to parameter: "+index);
      st.setString(index, activityName);
    }
  }

  // for dirty checking ?

  public Object deepCopy(Object object) throws HibernateException {
    if (object==null) {
      return null;
    }
    
    ExecutionImpl original = (ExecutionImpl) object;

    ActivityImpl activity = new ActivityImpl();
    activity.setName(original.getActivity().getName());
    
    ExecutionImpl copy = new ExecutionImpl();
    copy.setActivity(activity);

    return copy;
  }

  public boolean equals(Object arg0, Object arg1) throws HibernateException {
    if ( (arg0==null) || (arg1==null)) return false;
    
    ExecutionImpl execution0 = (ExecutionImpl) arg0;
    ExecutionImpl execution1 = (ExecutionImpl) arg1;
    
    String activityName0 = execution0.getActivity().getName();
    String activityName1 = execution1.getActivity().getName();
    
    return activityName0.equals(activityName1);
  }

  public int hashCode(Object object) throws HibernateException {
    return object.hashCode();
  }

  public boolean isMutable() {
    return true;
  }

  public Class<?> returnedClass() {
    return Execution.class;
  }

  // merge functionality //////////////////////////////////////////////////////
  
  public Object replace(Object arg0, Object arg1, Object arg2) throws HibernateException {
    return null;
  }

  // serialization for cache //////////////////////////////////////////////////

  public Object assemble(Serializable arg0, Object arg1) throws HibernateException {
    return null;
  }

  public Serializable disassemble(Object arg0) throws HibernateException {
    return null;
  }
}