<?php

// Generated by scripts/plugin-stub-generator; do not edit by hand.
// Proxy stub for Composer\Util\ProcessExecutor: the public surface forwards to the Rust-side entity over RPC.

namespace Composer\Util;

use Composer\IO\IOInterface;
use React\Promise\PromiseInterface;

class ProcessExecutor implements \ShirabeRustStub
{
    /** @var int */
    protected $__rhandle;
    /** @var int */
    protected $__epoch;

    /**
     * Binds a stub the registry built for an existing entity. Proxy instantiation bypasses
     * the constructor, which belongs to plugin code building a new entity instead.
     */
    public function __shirabeBind(int $rhandle, int $epoch): void
    {
        $this->__rhandle = $rhandle;
        $this->__epoch = $epoch;
    }

    public function __destruct()
    {
        \ShirabeRustObjectRegistry::release($this->__rhandle);
    }

    public function __shirabeRustHandleDescriptor(): array
    {
        return [
            '__rhandle' => $this->__rhandle,
            '__class' => static::class,
            '__epoch' => $this->__epoch,
        ];
    }

    public function __clone()
    {
        // PHP has already shallow-copied this stub, so both copies would point at one
        // entity and release it twice. The Rust side clones the entity instead, applying
        // whatever __clone semantics the real class defines, and this copy rebinds to the
        // fresh handle. Entities without clone semantics answer with an explicit error.
        [$this->__rhandle, $this->__epoch] = \ShirabeRpcRuntime::callRust($this->__rhandle, '__shirabeClone', []);
        \ShirabeRustObjectRegistry::adopt($this->__rhandle, $this);
    }

    public function __get($name)
    {
        return \ShirabeRpcRuntime::callRust($this->__rhandle, '__get', [$name]);
    }

    public function __set($name, $value): void
    {
        \ShirabeRpcRuntime::callRust($this->__rhandle, '__set', [$name, $value]);
    }

    public function __isset($name): bool
    {
        return \ShirabeRpcRuntime::callRust($this->__rhandle, '__isset', [$name]);
    }

    public function __unset($name): void
    {
        \ShirabeRpcRuntime::callRust($this->__rhandle, '__unset', [$name]);
    }

    public function __construct(?IOInterface $io = null)
    {
        [$this->__rhandle, $this->__epoch] = \ShirabeRpcRuntime::callRust(0, '__shirabeConstruct', [static::class, [$io]]);
        \ShirabeRustObjectRegistry::adopt($this->__rhandle, $this);
    }

    private const STATUS_QUEUED = 1;
    private const STATUS_STARTED = 2;
    private const STATUS_COMPLETED = 3;
    private const STATUS_FAILED = 4;
    private const STATUS_ABORTED = 5;
    private const BUILTIN_CMD_COMMANDS = [
        'assoc', 'break', 'call', 'cd', 'chdir', 'cls', 'color', 'copy', 'date',
        'del', 'dir', 'echo', 'endlocal', 'erase', 'exit', 'for', 'ftype', 'goto',
        'help', 'if', 'label', 'md', 'mkdir', 'mklink', 'move', 'path', 'pause',
        'popd', 'prompt', 'pushd', 'rd', 'rem', 'ren', 'rename', 'rmdir', 'set',
        'setlocal', 'shift', 'start', 'time', 'title', 'type', 'ver', 'vol',
    ];
    private const GIT_CMDS_NEED_GIT_DIR = [
        ['show'],
        ['log'],
        ['branch'],
        ['remote', 'set-url'],
    ];

    // Forwarded rather than materialized: it reads the static property $timeout, whose value the Rust side owns.
    public static function getTimeout(): int
    {
        return \ShirabeRpcRuntime::callRust(0, '__shirabeCallStatic', [self::class, 'getTimeout', []]);
    }

    // Forwarded rather than materialized: it reads the static property $timeout, whose value the Rust side owns.
    public static function setTimeout(int $timeout): void
    {
        \ShirabeRpcRuntime::callRust(0, '__shirabeCallStatic', [self::class, 'setTimeout', [$timeout]]);
    }

    // Forwarded rather than materialized: it references Composer\Util\Platform, which a guard shadows in the worker.
    public static function escape($argument): string
    {
        return \ShirabeRpcRuntime::callRust(0, '__shirabeCallStatic', [self::class, 'escape', [$argument]]);
    }

    public function execute($command, &$output = null, ?string $cwd = null): int
    {
        $__args = [$command, $output, $cwd];
        array_splice($__args, func_num_args());
        $__out = [];
        $__result = \ShirabeRpcRuntime::callRust($this->__rhandle, 'execute', $__args, [1], $__out);
        if (array_key_exists(1, $__out)) {
            $output = $__out[1];
        }
        return $__result;
    }

    public function executeTty($command, ?string $cwd = null): int
    {
        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'executeTty', [$command, $cwd]);
    }

    public function executeAsync($command, ?string $cwd = null): PromiseInterface
    {
        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'executeAsync', [$command, $cwd]);
    }

    public function setMaxJobs(int $maxJobs): void
    {
        \ShirabeRpcRuntime::callRust($this->__rhandle, 'setMaxJobs', [$maxJobs]);
    }

    public function resetMaxJobs(): void
    {
        \ShirabeRpcRuntime::callRust($this->__rhandle, 'resetMaxJobs', []);
    }

    public function wait($index = null): void
    {
        \ShirabeRpcRuntime::callRust($this->__rhandle, 'wait', [$index]);
    }

    public function enableAsync(): void
    {
        \ShirabeRpcRuntime::callRust($this->__rhandle, 'enableAsync', []);
    }

    public function countActiveJobs($index = null): int
    {
        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'countActiveJobs', [$index]);
    }

    public function splitLines(?string $output): array
    {
        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'splitLines', [$output]);
    }

    public function getErrorOutput(): string
    {
        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getErrorOutput', []);
    }

    public function requiresGitDirEnv($command): bool
    {
        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'requiresGitDirEnv', [$command]);
    }
}