<?php

use Drush\Log\LogLevel;

/**
 * No bootstrap.
 *
 * Commands that only preflight, but do not bootstrap, should use
 * a bootstrap level of DRUSH_BOOTSTRAP_NONE.
 */
define('DRUSH_BOOTSTRAP_NONE', -1);

/**
 * Use drush_bootstrap_max instead of drush_bootstrap_to_phase
 *
 * This constant is only usable as the value of the 'bootstrap'
 * item of a command object, or as the parameter to
 * drush_bootstrap_to_phase.  It is not a real bootstrap state.
 */
define('DRUSH_BOOTSTRAP_MAX', -2);

/**
 * @deprecated
 *
 * No longer used, but 0 remains reserved. Drush always runs preflight.
 * Commands may alternatively use DRUSH_BOOTSTRAP_NONE.
 */
define('DRUSH_BOOTSTRAP_DRUSH', 0);

// TODO: Move all of the constants below to a Drupal-specific file.
// We can't do this until commands are declaring which CMS they work
// with, because right now, commands that do not declare a 'bootstrap'
// level default to DRUSH_BOOTSTRAP_DRUPAL_LOGIN, so we need this constant,
// at least, available in non-Drupal contexts.

/**
 * Set up and test for a valid drupal root, either through the -r/--root options,
 * or evaluated based on the current working directory.
 *
 * Any code that interacts with an entire Drupal installation, and not a specific
 * site on the Drupal installation should use this bootstrap phase.
 */
define('DRUSH_BOOTSTRAP_DRUPAL_ROOT',  1);

/**
 * Set up a Drupal site directory and the correct environment variables to
 * allow Drupal to find the configuration file.
 *
 * If no site is specified with the -l / --uri options, Drush will assume the
 * site is 'default', which mimics Drupal's behaviour.
 *
 * If you want to avoid this behaviour, it is recommended that you use the
 * DRUSH_BOOTSTRAP_DRUPAL_ROOT bootstrap phase instead.
 *
 * Any code that needs to modify or interact with a specific Drupal site's
 * settings.php file should bootstrap to this phase.
 */
define('DRUSH_BOOTSTRAP_DRUPAL_SITE', 2);

/**
 * Load the settings from the Drupal sites directory.
 *
 * This phase is analagous to the DRUPAL_BOOTSTRAP_CONFIGURATION bootstrap phase in Drupal
 * itself, and this is also the first step where Drupal specific code is included.
 *
 * This phase is commonly used for code that interacts with the Drupal install API,
 * as both install.php and update.php start at this phase.
 */
define('DRUSH_BOOTSTRAP_DRUPAL_CONFIGURATION', 3);

/**
 * Connect to the Drupal database using the database credentials loaded
 * during the previous bootstrap phase.
 *
 * This phase is analogous to the DRUPAL_BOOTSTRAP_DATABASE bootstrap phase in
 * Drupal.
 *
 * Any code that needs to interact with the Drupal database API needs to
 * be bootstrapped to at least this phase.
 */
define('DRUSH_BOOTSTRAP_DRUPAL_DATABASE', 4);

/**
 * Fully initialize Drupal.
 *
 * This is analogous to the DRUPAL_BOOTSTRAP_FULL bootstrap phase in
 * Drupal.
 *
 * Any code that interacts with the general Drupal API should be
 * bootstrapped to this phase.
 */
define('DRUSH_BOOTSTRAP_DRUPAL_FULL', 5);

/**
 * Log in to the initialiased Drupal site.
 *
 * This is the default bootstrap phase all commands will try to reach,
 * unless otherwise specified.
 *
 * This bootstrap phase is used after the site has been
 * fully bootstrapped.
 *
 * This phase will log you in to the drupal site with the username
 * or user ID specified by the --user/ -u option.
 *
 * Use this bootstrap phase for your command if you need to have access
 * to information for a specific user, such as listing nodes that might
 * be different based on who is logged in.
 */
define('DRUSH_BOOTSTRAP_DRUPAL_LOGIN', 6);

/**
 * Return the list of bootstrap objects that are available for
 * initializing a CMS with Drush.  We insure that any given candidate
 * class is instantiated only once.
 *
 * @return \Drush\Boot\Boot[]
 */
