<?php

/*

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 * This software consists of voluntary contributions made by many individuals

 * and is licensed under the LGPL. For more information, see

 * <http://www.doctrine-project.org>.

 */

namespace Doctrine\ORM;

use Exception, InvalidArgumentException, UnexpectedValueException,

    Doctrine\Common\Collections\ArrayCollection,

    Doctrine\Common\Collections\Collection,

    Doctrine\Common\NotifyPropertyChanged,

    Doctrine\Common\PropertyChangedListener,

    Doctrine\ORM\Event\LifecycleEventArgs,

    Doctrine\ORM\Mapping\ClassMetadata,

    Doctrine\ORM\Proxy\Proxy;

/**

 * The UnitOfWork is responsible for tracking changes to objects during an

 * "object-level" transaction and for writing out changes to the database

 * in the correct order.

 *

 * @since       2.0

 * @author      Benjamin Eberlei <kontakt@beberlei.de>

 * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>

 * @author      Jonathan Wage <jonwage@gmail.com>

 * @author      Roman Borschel <roman@code-factory.org>

 * @internal    This class contains highly performance-sensitive code.

 */

class UnitOfWork implements PropertyChangedListener

{

    /**

     * An entity is in MANAGED state when its persistence is managed by an EntityManager.

     */

    const STATE_MANAGED = 1;

    /**

     * An entity is new if it has just been instantiated (i.e. using the "new" operator)

     * and is not (yet) managed by an EntityManager.

     */

    const STATE_NEW = 2;

    /**

     * A detached entity is an instance with persistent state and identity that is not

     * (or no longer) associated with an EntityManager (and a UnitOfWork).

     */

    const STATE_DETACHED = 3;

    /**

     * A removed entity instance is an instance with a persistent identity,

     * associated with an EntityManager, whose persistent state will be deleted

     * on commit.

     */

    const STATE_REMOVED = 4;

    /**

     * The identity map that holds references to all managed entities that have

     * an identity. The entities are grouped by their class name.

     * Since all classes in a hierarchy must share the same identifier set,

     * we always take the root class name of the hierarchy.

     *

     * @var array

     */

    private $identityMap = array();

    /**

     * Map of all identifiers of managed entities.

     * Keys are object ids (spl_object_hash).

     *

     * @var array

     */

    private $entityIdentifiers = array();

    /**

     * Map of the original entity data of managed entities.

     * Keys are object ids (spl_object_hash). This is used for calculating changesets

     * at commit time.

     *

     * @var array

     * @internal Note that PHPs "copy-on-write" behavior helps a lot with memory usage.

     *           A value will only really be copied if the value in the entity is modified

     *           by the user.

     */

    private $originalEntityData = array();

    /**

     * Map of entity changes. Keys are object ids (spl_object_hash).

     * Filled at the beginning of a commit of the UnitOfWork and cleaned at the end.

     *

     * @var array

     */

    private $entityChangeSets = array();

    /**

     * The (cached) states of any known entities.

     * Keys are object ids (spl_object_hash).

     *

     * @var array

     */

    private $entityStates = array();

    /**

     * Map of entities that are scheduled for dirty checking at commit time.

     * This is only used for entities with a change tracking policy of DEFERRED_EXPLICIT.

     * Keys are object ids (spl_object_hash).

     * 

     * @var array

     * @todo rename: scheduledForSynchronization

     */

    private $scheduledForDirtyCheck = array();

    /**

     * A list of all pending entity insertions.

     *

     * @var array

     */

    private $entityInsertions = array();

    /**

     * A list of all pending entity updates.

     *

     * @var array

     */

    private $entityUpdates = array();

    /**

     * Any pending extra updates that have been scheduled by persisters.

     * 

     * @var array

     */

    private $extraUpdates = array();

    /**

     * A list of all pending entity deletions.

     *

     * @var array

     */

    private $entityDeletions = array();

    /**

     * All pending collection deletions.

     *

     * @var array

     */

    private $collectionDeletions = array();

    /**

     * All pending collection updates.

     *

     * @var array

     */

    private $collectionUpdates = array();

