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

use Symfony\Component\Console\Input\InputInterface;

use Symfony\Component\Console\Input\ArgvInput;

use Symfony\Component\Console\Input\ArrayInput;

use Symfony\Component\Console\Input\InputDefinition;

use Symfony\Component\Console\Input\InputOption;

use Symfony\Component\Console\Input\InputArgument;

use Symfony\Component\Console\Output\OutputInterface;

use Symfony\Component\Console\Output\Output;

use Symfony\Component\Console\Output\ConsoleOutput;

use Symfony\Component\Console\Command\Command;

use Symfony\Component\Console\Command\HelpCommand;

use Symfony\Component\Console\Command\ListCommand;

use Symfony\Component\Console\Helper\HelperSet;

use Symfony\Component\Console\Helper\FormatterHelper;

use Symfony\Component\Console\Helper\DialogHelper;

/**

 * An Application is the container for a collection of commands.

 *

 * It is the main entry point of a Console application.

 *

 * This class is optimized for a standard CLI environment.

 *

 * Usage:

 *

 *     $app = new Application('myapp', '1.0 (stable)');

 *     $app->add(new SimpleCommand());

 *     $app->run();

 *

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

 *

 * @api

 */

class Application

{

    private $commands;

    private $wantHelps = false;

    private $runningCommand;

    private $name;

    private $version;

    private $catchExceptions;

    private $autoExit;

    private $definition;

    private $helperSet;

    /**

     * Constructor.

     *

     * @param string  $name    The name of the application

     * @param string  $version The version of the application

     *

     * @api

     */

    public function __construct($name = 'UNKNOWN', $version = 'UNKNOWN')

    {

        $this->name = $name;

        $this->version = $version;

        $this->catchExceptions = true;

        $this->autoExit = true;

        $this->commands = array();

        $this->helperSet = new HelperSet(array(

            new FormatterHelper(),

            new DialogHelper(),

        ));

        $this->add(new HelpCommand());

        $this->add(new ListCommand());

        $this->definition = new InputDefinition(array(

            new InputArgument('command', InputArgument::REQUIRED, 'The command to execute'),

            new InputOption('--help',           '-h', InputOption::VALUE_NONE, 'Display this help message.'),

            new InputOption('--quiet',          '-q', InputOption::VALUE_NONE, 'Do not output any message.'),

            new InputOption('--verbose',        '-v', InputOption::VALUE_NONE, 'Increase verbosity of messages.'),

            new InputOption('--version',        '-V', InputOption::VALUE_NONE, 'Display this program version.'),

            new InputOption('--ansi',           '',   InputOption::VALUE_NONE, 'Force ANSI output.'),

            new InputOption('--no-ansi',        '',   InputOption::VALUE_NONE, 'Disable ANSI output.'),

            new InputOption('--no-interaction', '-n', InputOption::VALUE_NONE, 'Do not ask any interactive question.'),

        ));

    }

    /**

     * Runs the current application.

     *

     * @param InputInterface  $input  An Input instance

     * @param OutputInterface $output An Output instance

     *

     * @return integer 0 if everything went fine, or an error code

     *

     * @throws \Exception When doRun returns Exception

     *

     * @api

     */

    public function run(InputInterface $input = null, OutputInterface $output = null)

    {

        if (null === $input) {

            $input = new ArgvInput();

        }

        if (null === $output) {

            $output = new ConsoleOutput();

        }

        try {

            $statusCode = $this->doRun($input, $output);

        } catch (\Exception $e) {

            if (!$this->catchExceptions) {

                throw $e;

            }

            $this->renderException($e, $output);

            $statusCode = $e->getCode();

            $statusCode = is_numeric($statusCode) && $statusCode ? $statusCode : 1;

        }

        if ($this->autoExit) {

            if ($statusCode > 255) {

                $statusCode = 255;

            }

            // @codeCoverageIgnoreStart

            exit($statusCode);

            // @codeCoverageIgnoreEnd

        }

        return $statusCode;

    }

    /**

     * Runs the current application.

     *

     * @param InputInterface  $input  An Input instance

     * @param OutputInterface $output An Output instance

     *

     * @return integer 0 if everything went fine, or an error code

     */

    public function doRun(InputInterface $input, OutputInterface $output)

    {

        $name = $this->getCommandName($input);

        if (true === $input->hasParameterOption(array('--ansi'))) {

            $output->setDecorated(true);

        } elseif (true === $input->hasParameterOption(array('--no-ansi'))) {

            $output->setDecorated(false);

        }

        if (true === $input->hasParameterOption(array('--help', '-h'))) {

            if (!$name) {

                $name = 'help';

                $input = new ArrayInput(array('command' => 'help'));

            } else {

                $this->wantHelps = true;

            }

        }

        if (true === $input->hasParameterOption(array('--no-interaction', '-n'))) {

            $input->setInteractive(false);

        }

        if (true === $input->hasParameterOption(array('--quiet', '-q'))) {

            $output->setVerbosity(OutputInterface::VERBOSITY_QUIET);

        } elseif (true === $input->hasParameterOption(array('--verbose', '-v'))) {

            $output->setVerbosity(OutputInterface::VERBOSITY_VERBOSE);

        }

        if (true === $input->hasParameterOption(array('--version', '-V'))) {

            $output->writeln($this->getLongVersion());

            return 0;

        }

        if (!$name) {

            $name = 'list';

            $input = new ArrayInput(array('command' => 'list'));

        }

        // the command name MUST be the first element of the input

        $command = $this->find($name);

        $this->runningCommand = $command;

        $statusCode = $command->run($input, $output);

        $this->runningCommand = null;

        return is_numeric($statusCode) ? $statusCode : 0;

    }