function drush_get_bootstrap_candidates() {
  $candidate_classes = drush_get_bootstrap_candidate_classnames();

  $cache =& drush_get_context('DRUSH_BOOTSTRAP_CANDIDATE_OBJECTS');

  $result = array();
  foreach($candidate_classes as $candidate_class) {
    if (array_key_exists($candidate_class, $cache)) {
      $result[$candidate_class] = $cache[$candidate_class];
    }
    else {
      $result[$candidate_class] = new $candidate_class;
    }
  }

  $cache = $result;
  return $result;
}

/**
 * Find the list of bootstrap classnames available for initializing a
 * CMS with Drush.
 *
 * @return array
 */
function drush_get_bootstrap_candidate_classnames() {
  // Give all commandfiles a chance to return candidates.  They should
  // return STRINGS with the class name of the bootstrap object they provide.
  $candidates = drush_command_invoke_all('bootstrap_candidates');
  // If a bootstrap class was specified on the command line, consider it first.
  $bootstrap_class = drush_get_option('bootstrap_class', FALSE);
  if ($bootstrap_class) {
    array_unshift($candidates, $bootstrap_class);
  }
  // Add candidate bootstrap classes for Drupal
  foreach (array('8', '7', '6') as $version) {
    $drupal_bootstrap_class = 'Drush\Boot\DrupalBoot' . $version;
    $candidates[] = $drupal_bootstrap_class;
  }
  // Always consider our default bootstrap class last.
  $candidates[] = 'Drush\Boot\EmptyBoot';

  return $candidates;
}

/**
 * Look up the best bootstrap class for the given location
 * from the set of available candidates.
 */
function drush_bootstrap_class_for_root($path) {
  drush_load_bootstrap_commandfile_at_path($path);
  $candidates = drush_get_bootstrap_candidates();
  foreach ($candidates as $candidate) {
    if ($candidate->valid_root($path)) {
      return $candidate;
    }
  }
  return NULL;
}

/**
 * Check to see if there is a bootstrap class available
 * at the specified location; if there is, load it.
 */
function drush_load_bootstrap_commandfile_at_path($path) {
  static $paths = array();

  if (!empty($path) && (!array_key_exists($path, $paths))) {
    $paths[$path] = TRUE;
    // Check to see if we have any bootstrap classes in this location.
    $bootstrap_class_dir = $path . '/drush/bootstrap';
    if (is_dir($bootstrap_class_dir)) {
      _drush_add_commandfiles(array($bootstrap_class_dir), DRUSH_BOOTSTRAP_NONE);
    }
  }
}

/**
 * Select the bootstrap class to use.  If this is called multiple
 * times, the bootstrap class returned might change on subsequent
 * calls, if the root directory changes.  Once the bootstrap object
 * starts changing the state of the system, however, it will
 * be 'latched', and further calls to drush_select_bootstrap_class()
 * will always return the same object.
 */
function drush_select_bootstrap_class() {
  $root = drush_get_context('DRUSH_SELECTED_DRUPAL_ROOT');

  // Once we have selected a Drupal root, we will reduce our bootstrap
  // candidates down to just the one used to select this site root.
  $bootstrap = drush_bootstrap_class_for_root($root);
  // If we have not found a bootstrap class by this point,
  // then take the last one and use it.  This should be our
  // default bootstrap class.  The default bootstrap class
  // should pass through all calls without doing anything that
  // changes state in a CMS-specific way.
  if ($bootstrap == NULL) {
    $candidates = drush_get_bootstrap_candidates();
    $bootstrap = array_pop($candidates);
  }

  return $bootstrap;
}

/**
 * Don't allow the bootstrap object to change once we start bootstrapping
 */
function drush_latch_bootstrap_object($bootstrap) {
  drush_set_context('DRUSH_BOOTSTRAP_OBJECT', $bootstrap);
}

/**
 * Get the appropriate bootstrap object.  We'll search for a new
 * bootstrap object every time someone asks for one until we start
 * bootstrapping; then we'll returned the same cached one every time.
 *
 * @return \Drush\Boot\Boot
 */
function drush_get_bootstrap_object() {
  $bootstrap = drush_get_context('DRUSH_BOOTSTRAP_OBJECT', FALSE);
  if (!$bootstrap) {
    $bootstrap = drush_select_bootstrap_class();
  }
  return $bootstrap;
}