    /**

     * List of collections visited during changeset calculation on a commit-phase of a UnitOfWork.

     * At the end of the UnitOfWork all these collections will make new snapshots

     * of their data.

     *

     * @var array

     */

    private $visitedCollections = array();

    /**

     * The EntityManager that "owns" this UnitOfWork instance.

     *

     * @var Doctrine\ORM\EntityManager

     */

    private $em;

    /**

     * The calculator used to calculate the order in which changes to

     * entities need to be written to the database.

     *

     * @var Doctrine\ORM\Internal\CommitOrderCalculator

     */

    private $commitOrderCalculator;

    /**

     * The entity persister instances used to persist entity instances.

     *

     * @var array

     */

    private $persisters = array();

    /**

     * The collection persister instances used to persist collections.

     *

     * @var array

     */

    private $collectionPersisters = array();

    /**

     * The EventManager used for dispatching events.

     * 

     * @var EventManager

     */

    private $evm;

    /**

     * Orphaned entities that are scheduled for removal.

     * 

     * @var array

     */

    private $orphanRemovals = array();

    //private $_readOnlyObjects = array();

    /**

     * Map of Entity Class-Names and corresponding IDs that should eager loaded when requested.

     * 

     * @var array

     */

    private $eagerLoadingEntities = array();

    /**

     * Initializes a new UnitOfWork instance, bound to the given EntityManager.

     *

     * @param Doctrine\ORM\EntityManager $em

     */

    public function __construct(EntityManager $em)

    {

        $this->em = $em;

        $this->evm = $em->getEventManager();

    }

    /**

     * Commits the UnitOfWork, executing all operations that have been postponed

     * up to this point. The state of all managed entities will be synchronized with

     * the database.

     * 

     * The operations are executed in the following order:

     * 

     * 1) All entity insertions

     * 2) All entity updates

     * 3) All collection deletions

     * 4) All collection updates

     * 5) All entity deletions

     * 

     */

    public function commit()

    {

        // Compute changes done since last commit.

        $this->computeChangeSets();

        if ( ! ($this->entityInsertions ||

                $this->entityDeletions ||

                $this->entityUpdates ||

                $this->collectionUpdates ||

                $this->collectionDeletions ||

                $this->orphanRemovals)) {

            return; // Nothing to do.

        }

        if ($this->orphanRemovals) {

            foreach ($this->orphanRemovals as $orphan) {

                $this->remove($orphan);

            }

        }

        // Raise onFlush

        if ($this->evm->hasListeners(Events::onFlush)) {

            $this->evm->dispatchEvent(Events::onFlush, new Event\OnFlushEventArgs($this->em));

        }

        // Now we need a commit order to maintain referential integrity

        $commitOrder = $this->getCommitOrder();

        $conn = $this->em->getConnection();

        $conn->beginTransaction();

        try {

            if ($this->entityInsertions) {

                foreach ($commitOrder as $class) {

                    $this->executeInserts($class);

                }

            }

            if ($this->entityUpdates) {

                foreach ($commitOrder as $class) {

                    $this->executeUpdates($class);

                }

            }

            // Extra updates that were requested by persisters.

            if ($this->extraUpdates) {

                $this->executeExtraUpdates();

            }

            // Collection deletions (deletions of complete collections)

            foreach ($this->collectionDeletions as $collectionToDelete) {

                $this->getCollectionPersister($collectionToDelete->getMapping())

                        ->delete($collectionToDelete);

            }

            // Collection updates (deleteRows, updateRows, insertRows)

            foreach ($this->collectionUpdates as $collectionToUpdate) {

                $this->getCollectionPersister($collectionToUpdate->getMapping())

                        ->update($collectionToUpdate);

            }

            // Entity deletions come last and need to be in reverse commit order

            if ($this->entityDeletions) {

                for ($count = count($commitOrder), $i = $count - 1; $i >= 0; --$i) {

                    $this->executeDeletions($commitOrder[$i]);

                }

            }

            $conn->commit();

        } catch (Exception $e) {

            $this->em->close();

            $conn->rollback();

            throw $e;

        }

        // Take new snapshots from visited collections

        foreach ($this->visitedCollections as $coll) {

            $coll->takeSnapshot();

        }

        // Clear up

        $this->entityInsertions =

        $this->entityUpdates =

        $this->entityDeletions =

        $this->extraUpdates =

        $this->entityChangeSets =

        $this->collectionUpdates =

        $this->collectionDeletions =

        $this->visitedCollections =

        $this->scheduledForDirtyCheck =

        $this->orphanRemovals = array();

    }

