<?php

/*

 * This file is part of the Symfony package.

 *

 * (c) Fabien Potencier <fabien@symfony.com>

 *

 * For the full copyright and license information, please view the LICENSE

 * file that was distributed with this source code.

 */

namespace Symfony\Component\DependencyInjection;

use Symfony\Component\DependencyInjection\Compiler\Compiler;

use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;

use Symfony\Component\DependencyInjection\Compiler\PassConfig;

use Symfony\Component\DependencyInjection\Extension\ExtensionInterface;

use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;

use Symfony\Component\Config\Resource\FileResource;

use Symfony\Component\Config\Resource\ResourceInterface;

/**

 * ContainerBuilder is a DI container that provides an API to easily describe services.

 *

 * @author Fabien Potencier <fabien@symfony.com>

 *

 * @api

 */

class ContainerBuilder extends Container implements TaggedContainerInterface

{

    private $extensions       = array();

    private $extensionsByNs   = array();

    private $definitions      = array();

    private $aliases          = array();

    private $resources        = array();

    private $extensionConfigs = array();

    private $injectors        = array();

    private $compiler;

    /**

     * Registers an extension.

     *

     * @param ExtensionInterface $extension An extension instance

     *

     * @api

     */

    public function registerExtension(ExtensionInterface $extension)

    {

        $this->extensions[$extension->getAlias()] = $extension;

        if (false !== $extension->getNamespace()) {

            $this->extensionsByNs[$extension->getNamespace()] = $extension;

        }

    }

    /**

     * Returns an extension by alias or namespace.

     *

     * @param string $name An alias or a namespace

     *

     * @return ExtensionInterface An extension instance

     *

     * @api

     */

    public function getExtension($name)

    {

        if (isset($this->extensions[$name])) {

            return $this->extensions[$name];

        }

        if (isset($this->extensionsByNs[$name])) {

            return $this->extensionsByNs[$name];

        }

        throw new \LogicException(sprintf('Container extension "%s" is not registered', $name));

    }

    /**

     * Returns all registered extensions.

     *

     * @return array An array of ExtensionInterface

     *

     * @api

     */

    public function getExtensions()

    {

        return $this->extensions;

    }

    /**

     * Checks if we have an extension.

     *

     * @param string $name The name of the extension

     * @return Boolean If the extension exists

     *

     * @api

     */

    public function hasExtension($name)

    {

        return isset($this->extensions[$name]) || isset($this->extensionsByNs[$name]);

    }

    /**

     * Returns an array of resources loaded to build this configuration.

     *

     * @return ResourceInterface[] An array of resources

     *

     * @api

     */

    public function getResources()

    {

        return array_unique($this->resources);

    }

    /**

     * Adds a resource for this configuration.

     *

     * @param ResourceInterface $resource A resource instance

     *

     * @return ContainerBuilder The current instance

     *

     * @api

     */

    public function addResource(ResourceInterface $resource)

    {

        $this->resources[] = $resource;

        return $this;

    }

    /**

     * Adds the object class hierarchy as resources.

     *

     * @param object $object An object instance

     *

     * @api

     */

    public function addObjectResource($object)

    {

        $parent = new \ReflectionObject($object);

        do {

            $this->addResource(new FileResource($parent->getFileName()));

        } while ($parent = $parent->getParentClass());

    }

    /**

     * Loads the configuration for an extension.

     *

     * @param string $extension The extension alias or namespace

     * @param array  $values    An array of values that customizes the extension

     *

     * @return ContainerBuilder The current instance

     *

     * @api

     */

    public function loadFromExtension($extension, array $values = array())

    {

        if (true === $this->isFrozen()) {

            throw new \LogicException('Cannot load from an extension on a frozen container.');

        }

        $namespace = $this->getExtension($extension)->getAlias();

        $this->extensionConfigs[$namespace][] = $values;

        return $this;

    }

    /**

     * Adds a compiler pass.

     *

     * @param CompilerPassInterface $pass A compiler pass

     * @param string                $type The type of compiler pass

     *

     * @api

     */

    public function addCompilerPass(CompilerPassInterface $pass, $type = PassConfig::TYPE_BEFORE_OPTIMIZATION)

    {

        if (null === $this->compiler) {

            $this->compiler = new Compiler();

        }

        $this->compiler->addPass($pass, $type);

        $this->addObjectResource($pass);

    }

    /**

     * Returns the compiler pass config which can then be modified.

     *

     * @return PassConfig The compiler pass config

     *

     * @api

     */

    public function getCompilerPassConfig()

    {

        if (null === $this->compiler) {

            $this->compiler = new Compiler();

        }

        return $this->compiler->getPassConfig();

    }

    /**

     * Returns the compiler.

     *

     * @return Compiler The compiler

     *

     * @api

     */

    public function getCompiler()

    {

        if (null === $this->compiler) {

            $this->compiler = new Compiler();

        }

        return $this->compiler;

    }

    /**

     * Returns all Scopes.

     *

     * @return array An array of scopes

     *

     * @api

     */

    public function getScopes()

    {

        return $this->scopes;

    }

    /**

     * Returns all Scope children.

     *

     * @return array An array of scope children.

     *

     * @api

     */