/**
 * Find the URI that has been selected by the cwd
 * if it was not previously set via the --uri / -l option
 */
function _drush_bootstrap_selected_uri() {
  $uri = drush_get_context('DRUSH_SELECTED_URI');
  if (empty($uri)) {
    $site_path = drush_site_path();
    $elements = explode('/', $site_path);
    $current = array_pop($elements);
    if (!$current) {
      $current = 'default';
    }
    $uri = 'http://'. $current;
    $uri = drush_set_context('DRUSH_SELECTED_URI', $uri);
    drush_sitealias_create_self_alias();
  }

  return $uri;
}

/**
 * Helper function to store any context settings that are being validated.
 */
function drush_bootstrap_value($context, $value = null) {
  $values =& drush_get_context('DRUSH_BOOTSTRAP_VALUES', array());

  if (isset($value)) {
    $values[$context] = $value;
  }

  if (array_key_exists($context, $values)) {
    return $values[$context];
  }

  return null;
}

/**
 * Returns an array that determines what bootstrap phases
 * are necessary to bootstrap the CMS.
 *
 * @param bool $function_names
 *   (optional) If TRUE, return an array of method names index by their
 *   corresponding phase values. Otherwise return an array of phase values.
 *
 * @return array
 *
 * @see \Drush\Boot\Boot::bootstrap_phases()
 */
function _drush_bootstrap_phases($function_names = FALSE) {
  $result = array();

  if ($bootstrap = drush_get_bootstrap_object()) {
    $result = $bootstrap->bootstrap_phases();
    if (!$function_names) {
      $result = array_keys($result);
    }
  }
  return $result;
}

/**
 * Bootstrap Drush to the desired phase.
 *
 * This function will sequentially bootstrap each
 * lower phase up to the phase that has been requested.
 *
 * @param int $phase
 *   The bootstrap phase to bootstrap to.
 * @param int $phase_max
 *   (optional) The maximum level to boot to. This does not have a use in this
 *   function itself but can be useful for other code called from within this
 *   function, to know if e.g. a caller is in the process of booting to the
 *   specified level. If specified, it should never be lower than $phase.
 *
 * @return bool
 *   TRUE if the specified bootstrap phase has completed.
 *
 * @see \Drush\Boot\Boot::bootstrap_phases()
 */
function drush_bootstrap($phase, $phase_max = FALSE) {
  $bootstrap = drush_get_bootstrap_object();
  $phases = _drush_bootstrap_phases(TRUE);
  $result = TRUE;

  // If the requested phase does not exist in the list of available
  // phases, it means that the command requires bootstrap to a certain
  // level, but no site root could be found.
  if (!isset($phases[$phase])) {
    $result = drush_bootstrap_error('DRUSH_NO_SITE', dt("We could not find an applicable site for that command."));
  }

  // Once we start bootstrapping past the DRUSH_BOOTSTRAP_DRUSH phase, we
  // will latch the bootstrap object, and prevent it from changing.
  if ($phase > DRUSH_BOOTSTRAP_DRUSH) {
    drush_latch_bootstrap_object($bootstrap);
  }

  drush_set_context('DRUSH_BOOTSTRAPPING', TRUE);
  foreach ($phases as $phase_index => $current_phase) {
    $bootstrapped_phase = drush_get_context('DRUSH_BOOTSTRAP_PHASE', -1);
    if ($phase_index > $phase) {
      break;
    }
    if ($phase_index > $bootstrapped_phase) {
      if ($result = drush_bootstrap_validate($phase_index)) {
        if (method_exists($bootstrap, $current_phase) && !drush_get_error()) {
          drush_log(dt("Drush bootstrap phase : !function()", array('!function' => $current_phase)), LogLevel::BOOTSTRAP);
          $bootstrap->{$current_phase}();

          // Reset commandfile cache and find any new command files that are available during this bootstrap phase.
          drush_get_commands(TRUE);
          _drush_find_commandfiles($phase_index, $phase_max);
        }
        drush_set_context('DRUSH_BOOTSTRAP_PHASE', $phase_index);
      }
    }
  }
  drush_set_context('DRUSH_BOOTSTRAPPING', FALSE);
  if (!$result || drush_get_error()) {
    $errors = drush_get_context('DRUSH_BOOTSTRAP_ERRORS', array());
    foreach ($errors as $code => $message) {
      drush_set_error($code, $message);
    }
  }
  return !drush_get_error();
}