    /**

     * Executes any extra updates that have been scheduled.

     */

    private function executeExtraUpdates()

    {

        foreach ($this->extraUpdates as $oid => $update) {

            list ($entity, $changeset) = $update;

            $this->entityChangeSets[$oid] = $changeset;

            $this->getEntityPersister(get_class($entity))->update($entity);

        }

    }

    /**

     * Gets the changeset for an entity.

     *

     * @return array

     */

    public function getEntityChangeSet($entity)

    {

        $oid = spl_object_hash($entity);

        if (isset($this->entityChangeSets[$oid])) {

            return $this->entityChangeSets[$oid];

        }

        return array();

    }

    /**

     * Computes the changes that happened to a single entity.

     *

     * Modifies/populates the following properties:

     *

     * {@link _originalEntityData}

     * If the entity is NEW or MANAGED but not yet fully persisted (only has an id)

     * then it was not fetched from the database and therefore we have no original

     * entity data yet. All of the current entity data is stored as the original entity data.

     *

     * {@link _entityChangeSets}

     * The changes detected on all properties of the entity are stored there.

     * A change is a tuple array where the first entry is the old value and the second

     * entry is the new value of the property. Changesets are used by persisters

     * to INSERT/UPDATE the persistent entity state.

     *

     * {@link _entityUpdates}

     * If the entity is already fully MANAGED (has been fetched from the database before)

     * and any changes to its properties are detected, then a reference to the entity is stored

     * there to mark it for an update.

     *

     * {@link _collectionDeletions}

     * If a PersistentCollection has been de-referenced in a fully MANAGED entity,

     * then this collection is marked for deletion.

     *

     * @param ClassMetadata $class The class descriptor of the entity.

     * @param object $entity The entity for which to compute the changes.

     */

    public function computeChangeSet(ClassMetadata $class, $entity)

    {

        if ( ! $class->isInheritanceTypeNone()) {

            $class = $this->em->getClassMetadata(get_class($entity));

        }

        $oid = spl_object_hash($entity);

        $actualData = array();

        foreach ($class->reflFields as $name => $refProp) {

            $value = $refProp->getValue($entity);

            if (isset($class->associationMappings[$name])

                    && ($class->associationMappings[$name]['type'] & ClassMetadata::TO_MANY)

                    && $value !== null

                    && ! ($value instanceof PersistentCollection)) {

                // If $value is not a Collection then use an ArrayCollection.

                if ( ! $value instanceof Collection) {

                    $value = new ArrayCollection($value);

                }

                $assoc = $class->associationMappings[$name];

                // Inject PersistentCollection

                $coll = new PersistentCollection(

                    $this->em,

                    $this->em->getClassMetadata($assoc['targetEntity']),

                    $value

                );

                $coll->setOwner($entity, $assoc);

                $coll->setDirty( ! $coll->isEmpty());

                $class->reflFields[$name]->setValue($entity, $coll);

                $actualData[$name] = $coll;

            } else if ( (! $class->isIdentifier($name) || ! $class->isIdGeneratorIdentity()) && ($name !== $class->versionField) ) {

                $actualData[$name] = $value;

            }

        }

        if ( ! isset($this->originalEntityData[$oid])) {

            // Entity is either NEW or MANAGED but not yet fully persisted (only has an id).

            // These result in an INSERT.

            $this->originalEntityData[$oid] = $actualData;

            $changeSet = array();

            foreach ($actualData as $propName => $actualValue) {

                if (isset($class->associationMappings[$propName])) {

                    $assoc = $class->associationMappings[$propName];

                    if ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE) {

                        $changeSet[$propName] = array(null, $actualValue);

                    }

                } else {

                    $changeSet[$propName] = array(null, $actualValue);

                }

            }

            $this->entityChangeSets[$oid] = $changeSet;