    /**

     * Set a helper set to be used with the command.

     *

     * @param HelperSet $helperSet The helper set

     *

     * @api

     */

    public function setHelperSet(HelperSet $helperSet)

    {

        $this->helperSet = $helperSet;

    }

    /**

     * Get the helper set associated with the command.

     *

     * @return HelperSet The HelperSet instance associated with this command

     *

     * @api

     */

    public function getHelperSet()

    {

        return $this->helperSet;

    }

    /**

     * Gets the InputDefinition related to this Application.

     *

     * @return InputDefinition The InputDefinition instance

     */

    public function getDefinition()

    {

        return $this->definition;

    }

    /**

     * Gets the help message.

     *

     * @return string A help message.

     */

    public function getHelp()

    {

        $messages = array(

            $this->getLongVersion(),

            '',

            '<comment>Usage:</comment>',

            sprintf("  [options] command [arguments]\n"),

            '<comment>Options:</comment>',

        );

        foreach ($this->getDefinition()->getOptions() as $option) {

            $messages[] = sprintf('  %-29s %s %s',

                '<info>--'.$option->getName().'</info>',

                $option->getShortcut() ? '<info>-'.$option->getShortcut().'</info>' : '  ',

                $option->getDescription()

            );

        }

        return implode("\n", $messages);

    }

    /**

     * Sets whether to catch exceptions or not during commands execution.

     *

     * @param Boolean $boolean Whether to catch exceptions or not during commands execution

     *

     * @api

     */

    public function setCatchExceptions($boolean)

    {

        $this->catchExceptions = (Boolean) $boolean;

    }

    /**

     * Sets whether to automatically exit after a command execution or not.

     *

     * @param Boolean $boolean Whether to automatically exit after a command execution or not

     *

     * @api

     */

    public function setAutoExit($boolean)

    {

        $this->autoExit = (Boolean) $boolean;

    }

    /**

     * Gets the name of the application.

     *

     * @return string The application name

     *

     * @api

     */

    public function getName()

    {

        return $this->name;

    }

    /**

     * Sets the application name.

     *

     * @param string $name The application name

     *

     * @api

     */

    public function setName($name)

    {

        $this->name = $name;

    }

    /**

     * Gets the application version.

     *

     * @return string The application version

     *

     * @api

     */

    public function getVersion()

    {

        return $this->version;

    }

    /**

     * Sets the application version.

     *

     * @param string $version The application version

     *

     * @api

     */

    public function setVersion($version)

    {

        $this->version = $version;

    }

    /**

     * Returns the long version of the application.

     *

     * @return string The long application version

     *

     * @api

     */

    public function getLongVersion()

    {

        if ('UNKNOWN' !== $this->getName() && 'UNKNOWN' !== $this->getVersion()) {

            return sprintf('<info>%s</info> version <comment>%s</comment>', $this->getName(), $this->getVersion());

        }

        return '<info>Console Tool</info>';

    }

    /**

     * Registers a new command.

     *

     * @param string $name The command name

     *

     * @return Command The newly created command

     *

     * @api

     */

    public function register($name)

    {

        return $this->add(new Command($name));

    }

    /**

     * Adds an array of command objects.

     *

     * @param Command[] $commands An array of commands

     *

     * @api

     */

    public function addCommands(array $commands)

    {

        foreach ($commands as $command) {

            $this->add($command);

        }

    }

    /**

     * Adds a command object.

     *

     * If a command with the same name already exists, it will be overridden.

     *

     * @param Command $command A Command object

     *

     * @return Command The registered command

     *

     * @api

     */

    public function add(Command $command)

    {

        $command->setApplication($this);

        $this->commands[$command->getName()] = $command;

        foreach ($command->getAliases() as $alias) {

            $this->commands[$alias] = $command;

        }

        return $command;

    }

    /**

     * Returns a registered command by name or alias.

     *

     * @param string $name The command name or alias

     *

     * @return Command A Command object

     *

     * @throws \InvalidArgumentException When command name given does not exist

     *

     * @api

     */

    public function get($name)

    {

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

            throw new \InvalidArgumentException(sprintf('The command "%s" does not exist.', $name));

        }

        $command = $this->commands[$name];

        if ($this->wantHelps) {

            $this->wantHelps = false;

            $helpCommand = $this->get('help');

            $helpCommand->setCommand($command);

            return $helpCommand;

        }

        return $command;

    }

    /**

     * Returns true if the command exists, false otherwise.

     *

     * @param string $name The command name or alias

     *

     * @return Boolean true if the command exists, false otherwise

     *

     * @api

     */

    public function has($name)

    {

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

    }

    /**