/**
 * Determine whether a given bootstrap phase has been completed
 *
 * This function name has a typo which makes me laugh so we choose not to
 * fix it. Take a deep breath, and smile. See
 * http://en.wikipedia.org/wiki/HTTP_referer
 *
 *
 * @param int $phase
 *   The bootstrap phase to test
 *
 * @return bool
 *   TRUE if the specified bootstrap phase has completed.
 */
function drush_has_boostrapped($phase) {
  $phase_index = drush_get_context('DRUSH_BOOTSTRAP_PHASE');

  return isset($phase_index) && ($phase_index >= $phase);
}

/**
 * Validate whether a bootstrap phase can be reached.
 *
 * This function will validate the settings that will be used
 * during the actual bootstrap process, and allow commands to
 * progressively bootstrap to the highest level that can be reached.
 *
 * This function will only run the validation function once, and
 * store the result from that execution in a local static. This avoids
 * validating phases multiple times.
 *
 * @param int $phase
 *   The bootstrap phase to validate to.
 *
 * @return bool
 *   TRUE if bootstrap is possible, FALSE if the validation failed.
 *
 * @see \Drush\Boot\Boot::bootstrap_phases()
 */
function drush_bootstrap_validate($phase) {
  $bootstrap = drush_get_bootstrap_object();
  $phases = _drush_bootstrap_phases(TRUE);
  static $result_cache = array();

  if (!array_key_exists($phase, $result_cache)) {
    drush_set_context('DRUSH_BOOTSTRAP_ERRORS', array());
    drush_set_context('DRUSH_BOOTSTRAP_VALUES', array());

    foreach ($phases as $phase_index => $current_phase) {
      $validated_phase = drush_get_context('DRUSH_BOOTSTRAP_VALIDATION_PHASE', -1);
      if ($phase_index > $phase) {
        break;
      }
      if ($phase_index > $validated_phase) {
        $current_phase .= '_validate';
        if (method_exists($bootstrap, $current_phase)) {
          $result_cache[$phase_index] = $bootstrap->{$current_phase}();
        }
        else {
          $result_cache[$phase_index] = TRUE;
        }
        drush_set_context('DRUSH_BOOTSTRAP_VALIDATION_PHASE', $phase_index);
      }
    }
  }
  return $result_cache[$phase];
}

/**
 * Bootstrap to the specified phase.
 *
 * @param int $max_phase_index
 *   Only attempt bootstrap to the specified level.
 *
 * @return bool
 *   TRUE if the specified bootstrap phase has completed.
 */
function drush_bootstrap_to_phase($max_phase_index) {
  if ($max_phase_index == DRUSH_BOOTSTRAP_MAX) {
    // Bootstrap as far as we can without throwing an error, but log for
    // debugging purposes.
    drush_log(dt("Trying to bootstrap as far as we can."), 'debug');
    drush_bootstrap_max();
    return TRUE;
  }

  drush_log(dt("Bootstrap to phase !phase.", array('!phase' => $max_phase_index)), LogLevel::BOOTSTRAP);
  $phases = _drush_bootstrap_phases();
  $result = TRUE;

  // Try to bootstrap to the maximum possible level, without generating errors
  foreach ($phases as $phase_index) {
    if ($phase_index > $max_phase_index) {
      // Stop trying, since we achieved what was specified.
      break;
    }

    if (drush_bootstrap_validate($phase_index)) {
      if ($phase_index > drush_get_context('DRUSH_BOOTSTRAP_PHASE', DRUSH_BOOTSTRAP_NONE)) {
        $result = drush_bootstrap($phase_index, $max_phase_index);
      }
    }
    else {
      $result = FALSE;
      break;
    }
  }

  return $result;
}

/**
 * Bootstrap to the highest level possible, without triggering any errors.
 *
 * @param int $max_phase_index
 *   (optional) Only attempt bootstrap to the specified level.
 *
 * @return int
 *   The maximum phase to which we bootstrapped.
 */
