/FileExtraction/Java_unseen/dlitz_resin/modules/resin/src/com/caucho/env/jpa/EntityManagerJtaProxy.java
/*
 * Copyright (c) 1998-2011 Caucho Technology -- all rights reserved
 *
 * This file is part of Resin(R) Open Source
 *
 * Each copy or derived work must preserve the copyright notice and this
 * notice unmodified.
 *
 * Resin Open Source 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.
 *
 * Resin Open Source 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, or any warranty
 * of NON-INFRINGEMENT.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Resin Open Source; if not, write to the
 *
 *   Free Software Foundation, Inc.
 *   59 Temple Place, Suite 330
 *   Boston, MA 02111-1307  USA
 *
 * @author Scott Ferguson
 */

package com.caucho.env.jpa;

import java.util.Map;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.FlushModeType;
import javax.persistence.LockModeType;
import javax.persistence.Query;
import javax.persistence.TransactionRequiredException;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.metamodel.Metamodel;
import javax.transaction.Status;
import javax.transaction.Synchronization;
import javax.transaction.SystemException;
import javax.transaction.Transaction;

import com.caucho.amber.AmberRuntimeException;
import com.caucho.config.inject.HandleAware;
import com.caucho.transaction.ManagedResource;
import com.caucho.transaction.ManagedXAResource;
import com.caucho.transaction.TransactionImpl;
import com.caucho.transaction.UserTransactionProxy;
import com.caucho.util.FreeList;
import com.caucho.util.L10N;

/**
 * The @PersistenceContext, container managed entity manager proxy, used
 * for third-party providers.
 */
