<?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\Form;

use Symfony\Component\Form\Exception\FormException;

use Symfony\Component\Form\Exception\UnexpectedTypeException;

/**

 * @author Bernhard Schussek <bernhard.schussek@symfony.com>

 */

abstract class AbstractExtension implements FormExtensionInterface

{

    /**

     * The types provided by this extension

     * @var array An array of FormTypeInterface

     */

    private $types;

    /**

     * The type extensions provided by this extension

     * @var array An array of FormTypeExtensionInterface

     */

    private $typeExtensions;

    /**

     * The type guesser provided by this extension

     * @var FormTypeGuesserInterface

     */

    private $typeGuesser;

    /**

     * Whether the type guesser has been loaded

     * @var Boolean

     */

    private $typeGuesserLoaded = false;

    /**

     * Returns a type by name.

     *

     * @param string $name The name of the type

     *

     * @return FormTypeInterface The type

     *

     * @throws FormException if the given type is not supported by this extension

     */

    public function getType($name)

    {

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

            $this->initTypes();

        }

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

            throw new FormException(sprintf('The type "%s" can not be loaded by this extension', $name));

        }

        return $this->types[$name];

    }

    /**

     * Returns whether the given type is supported.

     *

     * @param string $name The name of the type

     *

     * @return Boolean Whether the type is supported by this extension

     */

    public function hasType($name)

    {

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

            $this->initTypes();

        }

        return isset($this->types[$name]);

    }

    /**

     * Returns the extensions for the given type.

     *

     * @param string $name The name of the type

     *

     * @return array An array of extensions as FormTypeExtensionInterface instances

     */

    public function getTypeExtensions($name)

    {

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

            $this->initTypeExtensions();

        }

        return isset($this->typeExtensions[$name])

            ? $this->typeExtensions[$name]

            : array();

    }

    /**

     * Returns whether this extension provides type extensions for the given type.

     *

     * @param string $name The name of the type

     *

     * @return Boolean Whether the given type has extensions

     */

    public function hasTypeExtensions($name)

    {

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

            $this->initTypeExtensions();

        }

        return isset($this->typeExtensions[$name]) && count($this->typeExtensions[$name]) > 0;

    }

    /**

     * Returns the type guesser provided by this extension.

     *

     * @return FormTypeGuesserInterface|null The type guesser

     */

    public function getTypeGuesser()

    {

        if (!$this->typeGuesserLoaded) {

            $this->initTypeGuesser();

        }

        return $this->typeGuesser;

    }

    /**

     * Registers the types.

     *

     * @return array An array of FormTypeInterface instances

     */

    protected function loadTypes()

    {

        return array();

    }

    /**

     * Registers the type extensions.

     *

     * @return array An array of FormTypeExtensionInterface instances

     */

    protected function loadTypeExtensions()

    {

        return array();

    }

    /**

     * Registers the type guesser.

     *

     * @return FormTypeGuesserInterface|null A type guesser

     */

    protected function loadTypeGuesser()

    {

        return null;

    }

    /**

     * Initializes the types.

     *

     * @throws UnexpectedTypeException if any registered type is not an instance of FormTypeInterface

     */

    private function initTypes()

    {

        $this->types = array();

        foreach ($this->loadTypes() as $type) {

            if (!$type instanceof FormTypeInterface) {

                throw new UnexpectedTypeException($type, 'Symfony\Component\Form\FormTypeInterface');

            }

            $this->types[$type->getName()] = $type;

        }

    }

    /**

     * Initializes the type extensions.

     *

     * @throws UnexpectedTypeException if any registered type extension is not

     *                                 an instance of FormTypeExtensionInterface

     */

    private function initTypeExtensions()

    {

        $this->typeExtensions = array();

        foreach ($this->loadTypeExtensions() as $extension) {

            if (!$extension instanceof FormTypeExtensionInterface) {

                throw new UnexpectedTypeException($extension, 'Symfony\Component\Form\FormTypeExtensionInterface');

            }

            $type = $extension->getExtendedType();

            $this->typeExtensions[$type][] = $extension;

        }

    }

    /**

     * Initializes the type guesser.

     *

     * @throws UnexpectedTypeException if the type guesser is not an instance of FormTypeGuesserInterface

     */

    private function initTypeGuesser()

    {

        $this->typeGuesserLoaded = true;

        $this->typeGuesser = $this->loadTypeGuesser();

        if (null !== $this->typeGuesser && !$this->typeGuesser instanceof FormTypeGuesserInterface) {

            throw new UnexpectedTypeException($this->typeGuesser, 'Symfony\Component\Form\FormTypeGuesserInterface');

        }

    }

}