function drush_bootstrap_max($max_phase_index = FALSE) {
  $phases = _drush_bootstrap_phases(TRUE);
  if (!$max_phase_index) {
    $max_phase_index = count($phases);
  }

  // Try to bootstrap to the maximum possible level, without generating errors.
  foreach ($phases as $phase_index => $current_phase) {
    if ($phase_index > $max_phase_index) {
      // Stop trying, since we achieved what was specified.
      break;
    }

    if (drush_bootstrap_validate($phase_index)) {
      if ($phase_index > drush_get_context('DRUSH_BOOTSTRAP_PHASE')) {
        drush_bootstrap($phase_index, $max_phase_index);
      }
    }
    else {
      // drush_bootstrap_validate() only logs successful validations. For us,
      // knowing what failed can also be important.
      $previous = drush_get_context('DRUSH_BOOTSTRAP_PHASE');
      drush_log(dt("Bootstrap phase !function() failed to validate; continuing at !current().", array('!function' => $current_phase, '!current' => $phases[$previous])), 'debug');
      break;
    }
  }

  return drush_get_context('DRUSH_BOOTSTRAP_PHASE');
}

/**
 * Bootstrap the specified site alias.  The site alias must
 * be a valid alias to a local site.
 *
 * @param $site_record
 *   The alias record for the given site alias.
 *   @see drush_sitealias_get_record().
 * @param $max_phase_index
 *   Only attempt bootstrap to the specified level.
 * @returns TRUE if attempted to bootstrap, or FALSE
 *   if no bootstrap attempt was made.
 */
function drush_bootstrap_max_to_sitealias($site_record, $max_phase_index = NULL) {
  if ((array_key_exists('root', $site_record) && !array_key_exists('remote-host', $site_record))) {
    drush_sitealias_set_alias_context($site_record);
    drush_bootstrap_max($max_phase_index);
    return TRUE;
  }
  return FALSE;
}

/**
 * Helper function to collect any errors that occur during the bootstrap process.
 * Always returns FALSE, for convenience.
 */
function drush_bootstrap_error($code, $message = null) {
  $errors = drush_get_context('DRUSH_BOOTSTRAP_ERRORS');
  $errors[$code] = $message;
  drush_set_context('DRUSH_BOOTSTRAP_ERRORS', $errors);
  return FALSE;
}

function _drush_bootstrap_output_prepare() {
  // Note that as soon as we set the DRUSH_BACKEND context, we change
  // the behavior of drush_log().  It is therefore important that we
  // should not set this context until immediately before we call ob_start
  // (i.e., in this function).
  $backend = drush_set_context('DRUSH_BACKEND', drush_get_option('backend'));
  $quiet = drush_get_context('DRUSH_QUIET');

  if ($backend) {
    // Load options passed as a JSON encoded string through STDIN.
    $stdin_options = _drush_backend_get_stdin();
    if (is_array($stdin_options)) {
      drush_set_context('stdin', $stdin_options);
    }
    // Add an output buffer handler to collect output/pass through backend
    // packets. Using a chunksize of 2 ensures that each line is flushed
    // straight away.
    if ($quiet) {
      // Pass through of backend packets, discard regular output.
      ob_start('drush_backend_output_discard', 2);
    }
    else {
      // Collect output.
      ob_start('drush_backend_output_collect', 2);
    }
  }

  // In non-backend quiet mode we start buffering and discards it on command
  // completion.
  if ($quiet && !$backend) {
    ob_start();
  }
}

/**
 * Used by a Drush extension to request that its Composer autoload
 * files be loaded by Drush, if they have not already been.
 *
 * Usage:
 *
 * function mycommandfile_drush_init() {
 *   drush_autoload(__FILE__)
 * }
 *
 */
function drush_autoload($commandfile) {
  $already_added = commandfiles_cache()->add($commandfile);

  $dir = dirname($commandfile);
  $candidates = array("vendor/autoload.php", "../../../vendor/autoload.php");
  $drush_autoload_file = drush_get_context('DRUSH_VENDOR_PATH', '');

  foreach ($candidates as $candidate) {
    $autoload = $dir . '/' . $candidate;
    if (file_exists($autoload) && (realpath($autoload) != $drush_autoload_file)) {
      include $autoload;
    }
  }
}