class FixturesBase

abstract class FixturesBase {
  
  /**
   * Keep a persistent prefix to help group our tmp directories together.
   *
   * @var string
   */
  protected static string $randomPrefix = '';
  
  /**
   * Directories to delete when we are done.
   *
   * @var string[]
   */
  protected array $tmpDirs = [];
  
  /**
   * A Composer IOInterface to write to.
   *
   * @var \Composer\IO\IOInterface|null
   */
  protected ?IOInterface $io;
  
  /**
   * The composer object.
   *
   * @var \Composer\Composer
   */
  protected Composer $composer;
  
  /**
   * Gets an IO fixture.
   *
   * @return \Composer\IO\IOInterface
   *   A Composer IOInterface to write to; output may be retrieved via
   *   Fixtures::getOutput().
   */
  public function io() : IOInterface {
    if (!isset($this->io)) {
      $this->io = new BufferIO();
    }
    return $this->io;
  }
  
  /**
   * Gets the Composer object.
   *
   * @return \Composer\Composer
   *   The main Composer object, needed by the scaffold Handler, etc.
   */
  public function getComposer() : Composer {
    if (!isset($this->composer)) {
      $this->composer = Factory::create($this->io(), NULL, TRUE);
    }
    return $this->composer;
  }
  
  /**
   * Gets the output from the io() fixture.
   *
   * @return string
   *   Output captured from tests that write to Fixtures::io().
   */
  public function getOutput() : string {
    return $this->io()
      ->getOutput();
  }
  
  /**
   * Gets the path to Scaffold component.
   *
   * Used to inject the component into composer.json files.
   *
   * @return string
   *   Path to the root of this project.
   */
  public abstract function projectRoot() : string;
  
  /**
   * Gets the path to the project fixtures.
   *
   * @return string
   *   Path to project fixtures
   */
  public abstract function allFixturesDir() : string;
  
  /**
   * Gets the path to one particular project fixture.
   *
   * @param string $project_name
   *   The project name to get the path for.
   *
   * @return string
   *   Path to project fixture.
   */
  public function projectFixtureDir(string $project_name) : string {
    $dir = $this->allFixturesDir() . '/' . $project_name;
    if (!is_dir($dir)) {
      throw new \RuntimeException("Requested fixture project {$project_name} that does not exist.");
    }
    return $dir;
  }
  
  /**
   * Gets the path to one particular bin path.
   *
   * @param string $bin_name
   *   The bin name to get the path for.
   *
   * @return string
   *   Path to project fixture.
   */
  public function binFixtureDir(string $bin_name) : string {
    $dir = $this->allFixturesDir() . '/scripts/' . $bin_name;
    if (!is_dir($dir)) {
      throw new \RuntimeException("Requested fixture bin dir {$bin_name} that does not exist.");
    }
    return $dir;
  }
  
  /**
   * Generates a path to a temporary location, but do not create the directory.
   *
   * @param string $prefix
   *   A prefix for the temporary directory name.
   *
   * @return string
   *   Path to temporary directory
   */
  public function tmpDir(string $prefix) : string {
    $prefix .= static::persistentPrefix();
    $tmpDir = sys_get_temp_dir() . '/scaffold-' . $prefix . uniqid(md5($prefix . microtime()), TRUE);
    $this->tmpDirs[] = $tmpDir;
    return $tmpDir;
  }
  
  /**
   * Generates a persistent prefix to use with all of our temporary directories.
   *
   * The presumption is that this should reduce collisions in highly-parallel
   * tests. We prepend the process id to play nicely with phpunit process
   * isolation.
   *
   * @return string
   *   A random string that will remain the same for the entire process run.
   */
  protected static function persistentPrefix() : string {
    if (empty(static::$randomPrefix)) {
      static::$randomPrefix = getmypid() . md5(microtime());
    }
    return static::$randomPrefix;
  }
  
  /**
   * Creates a temporary directory.
   *
   * @param string $prefix
   *   A prefix for the temporary directory name.
   *
   * @return string
   *   Path to temporary directory
   */
  public function mkTmpDir(string $prefix) : string {
    $tmpDir = $this->tmpDir($prefix);
    $filesystem = new Filesystem();
    $filesystem->ensureDirectoryExists($tmpDir);
    return $tmpDir;
  }
  
  /**
   * Creates an isolated cache directory for Composer.
   */
  public function createIsolatedComposerCacheDir() : void {
    $cacheDir = $this->mkTmpDir('composer-cache');
    putenv("COMPOSER_CACHE_DIR={$cacheDir}");
  }
  
  /**
   * Calls 'tearDown' in any test that copies fixtures to transient locations.
   */
  public function tearDown() : void {
    // Remove any temporary directories that were created.
    $filesystem = new Filesystem();
    foreach ($this->tmpDirs as $dir) {
      $filesystem->remove($dir);
    }
    // Clear out variables from the previous pass.
    $this->tmpDirs = [];
    $this->io = NULL;
    // Clear the composer cache dir, if it was set
    putenv('COMPOSER_CACHE_DIR=');
  }
  
  /**
   * Creates a temporary copy of all of the fixtures projects into a temp dir.
   *
   * The fixtures remain dirty if they already exist. Individual tests should
   * first delete any fixture directory that needs to remain pristine. Since all
   * temporary directories are removed in tearDown, this is only an issue when
   * a) the FIXTURE_DIR environment variable has been set, or b) tests are
   * calling cloneFixtureProjects more than once per test method.
   *
   * @param string $fixturesDir
   *   The directory to place fixtures in.
   * @param array $replacements
   *   Key : value mappings for placeholders to replace in composer.json
   *   templates.
   */
  public function cloneFixtureProjects(string $fixturesDir, array $replacements = []) : void {
    $filesystem = new Filesystem();
    // We will replace 'SYMLINK' with the string 'true' in our composer.json
    // fixture.
    $replacements += [
      'SYMLINK' => 'true',
    ];
    $interpolator = new Interpolator('__', '__');
    $interpolator->setData($replacements);
    $filesystem->copy($this->allFixturesDir(), $fixturesDir);
    $composer_json_templates = glob($fixturesDir . "/*/composer.json.tmpl");
    foreach ($composer_json_templates as $composer_json_tmpl) {
      // Inject replacements into composer.json.
      if (file_exists($composer_json_tmpl)) {
        $composer_json_contents = file_get_contents($composer_json_tmpl);
        $composer_json_contents = $interpolator->interpolate($composer_json_contents, [], FALSE);
        file_put_contents(dirname($composer_json_tmpl) . "/composer.json", $composer_json_contents);
        @unlink($composer_json_tmpl);
      }
    }
  }
  
  /**
   * Runs a `composer` command.
   *
   * @param string $cmd
   *   The Composer command to execute (escaped as required)
   * @param string $cwd
   *   The current working directory to run the command from.
   *
   * @return string
   *   Standard output and standard error from the command.
   */
  public function runComposer(string $cmd, string $cwd) : string {
    chdir($cwd);
    $input = new StringInput($cmd);
    $output = new BufferedOutput();
    $application = new Application();
    $application->setAutoExit(FALSE);
    $exitCode = $application->run($input, $output);
    $output = $output->fetch();
    if ($exitCode != 0) {
      throw new \Exception("Fixtures::runComposer failed to set up fixtures.\n\nCommand: '{$cmd}'\nExit code: {$exitCode}\nOutput: \n\n{$output}");
    }
    return $output;
  }

}