<?php

namespace Composer\Command;

use Composer\Advisory\Auditor;
use Composer\Composer;
use Composer\Config;
use Composer\Console\Application;
use Composer\Console\Input\InputArgument;
use Composer\Console\Input\InputOption;
use Composer\Factory;
use Composer\Filter\PlatformRequirementFilter\PlatformRequirementFilterFactory;
use Composer\Filter\PlatformRequirementFilter\PlatformRequirementFilterInterface;
use Composer\IO\IOInterface;
use Composer\IO\NullIO;
use Composer\Package\Version\VersionParser;
use Composer\Plugin\PluginEvents;
use Composer\Plugin\PreCommandRunEvent;
use Composer\Util\Platform;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Completion\CompletionInput;
use Symfony\Component\Console\Completion\CompletionSuggestions;
use Symfony\Component\Console\Helper\Table;
use Symfony\Component\Console\Helper\TableSeparator;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Terminal;

/**
 * Base class for Composer commands
 *
 * @author Ryan Weaver <ryan@knplabs.com>
 * @author Konstantin Kudryashov <ever.zet@gmail.com>
 */
abstract class BaseCommand extends Command
{
	/** @var Composer|null */
	private $composer;

	/** @var IOInterface */
	private $io;


	/**
	 * Gets the application instance for this command.
	 */
	public function getApplication(): Application
	{
		$application = parent::getApplication();
		if (!$application instanceof Application) {
		    throw new \RuntimeException('Composer commands can only work with an '.Application::class.' instance set');
		}

		return $application;
	}


	/**
	 * @param  bool              $required       Should be set to false, or use `requireComposer` instead
	 * @param  bool|null         $disablePlugins If null, reads --no-plugins as default
	 * @param  bool|null         $disableScripts If null, reads --no-scripts as default
	 * @throws \RuntimeException
	 * @return Composer|null
	 * @deprecated since Composer 2.3.0 use requireComposer or tryComposer depending on whether you have $required set to true or false
	 */
	public function getComposer(bool $required = true, ?bool $disablePlugins = null, ?bool $disableScripts = null)
	{
		if ($required) {
		    return $this->requireComposer($disablePlugins, $disableScripts);
		}

		return $this->tryComposer($disablePlugins, $disableScripts);
	}


	/**
	 * Retrieves the default Composer\Composer instance or throws
	 *
	 * Use this instead of getComposer if you absolutely need an instance
	 *
	 * @param bool|null $disablePlugins If null, reads --no-plugins as default
	 * @param bool|null $disableScripts If null, reads --no-scripts as default
	 * @throws \RuntimeException
	 */
	public function requireComposer(?bool $disablePlugins = null, ?bool $disableScripts = null): Composer
	{
		if (null === $this->composer) {
		    $application = parent::getApplication();
		    if ($application instanceof Application) {
		        $this->composer = $application->getComposer(true, $disablePlugins, $disableScripts);
		        assert($this->composer instanceof Composer);
		    } else {
		        throw new \RuntimeException(
		            'Could not create a Composer\Composer instance, you must inject '.
		            'one if this command is not used with a Composer\Console\Application instance'
		        );
		    }
		}

		return $this->composer;
	}


	/**
	 * Retrieves the default Composer\Composer instance or null
	 *
	 * Use this instead of getComposer(false)
	 *
	 * @param bool|null $disablePlugins If null, reads --no-plugins as default
	 * @param bool|null $disableScripts If null, reads --no-scripts as default
	 */
	public function tryComposer(?bool $disablePlugins = null, ?bool $disableScripts = null): ?Composer
	{
		if (null === $this->composer) {
		    $application = parent::getApplication();
		    if ($application instanceof Application) {
		        $this->composer = $application->getComposer(false, $disablePlugins, $disableScripts);
		    }
		}

		return $this->composer;
	}


	/**
	 * @return void
	 */
	public function setComposer(Composer $composer)
	{
		$this->composer = $composer;
	}


