package org.apache.ojb.odmg;

 /* Copyright 2002-2005 The Apache Software Foundation

  *

  * Licensed under the Apache License, Version 2.0 (the "License");

  * you may not use this file except in compliance with the License.

  * You may obtain a copy of the License at

  *

  *     http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 /**

  *

  * @author <a href="mailto:thma@apache.org">Thomas Mahler</a>

  * @author <a href="mailto:mattbaird@yahoo.com">Matthew Baird</a>

  *

  */

 import java.util.HashMap;

 import java.util.Iterator;

 import java.util.Map;

 import java.util.List;

 import java.util.ArrayList;

 import org.apache.commons.lang.builder.ToStringBuilder;

 import org.apache.ojb.broker.Identity;

 import org.apache.ojb.broker.PersistenceBroker;

 import org.apache.ojb.broker.PersistenceBrokerException;

 import org.apache.ojb.broker.OJBRuntimeException;

 import org.apache.ojb.broker.PersistenceBrokerInternal;

 import org.apache.ojb.broker.core.proxy.IndirectionHandler;

 import org.apache.ojb.broker.core.proxy.ProxyHelper;

 import org.apache.ojb.broker.metadata.ClassDescriptor;

 import org.apache.ojb.broker.metadata.CollectionDescriptor;

 import org.apache.ojb.broker.metadata.FieldDescriptor;

 import org.apache.ojb.broker.metadata.ObjectReferenceDescriptor;

 import org.apache.ojb.broker.util.BrokerHelper;

 import org.apache.ojb.broker.util.ObjectModification;

 import org.apache.ojb.broker.util.logging.Logger;

 import org.apache.ojb.broker.util.logging.LoggerFactory;

 import org.apache.ojb.odmg.states.ModificationState;

 import org.apache.ojb.odmg.states.StateNewDirty;

 import org.apache.ojb.odmg.states.StateOldClean;

 import org.apache.ojb.odmg.states.StateOldDirty;

 import org.apache.ojb.odmg.link.LinkEntry;

 import org.apache.ojb.odmg.link.LinkEntryOneToOne;

 import org.apache.ojb.odmg.link.LinkEntryOneToN;

 /**

  * ObjectEnvelope is used during ODMG transactions as a wrapper for a

  * persistent objects declaration

  *

  */

 public class ObjectEnvelope implements ObjectModification, Image.ImageListener

 {

     private Logger log = LoggerFactory.getLogger(ObjectEnvelope.class);

     static final long serialVersionUID = -829177767933340522L;

     static final int IS_MATERIALIZED_OBJECT = 11;

     static final int IS_MATERIALIZED_PROXY = 13;

     static final int IS_UNMATERIALIZED_PROXY = 17;

     /**

      * The objects modification state, e.g. Old and Clean

      */

     private ModificationState modificationState = null;

     private Identity oid;

     private Boolean hasChanged;

     private boolean writeLocked;

     /**

      * myObj holds the object we are wrapping.

      */

     private Object myObj;

     /**

      * beforeImage holds a mapping between field

      * names and values at the start of the transaction.

      * currentImage holds the mapping at the

      * end of the transaction.

      */

     private Map beforeImage;

     private Map currentImage;

     private ObjectEnvelopeTable buffer;

     // list of all LinkEntry's

     private List linkEntryList;

     /**

      * Create a wrapper by providing an Object.

      */

     public ObjectEnvelope(ObjectEnvelopeTable buffer, Identity oid, Object obj, boolean isNewObject)

     {

         this.linkEntryList = new ArrayList();

         this.buffer = buffer;

         this.oid = oid;

         // TODO: do we really need to materialize??

         myObj = ProxyHelper.getRealObject(obj);

         prepareInitialState(isNewObject);

         /*

         TODO: is it possible to improve this? Take care that "new"

         objects should support "persistence by reachability" too

         (detection of new/persistent reference objects after maon object lock)

         */

         beforeImage = buildObjectImage(getBroker());

     }

     public PersistenceBrokerInternal getBroker()

     {

         return buffer.getTransaction().getBrokerInternal();

     }

     TransactionImpl getTx()

     {

         return buffer.getTransaction();

     }

     ObjectEnvelopeTable getEnvelopeTable()

     {

         return buffer;

     }

     public Map getBeforeImage()

     {

         if(beforeImage == null)

         {

             beforeImage = buildObjectImage(getBroker());

         }

         return beforeImage;

     }

     public Map getCurrentImage()

     {

         if(currentImage == null)

         {

             currentImage = buildObjectImage(getBroker());

         }

         return currentImage;

     }

     /**

      * This method should be called before transaction ends

      * to allow cleanup of used resources, e.g. remove proxy listener objects

      * to avoid invoke of registered objects after tx end.

      */

     public void cleanup(boolean reuse, boolean wasInsert)

     {

         if(currentImage != null)

         {

             performImageCleanup(currentImage, reuse);

         }

         if(beforeImage != null)

         {

             // we always free all resources of the old image

             performImageCleanup(beforeImage, false);

         }

         if(reuse)

         {

             refreshObjectImage(wasInsert);

         }

         else

         {

             myObj = null;

         }

     }

     private void performImageCleanup(Map imageMap, boolean reuse)

     {

         Iterator iterator = imageMap.values().iterator();

         while(iterator.hasNext())

         {

             Image base =  (Image) iterator.next();

             if(base != null) base.cleanup(reuse);

         }

     }

     private void refreshObjectImage(boolean wasInsert)

     {

         try

         {

             // if an image already exists we

             // replace the Identity too, maybe a temporary

             // used PK value was replaced by the real one,

             // see in docs SequenceManagerNativeImpl

             if(getIdentity().isTransient())

             {

                 refreshIdentity();

             }

             if(currentImage != null)

             {

                 beforeImage = currentImage;

             }

             else

             {

                 if(beforeImage == null)

                 {

                     beforeImage = buildObjectImage(getBroker());

                 }

             }

             currentImage = null;

             hasChanged = null;

             if(wasInsert)

             {

                 /*

                 on insert we have to replace the PK fields and the version fields, because

                 they populated after the object was written to DB, thus replace all field image values

                 */

                 refreshPKFields();

             }

             // TODO: How to handle version fields incremented by the DB?

             // always refresh the version fields, because these fields will change when written to DB

             refreshLockingFields();

         }

         catch(PersistenceBrokerException e)

         {

             beforeImage = null;

             currentImage = null;

             hasChanged = null;

             log.error("Can't refresh object image for " + getIdentity(), e);

             throw e;

         }

     }

     private void refreshPKFields()

     {

         FieldDescriptor[] flds = getClassDescriptor().getPkFields();

         for(int i = 0; i < flds.length; i++)

         {

             FieldDescriptor fld = flds[i];

             addFieldImage(beforeImage, fld);

         }

     }

     private void refreshLockingFields()

     {

         if(getClassDescriptor().isLocking())

         {

             FieldDescriptor[] flds = getClassDescriptor().getLockingFields();

             for(int i = 0; i < flds.length; i++)

             {

                 FieldDescriptor fld = flds[i];

                 addFieldImage(beforeImage, fld);

             }

         }

     }

     /**

      * Replace the current with a new generated identity object and

      * returns the old one.

      */

     public Identity refreshIdentity()

     {

         Identity oldOid = getIdentity();

         this.oid = getBroker().serviceIdentity().buildIdentity(myObj);

         return oldOid;

     }

     public Identity getIdentity()

     {

         if(oid == null)

         {

             oid = getBroker().serviceIdentity().buildIdentity(getObject());

         }

         return oid;

     }

     /**

      * Returns the managed materialized object.

      */

     public Object getObject()

     {

         return myObj;

     }

     public Object getRealObject()

     {

         return ProxyHelper.getRealObject(getObject());

     }

     public void refreshObjectIfNeeded(Object obj)

     {

         if(this.myObj != obj)

         {

             this.myObj = obj;

         }

     }

     /**

      * We need to implement the Two-Phase Commit

      * protocol.

      *

      * beginCommit is where we say if we can or cannot

      * commit the transaction.  At the begining however,

      * we need to attain the after image so we can isolate

      * everything.

      *

      * We should issue the call against the database

      * at this point.  If we get a SQL Exception, we

      * should throw the org.odmg.TransactionAbortedException.

      *

      * We should also check to see if the object is

      * TransactionAware.  If so, we should give it a chance

      * to kill the transaction before we toss it to the

      * database.

      */

     public void beforeCommit()

     {

         if(myObj instanceof TransactionAware)

         {

             TransactionAware ta = (TransactionAware) myObj;

             ta.beforeCommit();

         }

     }

     /**

      * Method declaration

      */

     public void afterCommit()

     {

         if(myObj instanceof TransactionAware)

         {

             TransactionAware ta = (TransactionAware) myObj;

             ta.afterCommit();

         }

     }

     /**

      * Method declaration

      */

     public void beforeAbort()

     {

         if(myObj instanceof TransactionAware)

         {

             TransactionAware ta = (TransactionAware) myObj;

             ta.beforeAbort();

         }

     }

     /**

      * Method declaration

      */

     public void afterAbort()

     {

         if(myObj instanceof TransactionAware)

         {

             TransactionAware ta = (TransactionAware) myObj;

             ta.afterAbort();

         }

     }

     /**

      * buildObjectImage() will return the image of the Object.

      */

     private Map buildObjectImage(PersistenceBroker broker) throws PersistenceBrokerException

     {

         Map imageMap = new HashMap();

         ClassDescriptor cld = broker.getClassDescriptor(getObject().getClass());

         //System.out.println("++++ build image: " + getObject());

         // register 1:1 references in image

         buildImageForSingleReferences(imageMap, cld);

         // put object values to image map

         buildImageForFields(imageMap, cld);

         // register 1:n and m:n references in image

         buildImageForCollectionReferences(imageMap, cld);

         return imageMap;

     }

     private void buildImageForSingleReferences(Map imageMap, ClassDescriptor cld)

     {

         // register all 1:1 references

         Iterator iter = cld.getObjectReferenceDescriptors(true).iterator();

         ObjectReferenceDescriptor rds;

         while(iter.hasNext())

         {

             rds = (ObjectReferenceDescriptor) iter.next();

             /*

             arminw:

             if a "super-reference" is matched (a 1:1 reference used to represent a super class)

             we don't handle it, because this will be done by the PB-api and will never be change

             */

             if(!rds.isSuperReferenceDescriptor())

             {

                 Object referenceObject = rds.getPersistentField().get(myObj);

                 IndirectionHandler handler = ProxyHelper.getIndirectionHandler(referenceObject);

                 /*

                 arminw:

                 if object was serialized and anonymous FK are used in the main object, the FK

                 values are null, we have to refresh (re-assign) these values before building field images.

                 This will not touch the main object itself, because we only reassign anonymous FK fields.

                 */

                 if(handler == null && referenceObject != null

                         && BrokerHelper.hasAnonymousKeyReference(rds.getClassDescriptor(), rds))

                 {

                     getBroker().serviceBrokerHelper().link(myObj, rds, false);

                 }

                 Image.SingleRef singleRef = new Image.SingleRef(this, rds, referenceObject);

                 imageMap.put(rds, singleRef);

             }

         }

     }

     private void buildImageForFields(Map imageMap, ClassDescriptor cld)

     {

         // register all non reference fields of object (with inherited fields)

         FieldDescriptor[] fieldDescs = cld.getFieldDescriptor(true);

         for(int i = 0; i < fieldDescs.length; i++)

         {

             addFieldImage(imageMap, fieldDescs[i]);

         }

     }

     private void addFieldImage(Map imageMap, FieldDescriptor fld)

     {

         // register copies of all field values

         Object value = fld.getPersistentField().get(myObj);

         // get the real sql type value

         value = fld.getFieldConversion().javaToSql(value);

         // make copy of the sql type value

         value = fld.getJdbcType().getFieldType().copy(value);

         // buffer in image the field name and the sql type value

         // wrapped by a helper class

         imageMap.put(fld.getPersistentField().getName(), new Image.Field(fld.getJdbcType().getFieldType(), value));

     }

     private void buildImageForCollectionReferences(Map imageMap, ClassDescriptor cld)

     {

         // register the 1:n and m:n references

         Iterator collections = cld.getCollectionDescriptors(true).iterator();

         CollectionDescriptor cds;

         while(collections.hasNext())

         {

             cds = (CollectionDescriptor) collections.next();

             Object collectionOrArray = cds.getPersistentField().get(myObj);

             Image.MultipleRef colRef = new Image.MultipleRef(this, cds, collectionOrArray);

             imageMap.put(cds, colRef);

         }

     }

     /**

      * Returns the Modification-state.

      * @return org.apache.ojb.server.states.ModificationState

      */

     public ModificationState getModificationState()

     {

         return modificationState;

     }

     /**

      * Returns true if the underlying Object needs an INSERT statement, else returns false.

      */

     public boolean needsInsert()

     {

         return this.getModificationState().needsInsert();

     }

     /**

      * Returns true if the underlying Object needs an UPDATE statement, else returns false.

      */

     public boolean needsUpdate()

     {

         return this.getModificationState().needsUpdate();

     }

     /**

      * Returns true if the underlying Object needs an UPDATE statement, else returns false.

      */

     public boolean needsDelete()

     {

         return this.getModificationState().needsDelete();

     }

     /**

      * Sets the initial MoificationState of the wrapped object myObj. The initial state will be StateNewDirty if myObj

      * is not persisten already. The state will be set to StateOldClean if the object is already persistent.

      */

     private void prepareInitialState(boolean isNewObject)

     {

         // determine appropriate modification state

         ModificationState initialState;

         if(isNewObject)

         {

             // if object is not already persistent it must be marked as new

             // it must be marked as dirty because it must be stored even if it will not modified during tx

             initialState = StateNewDirty.getInstance();

         }

         else if(isDeleted(oid))

         {

             // if object is already persistent it will be marked as old.

             // it is marked as dirty as it has been deleted during tx and now it is inserted again,

             // possibly with new field values.

             initialState = StateOldDirty.getInstance();

         }

         else

         {

             // if object is already persistent it will be marked as old.

             // it is marked as clean as it has not been modified during tx already

             initialState = StateOldClean.getInstance();

         }

         // remember it:

         modificationState = initialState;

     }

     /**

      * Checks if the object with the given identity has been deleted

      * within the transaction.

      * @param id The identity

      * @return true if the object has been deleted

      * @throws PersistenceBrokerException

      */

     public boolean isDeleted(Identity id)

     {

         ObjectEnvelope envelope = buffer.getByIdentity(id);

         return (envelope != null && envelope.needsDelete());

     }

     /**

      * set the Modification state to a new value. Used during state transitions.

      * @param newModificationState org.apache.ojb.server.states.ModificationState

      */

     public void setModificationState(ModificationState newModificationState)

     {

         if(newModificationState != modificationState)

         {

             if(log.isDebugEnabled())

             {

                 log.debug("object state transition for object " + this.oid + " ("

                         + modificationState + " --> " + newModificationState + ")");

 //                try{throw new Exception();}catch(Exception e)

 //                {

 //                e.printStackTrace();

 //                }

             }

             modificationState = newModificationState;

         }

     }

     /**

      * returns a String representation.

      * @return java.lang.String

      */

     public String toString()

     {

         ToStringBuilder buf = new ToStringBuilder(this);

         buf.append("Identity", oid)

             .append("ModificationState", modificationState.toString());

         return buf.toString();

     }

     /**

      * For internal use only! Only call immediately before commit to guarantee

      * that all changes can be detected (because this method cache the detected "change state"

      * thus on eager call changes could be ignored). Checks whether object and internal clone

      * differ and returns <em>true</em> if so, returns <em>false</em> else.

      *

      * @return boolean The result.

      */

     public boolean hasChanged(PersistenceBroker broker)

     {

         if(hasChanged == null)

         {

             Map current = null;

             try

             {

                 current = getCurrentImage();

             }

             catch(Exception e)

             {

                 log.warn("Could not verify object changes, mark dirty: " + getIdentity(), e);

             }

             if(beforeImage != null && current != null)

             {

                 Iterator it = beforeImage.entrySet().iterator();

                 hasChanged = Boolean.FALSE;

                 while(it.hasNext())

                 {

                     Map.Entry entry =  (Map.Entry) it.next();

                     Image imageBefore = (Image) entry.getValue();

                     Image imageCurrent = (Image) current.get(entry.getKey());

                     if(imageBefore.modified(imageCurrent))

                     {

                         hasChanged = Boolean.TRUE;

                         break;

                     }

                 }

             }

             else

             {

                 hasChanged = Boolean.TRUE;

             }

             if(log.isDebugEnabled())

             {

                 log.debug("State detection for " + getIdentity() + " --> object "

                         + (hasChanged.booleanValue() ? "has changed" : "unchanged"));

             }

         }

         return hasChanged.booleanValue();

     }

     /**

      * Mark new or deleted reference elements

      * @param broker

      */

     void markReferenceElements(PersistenceBroker broker)

     {

         // these cases will be handled by ObjectEnvelopeTable#cascadingDependents()

         // if(getModificationState().needsInsert() || getModificationState().needsDelete()) return;

         Map oldImage = getBeforeImage();

         Map newImage = getCurrentImage();

         Iterator iter = newImage.entrySet().iterator();

         while (iter.hasNext())

         {

             Map.Entry entry = (Map.Entry) iter.next();

             Object key = entry.getKey();

             // we only interested in references

             if(key instanceof ObjectReferenceDescriptor)

             {

                 Image oldRefImage = (Image) oldImage.get(key);

                 Image newRefImage = (Image) entry.getValue();

                 newRefImage.performReferenceDetection(oldRefImage);

             }

         }

     }

     public void doUpdate()

     {

         if(log.isDebugEnabled()) log.debug("Start UPDATE action for " + getIdentity());

         performLinkEntries();

         getBroker().store(getObject(), getIdentity(), getClassDescriptor(), false, true);

     }

     public void doInsert()

     {

         if(log.isDebugEnabled()) log.debug("Start INSERT action for " + getIdentity());

         performLinkEntries();

         getBroker().store(getObject(), getIdentity(), getClassDescriptor(), true, true);

         Identity oldOid = refreshIdentity();

         buffer.replaceRegisteredIdentity(getIdentity(), oldOid);

     }

     public void doDelete()

     {

         if(log.isDebugEnabled()) log.debug("Start DELETE action for " + getIdentity());

         getBroker().delete(getObject(), true);

     }

     public void doEvictFromCache()

     {

         if(log.isDebugEnabled()) log.debug("Remove from cache " + getIdentity());

         getBroker().removeFromCache(getIdentity());

     }

     public boolean isWriteLocked()

     {

         return writeLocked;

     }

     public void setWriteLocked(boolean writeLocked)

     {

         this.writeLocked = writeLocked;

     }

     ClassDescriptor getClassDescriptor()

     {

         return getBroker().getClassDescriptor(ProxyHelper.getRealClass(getObject()));

     }

     void addLinkOneToOne(ObjectReferenceDescriptor ord, boolean unlink)

     {

         LinkEntry entry = new LinkEntryOneToOne(ord, getObject(), unlink);

         linkEntryList.add(entry);

     }

     void addLinkOneToN(CollectionDescriptor col, Object source, boolean unlink)

     {

         if(col.isMtoNRelation()) throw new OJBRuntimeException("Expected an 1:n relation, but specified a m:n");

         LinkEntry entry = new LinkEntryOneToN(source, col, getObject(), unlink);

         linkEntryList.add(entry);

     }

     private void performLinkEntries()

     {

         PersistenceBroker broker = getBroker();

         for(int i = 0; i < linkEntryList.size(); i++)

         {

             LinkEntry linkEntry = (LinkEntry) linkEntryList.get(i);

             linkEntry.execute(broker);

         }

     }

     public void addedOneToOne(ObjectReferenceDescriptor ord, Object refObjOrProxy, Identity oid)

     {

         // the main objects needs link/unlink of the FK to 1:1 reference,

         // so mark this dirty

         setModificationState(getModificationState().markDirty());

         // if the object is already registered, OJB knows about

         // else lock and register object, get read lock, because we

         // don't know if the object is new or moved from an existing other object

         ObjectEnvelope oe = buffer.getByIdentity(oid);

         if(oe == null)

         {

             RuntimeObject rt = new RuntimeObject(refObjOrProxy, getTx());

             // we don't use cascade locking, because new reference object

             // will be detected by ObjectEnvelopeTable#cascadeMarkedForInsert()

             getTx().lockAndRegister(rt, TransactionExt.READ, false, getTx().getRegistrationList());

         }

         // in any case we need to link the main object

         addLinkOneToOne(ord, false);

     }

     public void deletedOneToOne(ObjectReferenceDescriptor ord, Object refObjOrProxy, Identity oid, boolean needsUnlink)

     {

         // the main objects needs link/unlink of the FK to 1:1 reference,

         // so mark this dirty

         setModificationState(getModificationState().markDirty());

         ObjectEnvelope oldRefMod = buffer.getByIdentity(oid);

         // only delete when the reference wasn't assigned with another object

         if(!buffer.isNewAssociatedObject(oid))

         {

             // if cascading delete is enabled, remove the 1:1 reference

             // because it was removed from the main object

             if(buffer.getTransaction().cascadeDeleteFor(ord))

             {

                 oldRefMod.setModificationState(oldRefMod.getModificationState().markDelete());

             }

             // unlink the main object

             if(needsUnlink) addLinkOneToOne(ord, true);

         }

     }

     public void addedXToN(CollectionDescriptor cod, Object refObjOrProxy, Identity oid)

     {

         ObjectEnvelope mod = buffer.getByIdentity(oid);

         // if the object isn't registered already, it can be 'new' or already 'persistent'

         if(mod == null)

         {

             boolean isNew = getTx().isTransient(null, refObjOrProxy, oid);

             mod = buffer.get(oid, refObjOrProxy, isNew);

         }

         // if the object was deleted in an previous action, mark as new

         // to avoid deletion, else mark object as dirty to assign the FK of

         // the main object

         if(mod.needsDelete())

         {

             mod.setModificationState(mod.getModificationState().markNew());

         }

         else

         {

             /*

             arminw: if the reference is a m:n relation and the object state is

             old clean, no need to update the reference.

             */

             if(!(cod.isMtoNRelation() && mod.getModificationState().equals(StateOldClean.getInstance())))

             {

                 mod.setModificationState(mod.getModificationState().markDirty());

             }

         }

         // buffer this object as "new" in a list to prevent deletion

         // when object was moved from one collection to another

         buffer.addNewAssociatedIdentity(oid);

         // new referenced object found, so register all m:n relation for "linking"

         if(cod.isMtoNRelation())

         {

             buffer.addM2NLinkEntry(cod, getObject(), refObjOrProxy);

         }

         else

         {

             // we have to link the new object

             mod.addLinkOneToN(cod, getObject(), false);

         }

         if(mod.needsInsert())

         {

             buffer.addForInsertDependent(mod);

         }

     }

     public void deletedXToN(CollectionDescriptor cod, Object refObjOrProxy, Identity oid)

     {

         ObjectEnvelope mod = buffer.getByIdentity(oid);

         // if this object is associated with another object it's

         // not allowed to remove it, thus nothing will change

         if(!buffer.isNewAssociatedObject(oid))

         {

             if(mod != null)

             {

                 boolean cascade = buffer.getTransaction().cascadeDeleteFor(cod);

                 if(cascade)

                 {

                     mod.setModificationState(mod.getModificationState().markDelete());

                     buffer.addForDeletionDependent(mod);

                 }

                 if(cod.isMtoNRelation())

                 {

                     buffer.addM2NUnlinkEntry(cod, getObject(), refObjOrProxy);

                 }

                 else

                 {

                     // when cascade 'true' we remove all dependent objects, so no need

                     // to unlink, else we have to unlink all referenced objects of this

                     // object

                     if(!cascade)

                     {

                         mod.setModificationState(mod.getModificationState().markDirty());

                         mod.addLinkOneToN(cod, getObject(), true);

                     }

                 }

             }

             else

             {

                 throw new Image.ImageException("Unexpected behaviour, unregistered object to delete: "

                         + oid + ", main object is " + getIdentity()+ ", envelope object is " + this.toString());

             }

         }

     }

 }