# Lint as: python3
# Copyright 2021 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Helper functions for running commands as subprocesses."""

import logging
import pathlib
import shutil
import sys
import subprocess

from typing import Optional, Sequence, Union

_PYTHON_UTILS_PATH = pathlib.Path(__file__).resolve().parents[0]
if str(_PYTHON_UTILS_PATH) not in sys.path:
    sys.path.append(str(_PYTHON_UTILS_PATH))
import git_metadata_utils


def resolve_ninja() -> str:
    # Prefer the version on PATH, but fallback to known version if PATH doesn't
    # have one (e.g. on bots).
    if shutil.which('ninja') is None:
        return str(
            git_metadata_utils.get_chromium_src_path()
            / 'third_party/ninja/ninja'
        )
    return 'ninja'


def resolve_autoninja():
    # Prefer the version on PATH, but fallback to known version if PATH doesn't
    # have one (e.g. on bots).
    if shutil.which('autoninja') is None:
        return str(
            git_metadata_utils.get_chromium_src_path()
            / 'third_party/depot_tools/autoninja'
        )
    return 'autoninja'


def run_command(
    command: Sequence[str],
    *,  # Ensures that the rest of the args are passed explicitly.
    cwd: Optional[Union[str, pathlib.Path]] = None,
    cmd_input: Optional[str] = None,
    exitcode_only: bool = False,
) -> str:
    """Runs a command and returns the output as a string.

    For example, run_command(['echo', ' Hello, world!\n']) returns the string
    'Hello, world!' and run_command(['pwd'], cwd='/usr/local/bin') returns the
    string '/usr/local/bin'.

    Args:
      command:
        A sequence of strings representing the command to run, starting with the
        executable name followed by the arguments.
      cwd:
        The working directory in which to run the command; if not specified,
        defaults to the current working directory.
      cmd_input:
        Input text that should be automatically passed to the process's stdin.
      exitcode_only:
        Avoid re-raising any errors or logging any output for errors. Useful for
        commands that are expected to return a non-zero exit status.

    Returns:
      If |exitcode_only| is True, then only the exitcode is returned.
      Otherwise, output (stdout) of the command as a string. Leading and trailing
      whitespace are stripped from the output.

    Raises
      CalledProcessError:
        The command returned a non-zero exit code indicating failure; the error
        code is printed along with the error message (stderr) and output (stdout),
        if any.
      FileNotFoundError: The executable specified in the command was not found.
    """
    try:
        run_result: subprocess.CompletedProcess = subprocess.run(
            command,
            capture_output=True,
            text=True,
            check=not exitcode_only,
            cwd=cwd,
            input=cmd_input,
        )
    except subprocess.CalledProcessError as e:
        command_str = ' '.join(command)
        error_msg = f'Command "{command_str}" failed with code {e.returncode}.'
        if e.stderr:
            error_msg += f'\nSTDERR: {e.stderr}'
        if e.stdout:
            error_msg += f'\nSTDOUT: {e.stdout}'

        logging.error(error_msg)
        raise

    if exitcode_only:
        return run_result.returncode
    return str(run_result.stdout).strip()