    public function getScopeChildren()

    {

        return $this->scopeChildren;

    }

    /**

     * Sets a service.

     *

     * @param string $id      The service identifier

     * @param object $service The service instance

     * @param string $scope   The scope

     *

     * @throws BadMethodCallException

     *

     * @api

     */

    public function set($id, $service, $scope = self::SCOPE_CONTAINER)

    {

        if ($this->isFrozen()) {

            throw new \BadMethodCallException('Setting service on a frozen container is not allowed');

        }

        $id = strtolower($id);

        unset($this->definitions[$id], $this->aliases[$id]);

        parent::set($id, $service, $scope);

    }

    /**

     * Removes a service definition.

     *

     * @param string $id The service identifier

     *

     * @api

     */

    public function removeDefinition($id)

    {

        unset($this->definitions[strtolower($id)]);

    }

    /**

     * Returns true if the given service is defined.

     *

     * @param  string  $id      The service identifier

     *

     * @return Boolean true if the service is defined, false otherwise

     *

     * @api

     */

    public function has($id)

    {

        $id = strtolower($id);

        return isset($this->definitions[$id]) || isset($this->aliases[$id]) || parent::has($id);

    }

    /**

     * Gets a service.

     *

     * @param  string  $id              The service identifier

     * @param  integer $invalidBehavior The behavior when the service does not exist

     *

     * @return object The associated service

     *

     * @throws \InvalidArgumentException if the service is not defined

     * @throws \LogicException if the service has a circular reference to itself

     *

     * @see Reference

     *

     * @api

     */

    public function get($id, $invalidBehavior = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE)

    {

        $id = strtolower($id);

        try {

            return parent::get($id, ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE);

        } catch (\InvalidArgumentException $e) {

            if (isset($this->loading[$id])) {

                throw new \LogicException(sprintf('The service "%s" has a circular reference to itself.', $id), 0, $e);

            }

            if (!$this->hasDefinition($id) && isset($this->aliases[$id])) {

                return $this->get($this->aliases[$id]);

            }

            try {

                $definition = $this->getDefinition($id);

            } catch (\InvalidArgumentException $e) {

                if (ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE !== $invalidBehavior) {

                    return null;

                }

                throw $e;

            }

            $this->loading[$id] = true;

            $service = $this->createService($definition, $id);

            unset($this->loading[$id]);

            return $service;

        }

    }

    /**

     * Merges a ContainerBuilder with the current ContainerBuilder configuration.

     *

     * Service definitions overrides the current defined ones.

     *

     * But for parameters, they are overridden by the current ones. It allows

     * the parameters passed to the container constructor to have precedence

     * over the loaded ones.

     *

     * $container = new ContainerBuilder(array('foo' => 'bar'));

     * $loader = new LoaderXXX($container);

     * $loader->load('resource_name');

     * $container->register('foo', new stdClass());

     *

     * In the above example, even if the loaded resource defines a foo

     * parameter, the value will still be 'bar' as defined in the ContainerBuilder

     * constructor.

     *

     * @param ContainerBuilder $container The ContainerBuilder instance to merge.

     * @throws \LogicException when this ContainerBuilder is frozen

     *

     * @api

     */

    public function merge(ContainerBuilder $container)

    {

        if (true === $this->isFrozen()) {

            throw new \LogicException('Cannot merge on a frozen container.');

        }

        $this->addDefinitions($container->getDefinitions());

        $this->addAliases($container->getAliases());

        $this->getParameterBag()->add($container->getParameterBag()->all());

        foreach ($container->getResources() as $resource) {

            $this->addResource($resource);

        }

        foreach ($this->extensions as $name => $extension) {

            if (!isset($this->extensionConfigs[$name])) {

                $this->extensionConfigs[$name] = array();

            }

            $this->extensionConfigs[$name] = array_merge($this->extensionConfigs[$name], $container->getExtensionConfig($name));

        }

    }

    /**

     * Returns the configuration array for the given extension.

     *

     * @param string $name The name of the extension

     *

     * @return array An array of configuration

     *

     * @api

     */

    public function getExtensionConfig($name)

    {

        if (!isset($this->extensionConfigs[$name])) {

            $this->extensionConfigs[$name] = array();

        }

        return $this->extensionConfigs[$name];

    }

    /**

     * Compiles the container.

     *

     * This method passes the container to compiler

     * passes whose job is to manipulate and optimize

     * the container.

     *

     * The main compiler passes roughly do four things:

     *

     *  * The extension configurations are merged;

     *  * Parameter values are resolved;

     *  * The parameter bag is frozen;

     *  * Extension loading is disabled.

     *

     * @api

     */

    public function compile()

    {

        if (null === $this->compiler) {

            $this->compiler = new Compiler();

        }

        foreach ($this->compiler->getPassConfig()->getPasses() as $pass) {

            $this->addObjectResource($pass);

        }

        $this->compiler->compile($this);

        $this->extensionConfigs = array();

        parent::compile();

    }

    /**

     * Gets all service ids.

     *

     * @return array An array of all defined service ids

     */

    public function getServiceIds()

    {

        return array_unique(array_merge(array_keys($this->getDefinitions()), array_keys($this->aliases), parent::getServiceIds()));