	/**
	 * Removes the cached composer instance
	 *
	 * @return void
	 */
	public function resetComposer()
	{
		$this->composer = null;
		$this->getApplication()->resetComposer();
	}


	/**
	 * Whether or not this command is meant to call another command.
	 *
	 * This is mainly needed to avoid duplicated warnings messages.
	 *
	 * @return bool
	 */
	public function isProxyCommand()
	{
		return false;
	}


	/**
	 * @return IOInterface
	 */
	public function getIO()
	{
		if (null === $this->io) {
		    $application = parent::getApplication();
		    if ($application instanceof Application) {
		        $this->io = $application->getIO();
		    } else {
		        $this->io = new NullIO();
		    }
		}

		return $this->io;
	}


	/**
	 * @return void
	 */
	public function setIO(IOInterface $io)
	{
		$this->io = $io;
	}


	/**
	 * @inheritdoc
	 *
	 * Backport suggested values definition from symfony/console 6.1+
	 *
	 * TODO drop when PHP 8.1 / symfony 6.1+ can be required
	 */
	public function complete(CompletionInput $input, CompletionSuggestions $suggestions): void
	{
		$definition = $this->getDefinition();
		$name = (string) $input->getCompletionName();
		if (CompletionInput::TYPE_OPTION_VALUE === $input->getCompletionType()
		    && $definition->hasOption($name)
		    && ($option = $definition->getOption($name)) instanceof InputOption
		) {
		    $option->complete($input, $suggestions);
		} elseif (CompletionInput::TYPE_ARGUMENT_VALUE === $input->getCompletionType()
		    && $definition->hasArgument($name)
		    && ($argument = $definition->getArgument($name)) instanceof InputArgument
		) {
		    $argument->complete($input, $suggestions);
		} else {
		    parent::complete($input, $suggestions);
		}
	}


	/**
	 * @inheritDoc
	 *
	 * @return void
	 */
	protected function initialize(InputInterface $input, OutputInterface $output)
	{
		$disablePlugins = $input->hasParameterOption('--no-plugins');
		$disableScripts = $input->hasParameterOption('--no-scripts');
		if ($this instanceof SelfUpdateCommand) {
		    $disablePlugins = true;
		    $disableScripts = true;
		}

		$composer = $this->tryComposer($disablePlugins, $disableScripts);
		$io = $this->getIO();

		if (null === $composer) {
		    $composer = Factory::createGlobal($this->getIO(), $disablePlugins, $disableScripts);
		}
		if ($composer) {
		    $preCommandRunEvent = new PreCommandRunEvent(PluginEvents::PRE_COMMAND_RUN, $input, $this->getName());
		    $composer->getEventDispatcher()->dispatch($preCommandRunEvent->getName(), $preCommandRunEvent);
		}

		if (true === $input->hasParameterOption(['--no-ansi']) && $input->hasOption('no-progress')) {
		    $input->setOption('no-progress', true);
		}

		$envOptions = [
		    'COMPOSER_NO_AUDIT' => ['no-audit'],
		    'COMPOSER_NO_DEV' => ['no-dev', 'update-no-dev'],
		    'COMPOSER_PREFER_STABLE' => ['prefer-stable'],
		    'COMPOSER_PREFER_LOWEST' => ['prefer-lowest'],
		];
		foreach ($envOptions as $envName => $optionNames) {
		    foreach ($optionNames as $optionName) {
		        if (true === $input->hasOption($optionName)) {
		            if (false === $input->getOption($optionName) && (bool) Platform::getEnv($envName)) {
		                $input->setOption($optionName, true);
		            }
		        }
		    }
		}

		if (true === $input->hasOption('ignore-platform-reqs')) {
		    if (!$input->getOption('ignore-platform-reqs') && (bool) Platform::getEnv('COMPOSER_IGNORE_PLATFORM_REQS')) {
		        $input->setOption('ignore-platform-reqs', true);

		        $io->writeError('<warning>COMPOSER_IGNORE_PLATFORM_REQS is set. You may experience unexpected errors.</warning>');
		    }
		}

		if (true === $input->hasOption('ignore-platform-req') && (!$input->hasOption('ignore-platform-reqs') || !$input->getOption('ignore-platform-reqs'))) {
		    $ignorePlatformReqEnv = Platform::getEnv('COMPOSER_IGNORE_PLATFORM_REQ');
		    if (0 === count($input->getOption('ignore-platform-req')) && is_string($ignorePlatformReqEnv) && '' !== $ignorePlatformReqEnv) {
		        $input->setOption('ignore-platform-req', explode(',', $ignorePlatformReqEnv));

		        $io->writeError('<warning>COMPOSER_IGNORE_PLATFORM_REQ is set to ignore '.$ignorePlatformReqEnv.'. You may experience unexpected errors.</warning>');
		    }
		}

		parent::initialize($input, $output);
	}