@SuppressWarnings("serial")
public class EntityManagerJtaProxy
  implements EntityManager, java.io.Serializable, HandleAware
{
  private static final L10N L = new L10N(EntityManagerJtaProxy.class);
  
  private final PersistenceUnitManager _persistenceUnit;
  
  private EntityManagerFactory _emf;

  private final UserTransactionProxy _ut;

  private final FreeList<EntityManager> _idleEntityManagerPool
    = new FreeList<EntityManager>(8);

  /*
  private final ThreadLocal<EntityManagerItem> _threadEntityManager
    = new ThreadLocal<EntityManagerItem>();
    */

  private Object _serializationHandle;
  
  public EntityManagerJtaProxy(PersistenceUnitManager pUnit)
  {
    _persistenceUnit = pUnit;
    _ut = UserTransactionProxy.getCurrent();
    
    if (_persistenceUnit == null)
      throw new NullPointerException();
    if (_ut == null)
      throw new NullPointerException();
  }
  
  void init()
  {
  }

  @Override
  public EntityManagerFactory getEntityManagerFactory()
  {
    EntityManager em = getCurrent();
    
    if (em != null)
      return em.getEntityManagerFactory();
    
    em = createEntityManager();
    
    try {
      return em.getEntityManagerFactory();
    } finally {
      freeEntityManager(em);
    }
  }

  @Override
  public Map<String, Object> getProperties()
  {
    EntityManager em = getCurrent();
    
    if (em != null)
      return em.getProperties();
    
    em = createEntityManager();
    
    try {
      return em.getProperties();
    } finally {
      freeEntityManager(em);
    }
  }

  @Override
  public void setProperty(String propertyName, Object value)
  {
    EntityManager em = getCurrent();
    
    if (em != null) {
      em.setProperty(propertyName, value);
      return;
    }
    
    em = createEntityManager();
    
    try {
      em.setProperty(propertyName, value);
    } finally {
      freeEntityManager(em);
    }
  }

  /**
   * Joins the transaction.
   */
  @Override
  public void joinTransaction()
  {
    throw new IllegalStateException(L.l("Container-manager @PersistenceContext may not use joinTransaction."));
  }

  /**
   * Gets the delegate.
   */
  @Override
  public Object getDelegate()
  {
    EntityManager em = getCurrent();
    
    if (em != null) {
      return em;
    }
    
    em = createEntityManager();
    
    try {
      // XXX: unclear if this should be allowed, because it's put back
      // into the pool
      
      return em;
    } finally {
      freeEntityManager(em);
    }
  }

  /**
   * Sets the extended type.
   */
  public void setExtended(boolean isExtended)
  {
    throw new IllegalStateException(L.l("Container-managed @PersistenceContext may not be converted to extended"));
  }

  @Override
  public Metamodel getMetamodel()
  {
    EntityManager em = getCurrent();
    
    if (em != null) {
      return em.getMetamodel();
    }
    
    em = createEntityManager();
    
    try {
      return em.getMetamodel();
    } finally {
      freeEntityManager(em);
    }
  }

  @Override
  public CriteriaBuilder getCriteriaBuilder()
  {
    EntityManager em = getCurrent();
    
    if (em != null) {
      return em.getCriteriaBuilder();
    }
    
    em = createEntityManager();
    
    try {
      return em.getCriteriaBuilder();
    } finally {
      freeEntityManager(em);
    }
  }

  /**
   * Find by the primary key.
   */
  @Override
  public <T> T find(Class<T> entityClass, Object primaryKey)
  {
    EntityManager em = getCurrent();
    
    if (em != null) {
      try {
        T value = em.find(entityClass, primaryKey);

        return value;
      } catch (RuntimeException e) {
        throw e;
      }
    }
    
    em = createEntityManager();
    
    try {
      T value = em.find(entityClass, primaryKey);

      return value;
    } finally {
      freeEntityManager(em);
    }
  }

  @Override
  public <T> T find(Class<T> entityClass, Object primaryKey,
                    Map<String, Object> properties)
  {
    EntityManager em = getCurrent();
    
    if (em != null)
      return em.find(entityClass, primaryKey, properties);
    
    em = createEntityManager();
    
    try {
      return em.find(entityClass, primaryKey, properties);
    } finally {
      freeEntityManager(em);
    }
  }

  @Override
  public <T> T find(Class<T> entityClass, Object primaryKey,
                    LockModeType lockMode)
  {
    EntityManager em = getCurrent();
    
    if (em != null)
      return em.find(entityClass, primaryKey, lockMode);
    
    em = createEntityManager();
    
    try {
      return em.find(entityClass, primaryKey, lockMode);
    } finally {
      freeEntityManager(em);
    }
  }

  @Override
  public <T> T find(Class<T> entityClass, Object primaryKey,
                    LockModeType lockMode, Map<String, Object> properties)
  {
    EntityManager em = getCurrent();
    
    if (em != null)
      return em.find(entityClass, primaryKey, lockMode, properties);
    
    em = createEntityManager();
    
    try {
      return em.find(entityClass, primaryKey, lockMode, properties);
    } finally {
      freeEntityManager(em);
    }
  }

  /**
   * Find by the primary key.
   */
  @Override
  public <T> T getReference(Class<T> entityClass, Object primaryKey)
  {
    EntityManager em = getCurrent();
    
    if (em != null)
      return em.getReference(entityClass, primaryKey);
    
    em = createEntityManager();
    
    try {
      return em.getReference(entityClass, primaryKey);
    } finally {
      freeEntityManager(em);
    }
  }

  /**
   * Makes the instance managed.
   */
  @Override
  public void persist(Object entity)
  {
    EntityManager em = getCurrent();

    if (em != null) {
      em.persist(entity);
      return;
    }

    try {
      if (_ut.getStatus() == Status.STATUS_NO_TRANSACTION)
        throw new TransactionRequiredException(L.l("persist must be called within transaction."));
    } catch (SystemException e) {
      throw new RuntimeException(e);
    }

    em = createEntityManager();
    
    try {
      em.persist(entity);
    } finally {
      freeEntityManager(em);
    }
  }

  /**
   * Merges the state of the entity into the current context.
   */
  @Override
  public <T> T merge(T entity)
  {
    EntityManager em = getCurrent();
    
    if (em != null) {
      return em.merge(entity);
    }
    
    em = createEntityManager();
    
    try {
      return em.merge(entity);
    } finally {
      freeEntityManager(em);
    }
  }

  /**
   * Remove the instance.
   */
  @Override
  public void remove(Object entity)
  {
    EntityManager em = getCurrent();
    
    if (em != null) {
      em.remove(entity);
      return;
    }

    try {
      if (_ut.getStatus() == Status.STATUS_NO_TRANSACTION)
        throw new TransactionRequiredException(L.l("remove must be called within transaction."));
    } catch (SystemException e) {
      throw new RuntimeException(e);
    }

    em = createEntityManager();
    
    try {
      em.remove(entity);
    } finally {
      freeEntityManager(em);
    }
  }

  /**
   * Refresh the state of the instance from the database.
   */
  @Override
  public void refresh(Object entity)
  {
    EntityManager em = getCurrent();
    
    if (em != null) {
      em.refresh(entity);
      return;
    }

    try {
      if (_ut.getStatus() == Status.STATUS_NO_TRANSACTION)
        throw new TransactionRequiredException(L.l("refresh must be called within transaction."));
    } catch (SystemException e) {
      throw new RuntimeException(e);
    }

    em = createEntityManager();
    
    try {
      em.refresh(entity);
    } finally {
      freeEntityManager(em);
    }
  }

  @Override
  public void refresh(Object entity, Map<String, Object> properties)
  {
    EntityManager em = getCurrent();
    
    if (em != null) {
      em.refresh(entity, properties);
      return;
    }
    
    em = createEntityManager();
    
    try {
      em.refresh(entity, properties);
    } finally {
      freeEntityManager(em);
    }
  }

  @Override
  public void refresh(Object entity, LockModeType lockMode)
  {
    EntityManager em = getCurrent();
    
    if (em != null) {
      em.refresh(entity, lockMode);
      return;
    }
    
    em = createEntityManager();
    
    try {
      em.refresh(entity, lockMode);
    } finally {
      freeEntityManager(em);
    }
  }

  @Override
  public void refresh(Object entity, LockModeType lockMode,
                      Map<String, Object> properties)
  {
    EntityManager em = getCurrent();
    
    if (em != null) {
      em.refresh(entity, lockMode, properties);
      return;
    }
    
    em = createEntityManager();
    
    try {
      em.refresh(entity, lockMode, properties);
    } finally {
      freeEntityManager(em);
    }
  }

  @Override
  public void detach(Object entity)
  {
    EntityManager em = getCurrent();
    
    if (em != null) {
      em.detach(entity);
      return;
    }
    
    em = createEntityManager();
    
    try {
      em.detach(entity);
    } finally {
      freeEntityManager(em);
    }
  }

  /**
   * Returns true if the entity belongs to the current context.
   */
  @Override
  public boolean contains(Object entity)
  {
    EntityManager em = getCurrent();
    
    if (em != null) {
      return em.contains(entity);
    }
    
    em = createEntityManager();
    
    try {
      return em.contains(entity);
    } finally {
      freeEntityManager(em);
    }
  }

  /**
   * Returns the flush mode.
   */
  @Override
  public FlushModeType getFlushMode()
  {
    EntityManager em = getCurrent();
    
    if (em != null)
      return em.getFlushMode();
    
    em = createEntityManager();
    
    try {
      return em.getFlushMode();
    } finally {
      freeEntityManager(em);
    }
  }

  /**
   * Sets the flush mode.
   */
  @Override
  public void setFlushMode(FlushModeType mode)
  {
    EntityManager em = getCurrent();
    
    if (em != null) {
      em.setFlushMode(mode);
      return;
    }
    
    em = createEntityManager();
    
    try {
      em.setFlushMode(mode);
    } finally {
      freeEntityManager(em);
    }
  }

  /**
   * Synchronize with the database.
   */
  @Override
  public void flush()
  {
    EntityManager em = getCurrent();
    
    if (em != null) {
      em.flush();
      return;
    }
    
    em = createEntityManager();
    
    try {
      em.flush();
    } finally {
      freeEntityManager(em);
    }
  }

  @Override
  public LockModeType getLockMode(Object entity)
  {
    EntityManager em = getCurrent();
    
    if (em != null) {
      return em.getLockMode(entity);
    }
    
    em = createEntityManager();
    
    try {
      return em.getLockMode(entity);
    } finally {
      freeEntityManager(em);
    }
  }

  /**
   * Locks the object.
   */
  @Override
  public void lock(Object entity, LockModeType lockMode)
  {
    EntityManager em = getCurrent();
    
    if (em != null) {
      em.lock(entity, lockMode);
      return;
    }
    
    em = createEntityManager();
    
    try {
      em.lock(entity, lockMode);
    } finally {
      freeEntityManager(em);
    }
  }

  @Override
  public void lock(Object entity, LockModeType lockMode,
                   Map<String, Object> properties)
  {
    EntityManager em = getCurrent();
    
    if (em != null) {
      em.lock(entity, lockMode, properties);
      return;
    }
    
    em = createEntityManager();
    
    try {
      em.lock(entity, lockMode, properties);
    } finally {
      freeEntityManager(em);
    }
  }

  /**
   * Creates a query.
   */
  @Override
  public Query createQuery(String sql)
  {
    EntityManager em = getCurrent();
    
    if (em != null) {
      return em.createQuery(sql);
    }
    
    em = createEntityManager();
    
    try {
      return em.createQuery(sql);
    } finally {
      freeEntityManager(em);
    }
  }

  /**
   * Creates an instance of the named query
   */
  @Override
  public Query createNamedQuery(String sql)
  {
    EntityManager em = getCurrent();
    
    if (em != null) {
      return em.createNamedQuery(sql);
    }
    
    em = createEntityManager();
    
    try {
      return em.createNamedQuery(sql);
    } finally {
      freeEntityManager(em);
    }
  }

  /**
   * Creates a query.
   */
  @Override
  public Query createNativeQuery(String sql)
  {
    EntityManager em = getCurrent();
    
    if (em != null) {
      return em.createNativeQuery(sql);
    }
    
    em = createEntityManager();
    
    try {
      return em.createNativeQuery(sql);
    } finally {
      freeEntityManager(em);
    }
  }

  /**
   * Creates a query.
   */
  @Override
  public Query createNativeQuery(String sql, String map)
  {
    EntityManager em = getCurrent();
    
    if (em != null) {
      return em.createNativeQuery(sql, map);
    }
    
    em = createEntityManager();
    
    try {
      return em.createNativeQuery(sql, map);
    } finally {
      freeEntityManager(em);
    }
  }

  /**
   * Creates a query.
   */
  @Override
  @SuppressWarnings("unchecked")
  public Query createNativeQuery(String sql, Class retType)
  {
    EntityManager em = getCurrent();
    
    if (em != null) {
      return em.createNativeQuery(sql, retType);
    }
    
    em = createEntityManager();
    
    try {
      return em.createNativeQuery(sql, retType);
    } finally {
      freeEntityManager(em);
    }
  }

  @Override
  public <T> TypedQuery<T> createNamedQuery(String name, Class<T> resultClass)
  {
    EntityManager em = getCurrent();
    
    if (em != null) {
      return em.createNamedQuery(name, resultClass);
    }
    
    em = createEntityManager();
    
    try {
      return em.createNamedQuery(name, resultClass);
    } finally {
      freeEntityManager(em);
    }
  }

  @Override
  public <T> TypedQuery<T> createQuery(CriteriaQuery<T> criteriaQuery)
  {
    EntityManager em = getCurrent();
    
    if (em != null) {
      return em.createQuery(criteriaQuery);
    }
    
    em = createEntityManager();
    
    try {
      return em.createQuery(criteriaQuery);
    } finally {
      freeEntityManager(em);
    }
  }

  @Override
  public <T> TypedQuery<T> createQuery(String query,
                                       Class<T> resultClass)
  {
    EntityManager em = getCurrent();

    if (em != null) {
      return em.createQuery(query, resultClass);
    }

    em = createEntityManager();

    try {
      return em.createQuery(query, resultClass);
    } finally {
      freeEntityManager(em);
    }
  }

  @Override
  public <T> T unwrap(Class<T> cls)
  {
    EntityManager em = getCurrent();
    
    if (em != null) {
      return em.unwrap(cls);
    }
    
    em = createEntityManager();
    
    try {
      return em.unwrap(cls);
    } finally {
      freeEntityManager(em);
    }
  }

  /**
   * Returns the entity manager transaction.
   */
  @Override
  public EntityTransaction getTransaction()
  {
    throw new IllegalStateException(L.l("Container-manager @PersistenceContext may not use getTransaction."));
  }

  /**
   * Returns true if open.
   */
  @Override
  public boolean isOpen()
  {
    return true;
  }

  /**
   * Clears the manager.
   */
  @Override
  public void clear()
  {
    EntityManager em = getCurrent();

    if(em != null)
      em.clear();
  }

  /**
   * Clears the manager.
   */
  @Override
  public void close()
  {
    throw new IllegalStateException(L.l("Container-manager @PersistenceContext may not be closed."));
  }
  
  void closeImpl()
  {
    EntityManager em = null;
    
    while ((em = _idleEntityManagerPool.allocate()) != null) {
      em.close();
    }
  }

  /**
   * Returns the current EntityManager.
   */
  private EntityManager getCurrent()
  {
    try {
      TransactionImpl xa = (TransactionImpl) _ut.getTransaction();
      
      if (xa == null)
        return null;
      
      EntityManagerItem item;
      
      item = (EntityManagerItem) xa.getAttribute("resin.env.jpa.EntityManagerItem");
      
      if (item != null) {
        return item.getEntityManager();
      }

      if (_emf == null) {
        _emf = _persistenceUnit.getEntityManagerFactoryDelegate();
        
        if (_emf == null)
          throw new IllegalStateException(L.l("{0}: EntityManagerFactory cannot be found from {1}",
                                              this, _persistenceUnit));
      }

      EntityManager em;
      
      if (xa != null && xa.getStatus() == Status.STATUS_ACTIVE) {
        em = _emf.createEntityManager(_persistenceUnit.getProperties());

        item = new EntityManagerItem(item, em, xa);

        xa.setAttribute("resin.env.jpa.EntityManagerItem", item);
        
        // _threadEntityManager.set(item);

        xa.registerSynchronization(item);

        return em;
      }

      /*
      // env/0e70
      UserTransactionImpl ut = _ut.getCurrentUserTransactionImpl();

      if (ut != null && ut.isInContext()) {
        em = _emf.createEntityManager(_persistenceUnit.getProperties());

        item = new EntityManagerItem(null, em, xa);
        
        _threadEntityManager.set(item);

        ut.enlistResource(item);

        return em;
      }
      */
      
      return null;
    } catch (RuntimeException e) {
      throw e;
    } catch (Exception e) {
      throw new AmberRuntimeException(e);
    }
  }
  
  /**
   * Creates a transienct EM for outside a transaction.
   */
  private EntityManager createEntityManager()
  {
    EntityManager em = _idleEntityManagerPool.allocate();
    
    if (em == null) {
      if (_emf == null) {
        _emf = _persistenceUnit.getEntityManagerFactoryDelegate();
      }
      
      if (_emf == null)
        throw new IllegalStateException(L.l("{0} does not have a valid delegate.",
                                            _persistenceUnit));
      
      em = _emf.createEntityManager(_persistenceUnit.getProperties());
    }
    
    return em;
  }
  
  private void freeEntityManager(EntityManager em)
  {
    em.clear();

    if (! _idleEntityManagerPool.free(em))
      em.close();
  }

  /**
   * Serialization handle
   */
  public void setSerializationHandle(Object handle)
  {
    _serializationHandle = handle;
  }

  /**
   * Serialize to the handle.
   */
  private Object writeReplace()
  {
    return _serializationHandle;
  }

  @Override
  public String toString()
  {
    return getClass().getSimpleName() + "[" + _persistenceUnit + "]";
  }

  class EntityManagerItem implements Synchronization, ManagedResource {
    private final EntityManagerItem _prev;
    
    private final EntityManager _em;
    private final Transaction _xa;
    
    EntityManagerItem(EntityManagerItem prev,
                      EntityManager em,
                      Transaction xa)
    {
      _prev = prev;
      _em = em;
      _xa = xa;
    }
    
    EntityManager getEntityManager()
    {
      return _em;
    }
    
    Transaction getXa()
    {
      return _xa;
    }
    
    EntityManagerItem getPrev()
    {
      return _prev;
    }

    @Override
    public void beforeCompletion()
    {
    }

    @Override
    public void afterCompletion(int status)
    {
      close();
    }

    public void close()
    {
      // _threadEntityManager.set(_prev);

      freeEntityManager(_em);
    }

    @Override
    public void abortConnection()
    {
      close();
    }

    @Override
    public IllegalStateException getAllocationStackTrace()
    {
      return null;
    }

    @Override
    public Object getUserConnection()
    {
      return EntityManagerJtaProxy.this;
    }

    @Override
    public ManagedXAResource getXAResource()
    {
      return null;
    }

    @Override
    public boolean isCloseDanglingConnections()
    {
      return false;
    }

    @Override
    public void setSaveAllocationStackTrace(boolean isEnable)
    {

    }
  }
}
