<?php declare(strict_types=1);

namespace App;

use Symfony\Component\Console\Application;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\Input;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Input\StringInput;
use Symfony\Component\Console\Output\BufferedOutput;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Process\Process;
use Webmozarts\Console\Parallelization\Input\InputOptionsSerializer;
use Webmozarts\Console\Parallelization\Input\RawInput;
use function array_diff_key;
use function array_fill_keys;
use function array_values;
use function sprintf;

require __DIR__.'/vendor/autoload.php';

class RawInputCommand extends Command
{
    private const FIRST_REQ_ARG = 'firstArg';
    private const SECOND_REQ_ARG = 'secondArg';
    private const OPTIONAL_ARG = 'optionalArg';

    private const FIRST_OPTION = 'firstOpt';
    private const SUB_PROCESS_OPTION = 'child';
    private const MAIN_PROCESS_ONLY_OPTION = 'mainProcessOnlyOption';

    public function __construct()
    {
        parent::__construct('raw-input');
    }

    public function configure(): void
    {
        $this->addArgument(
            self::FIRST_REQ_ARG,
            InputArgument::REQUIRED,
            'The first argument',
        );
        $this->addArgument(
            self::SECOND_REQ_ARG,
            InputArgument::REQUIRED,
            'The second argument',
        );
        $this->addArgument(
            self::OPTIONAL_ARG,
            InputArgument::OPTIONAL,
            'An optional argument',
            'default',
        );
        $this->addOption(
            self::FIRST_OPTION,
            null,
            InputOption::VALUE_NONE,
            'The first option',
        );
        $this->addOption(
            self::SUB_PROCESS_OPTION,
            null,
            InputOption::VALUE_NONE,
            'An option to indicate the command is being executed in a sub-process',
        );
        $this->addOption(
            self::MAIN_PROCESS_ONLY_OPTION,
            null,
            InputOption::VALUE_NONE,
            'An option that should not be passed to the main process',
        );
    }

    protected function execute(
        InputInterface $input,
        OutputInterface $output,
    ): int {
        $processInput = [
            ...self::getProcessArguments($input),
            ...self::getProcessOptions($input),
        ];

        $output->write(implode(' ', $processInput));

        $process = new Process([
            PHP_BINARY,
            __DIR__,
            ...$processInput,
        ]);

        if ($output->isVerbose()) {
            $output->write(
                sprintf(
                    'Running command: %s',
                    $process->getCommandLine(),
                ),
            );
        }

        $process->run();

        if ($output->isVerbose()) {
            $output->writeln($process->getOutput());
        }

        return $process->getExitCode();
    }

    /**
     * @return list<string|bool|int|float|null|array<string|bool|int|float|null>>
     */
    private static function getProcessArguments(InputInterface $input): array
    {
        // We want the same arguments as the current command
        // There is cases where the command invoked could be different though
        // in which case the command name should be explicitly added, and
        // we can use $input->getRawArguments(true) instead.
        return $input instanceof Input
            ? array_values($input->getRawArguments())
            : [];
    }

    /**
     * @return list<string>
     */
    private static function getProcessOptions(InputInterface $input): array
    {
        if (!($input instanceof Input)) {
            return [];
        }

        $options = $input->getRawOptions();
        unset($options[self::MAIN_PROCESS_ONLY_OPTION]);
        $options[self::SUB_PROCESS_OPTION] = true;


        return $input->unparse($options);
    }
}

$application = new Application();
$application->add(new RawInputCommand());
$application->setDefaultCommand('raw-input');
$application->setAutoExit(false);

$application->run(
    new StringInput('raw-input firstArg secondArg --mainProcessOnlyOption'),
    $output = new BufferedOutput(),
);

// As you can see:
// - optionalArg is not passed to the child process as was not passed by the user
// - mainProcessOnlyOption is not passed to the child process
// - firstOpt is not passed to the child process as was not passed by the user
// - child is passed to the child process
assert($output->fetch() === 'raw-input firstArg secondArg --child');