	/**
	 * Returns preferSource and preferDist values based on the configuration.
	 *
	 * @return bool[] An array composed of the preferSource and preferDist values
	 */
	protected function getPreferredInstallOptions(
		Config $config,
		InputInterface $input,
		bool $keepVcsRequiresPreferSource = false,
	) {
		$preferSource = false;
		$preferDist = false;

		switch ($config->get('preferred-install')) {
		    case 'source':
		        $preferSource = true;
		        break;
		    case 'dist':
		        $preferDist = true;
		        break;
		    case 'auto':
		    default:
		        // noop
		        break;
		}

		if (!$input->hasOption('prefer-dist') || !$input->hasOption('prefer-source')) {
		    return [$preferSource, $preferDist];
		}

		if ($input->hasOption('prefer-install') && is_string($input->getOption('prefer-install'))) {
		    if ($input->getOption('prefer-source')) {
		        throw new \InvalidArgumentException('--prefer-source can not be used together with --prefer-install');
		    }
		    if ($input->getOption('prefer-dist')) {
		        throw new \InvalidArgumentException('--prefer-dist can not be used together with --prefer-install');
		    }
		    switch ($input->getOption('prefer-install')) {
		        case 'dist':
		            $input->setOption('prefer-dist', true);
		            break;
		        case 'source':
		            $input->setOption('prefer-source', true);
		            break;
		        case 'auto':
		            $preferDist = false;
		            $preferSource = false;
		            break;
		        default:
		            throw new \UnexpectedValueException('--prefer-install accepts one of "dist", "source" or "auto", got '.$input->getOption('prefer-install'));
		    }
		}

		if ($input->getOption('prefer-source') || $input->getOption('prefer-dist') || ($keepVcsRequiresPreferSource && $input->hasOption('keep-vcs') && $input->getOption('keep-vcs'))) {
		    $preferSource = $input->getOption('prefer-source') || ($keepVcsRequiresPreferSource && $input->hasOption('keep-vcs') && $input->getOption('keep-vcs'));
		    $preferDist = $input->getOption('prefer-dist');
		}

		return [$preferSource, $preferDist];
	}


	protected function getPlatformRequirementFilter(InputInterface $input): PlatformRequirementFilterInterface
	{
		if (!$input->hasOption('ignore-platform-reqs') || !$input->hasOption('ignore-platform-req')) {
		    throw new \LogicException('Calling getPlatformRequirementFilter from a command which does not define the --ignore-platform-req[s] flags is not permitted.');
		}

		if (true === $input->getOption('ignore-platform-reqs')) {
		    return PlatformRequirementFilterFactory::ignoreAll();
		}

		$ignores = $input->getOption('ignore-platform-req');
		if (count($ignores) > 0) {
		    return PlatformRequirementFilterFactory::fromBoolOrList($ignores);
		}

		return PlatformRequirementFilterFactory::ignoreNothing();
	}


