package org.starobjects.jpa.runtime.persistence.maps;
   
   import org.hibernate.proxy.HibernateProxy;
   import org.hibernate.proxy.LazyInitializer;
   import org.nakedobjects.metamodel.adapter.NakedObject;
   import org.nakedobjects.metamodel.adapter.oid.Oid;
   import org.nakedobjects.metamodel.spec.NakedObjectSpecification;
   import org.nakedobjects.metamodel.spec.feature.OneToOneAssociation;
   import org.nakedobjects.runtime.persistence.adaptermanager.AdapterManagerDefault;
  import org.nakedobjects.runtime.persistence.adaptermanager.AggregateAdapters;
  import org.starobjects.jpa.metamodel.facets.object.entity.JpaEntityFacet;
  import org.starobjects.jpa.metamodel.util.JpaPropertyUtils;
  import org.starobjects.jpa.runtime.persistence.objectstore.hibspi.ResolveStateUtil;
  import org.starobjects.jpa.runtime.persistence.oid.JpaOid;
  import org.starobjects.jpa.runtime.persistence.oid.JpaOidGenerator;
  import org.starobjects.jpa.runtime.util.JpaOidPropertyUtils;
  
  public class JpaAdapterManager extends AdapterManagerDefault {
  
      /**
       * see {@link #createOrRecreateRootAdapter(Object)}.
       */
      private long serviceId;
  
      public JpaAdapterManager() {
      // just discovered this commented out. Not sure why.
      // the tests still pass, so leaving as commented out.
      // setPojoAdapterMap(new JpaPojoAdapterMap());
      }
  
      /**
       * Downcast.
       */
      @Override
      public JpaOidGenerator getOidGenerator() {
          return (JpaOidGenerator) super.getOidGenerator();
      }
  
      @Override
      protected AggregateAdapters createOrRecreateRootAdapter(final Object pojo) {
          // will create a transient adapter or a ghost (if persistent) adapter
          final AggregateAdapters aggregateAdapters = super
                  .createOrRecreateRootAdapter(pojo);
  
          final NakedObject rootAdapter = aggregateAdapters.getRootAdapter();
  
          // special handling for services
          if (rootAdapter.getSpecification().isService()) {
              final Long id = ++serviceId;
              syncOidAndConvertToPersistent(rootAdapter, id);
              ResolveStateUtil.markAsResolved(rootAdapter);
              return aggregateAdapters;
          }
  
          // otherwise, regular object.
          updateResolveStateIfPersistent(rootAdapter);
          return aggregateAdapters;
      }
  
      @Override
      protected Oid createOid(final Object pojo) {
          final JpaOid oid = getOidGenerator().createTransientOid(pojo);
  
          // we create a throw-away adapter, just to extract the Id of the pojo
          final NakedObject adapter = getAdapterFactory()
                  .createAdapter(pojo, oid);
          initializeOidIfEntity(adapter);
  
          return oid;
      }
  
      private void initializeOidIfEntity(final NakedObject adapter) {
          final NakedObjectSpecification noSpec = adapter.getSpecification();
  
          if (!noSpec.containsFacet(JpaEntityFacet.class)) {
              return;
          }
  
          // Entities always have an Id
          final OneToOneAssociation idProperty = JpaPropertyUtils
                  .getIdPropertyFor(noSpec);
          final NakedObject idAdapter = idProperty.get(adapter);
  
          // if the Id is set we infer that the pojo is persistent.
          if (idAdapter != null) {
              final Number id = (Number) idAdapter.getObject();
              final JpaOid oid = (JpaOid) adapter.getOid();
              convertToPersistentOid(oid, id);
          }
      }
  
      private void convertToPersistentOid(final JpaOid oid, final Number id) {
          // ensure Oid is setup correctly.
          oid.setNewId(id);
          getOidGenerator().convertTransientToPersistentOid(oid);
      }
  
  
      private void updateResolveStateIfPersistent(final NakedObject adapter) {
         if (adapter.getOid().isTransient()) {
             return;
         }
 
         final Object pojo = adapter.getObject();
         final LazyInitializer hibernateLazyInitializer = getHibernateLazyInitializer(pojo);
 
 
         // this was a previous approach to try to guess whether the object was
         // transient or not. But I think it is flawed; we might have eagerly
         // loaded in the referenced object so there would be no proxy.
         // instead, see #createOid (called earlier on) which aims to setup the
         // correct Oid (transient or persistent) from the outset.
 
         // // see if we have a proxy
         // if (hibernateLazyInitializer == null) {
         // // no, so must be transient
         // return;
         // }
 
         // yes, so presume is persistent
 
         final Long id = JpaOidPropertyUtils.getIdFor(adapter);
         if (id == null) {
             // TODO: can't do much here; should we throw an exception instead?
             return;
         }
 
         // the following isn't needed any more because it is in effect
         // done in #createOid()
 
         // // sync the Oid & make persistent
         // // it shouldn't be in any maps yet, so can do this safely)
         // syncOidAndConvertToPersistent(adapter, id);
 
         // update the resolve state
         if (hibernateLazyInitializer != null &&
                 hibernateLazyInitializer.isUninitialized()) {
             ResolveStateUtil.markAsGhost(adapter);
         } else {
             ResolveStateUtil.markAsResolved(adapter);
         }
 
         return;
     }
 
     private void syncOidAndConvertToPersistent(final NakedObject adapter,
             final Number id) {
         final JpaOid oid = (JpaOid) adapter.getOid();
         convertToPersistentOid(oid, id);
     }
 
     private LazyInitializer getHibernateLazyInitializer(final Object pojo) {
         if (!(pojo instanceof HibernateProxy)) {
             return null;
         }
         final HibernateProxy hibernateProxy = (HibernateProxy) pojo;
         return hibernateProxy.getHibernateLazyInitializer();
     }
 }
 
 
 // Copyright (c) Naked Objects Group Ltd.