	/**
	 * @param array<string> $requirements
	 *
	 * @return array<string, string>
	 */
	protected function formatRequirements(array $requirements)
	{
		$requires = [];
		$requirements = $this->normalizeRequirements($requirements);
		foreach ($requirements as $requirement) {
		    if (!isset($requirement['version'])) {
		        throw new \UnexpectedValueException('Option '.$requirement['name'] .' is missing a version constraint, use e.g. '.$requirement['name'].':^1.0');
		    }
		    $requires[$requirement['name']] = $requirement['version'];
		}

		return $requires;
	}


	/**
	 * @param array<string> $requirements
	 *
	 * @return list<array{name: string, version?: string}>
	 */
	protected function normalizeRequirements(array $requirements)
	{
		$parser = new VersionParser();

		return $parser->parseNameVersionPairs($requirements);
	}


	/**
	 * @param array<TableSeparator|mixed[]> $table
	 *
	 * @return void
	 */
	protected function renderTable(array $table, OutputInterface $output)
	{
		$renderer = new Table($output);
		$renderer->setStyle('compact');
		$renderer->setRows($table)->render();
	}


	/**
	 * @return int
	 */
	protected function getTerminalWidth()
	{
		$terminal = new Terminal();
		$width = $terminal->getWidth();

		if (Platform::isWindows()) {
		    $width--;
		} else {
		    $width = max(80, $width);
		}

		return $width;
	}


	/**
	 * @internal
	 * @param 'format'|'audit-format' $optName
	 * @return Auditor::FORMAT_*
	 */
	protected function getAuditFormat(InputInterface $input, string $optName = 'audit-format'): string
	{
		if (!$input->hasOption($optName)) {
		    throw new \LogicException('This should not be called on a Command which has no '.$optName.' option defined.');
		}

		$val = $input->getOption($optName);
		if (!in_array($val, Auditor::FORMATS, true)) {
		    throw new \InvalidArgumentException('--'.$optName.' must be one of '.implode(', ', Auditor::FORMATS).'.');
		}

		return $val;
	}
}
__halt_compiler();----SIGNATURE:----C/ifwUrUyEBx0jEuaN1w2Yvcic0kcfEiJkPbIRY1fXAMPb7o2O9gRJybf0M4EccmE3/n143CO6VL361dY/kRN+zMN0tdWHBjWBwiWTIbvimFPJ8xNVWyS/DGUbn4gdojx6RsC8HLweWrRqUOJdU5nIXMhZmGgQOBVqgBk2CtdkeYVlGO+yuMfNb4zBKoxUUTLoDBQg/nlDriAooYQIuc/px/Nzcfj8vvhvJ/qD4p6zCBhm6hU9iD+q0ZTXnx6PhIimzpSWCqPZhAxarIPSeM8kvETzuDL7dsedlgxA1vgfn3rGsIEwQE2M5g6Xn3bMIi3zMJd0MQw7LejM+rKEuCoSWvuAC8f3XG66d2CqYQiqI1H1ICGlDp2l0YQS77gYIBhhbmNw3QRQfWJmkmdJZse83HicqEjAYieDNitgPFVU3PiqkOzfLHVeSngWDDthBlF/FkujxUb6cFekC7kC/KVhb2NAZ2hZbmk41+Qhqjj0opQr20aV39Rn9slRSHXPvNrdgQ11vjZ+5MaJib2o2KCZ6z/NL+AmBo8B9kCeTmJ8RRA53qBV0rZngJve5IvJDUOsyzExGJFPD7h/zJDNsY729W3/dXtpiHX7cc52A808lrtF+Bos9Gx9lRvTJTcBM7p8jkSfnEQhhHgu4U/50S5EIKcx4asMiSZ1YV4ua3Bsw=----ATTACHMENT:----NjUwOTkwOTU2MDg2MDE3NCAzMjE5NDY5OTM0ODA0MjkxIDY4OTgwMjA2NDk2NzAzNjg=