<?php

/**
 * Expose blocks as context reactions.
 */
class context_reaction_block extends context_reaction {
  /**
   * Options form.
   */
  function options_form($context) {
    // Rebuild the block info cache if necessary.
    $this->get_blocks(NULL, NULL, $this->rebuild_needed());
    $this->rebuild_needed(FALSE);

    $theme_key = variable_get('theme_default', 'garland');
    $weight_delta = $this->max_block_weight();

    $form = array(
      '#tree' => TRUE,
      '#theme' => 'context_block_form',
      'max_block_weight' => array(
        '#value' => $weight_delta,
        '#type' => 'value',
      ),
      'state' => array(
        '#type' => 'hidden',
        '#attributes' => array('class' => 'context-blockform-state'),
      ),
    );

    /**
     * Selector.
     */
    $modules = module_list();
    $form['selector'] = array(
      '#type' => 'item',
      '#tree' => TRUE,
      '#prefix' => '<div class="context-blockform-selector">',
      '#suffix' => '</div>',
    );
    foreach ($this->get_blocks() as $block) {
      $group = isset($block->context_group) ? $block->context_group : $block->module;
      if (!isset($form['selector'][$group])) {
        $form['selector'][$group] = array(
          '#type' => 'fieldset',
          '#collapsible' => TRUE, 
          '#collapsed' => TRUE,
          '#title' => isset($block->context_group) ? $block->context_group : $modules[$block->module],
        );
        $form['selector'][$group]['checkboxes'] = array(
          '#type' => 'checkboxes',
          '#options' => array(),
        );
      }
      $form['selector'][$group]['checkboxes']['#options'][$block->bid] = check_plain($block->info);
    }

    ksort($form['selector']);

    /**
     * Regions.
     */
    $form['blocks'] = array(
      '#tree' => TRUE,
      '#theme' => 'context_block_regions_form',
    );
    foreach ($this->system_region_list($theme_key, REGIONS_VISIBLE) as $region => $label) {
      $form['blocks'][$region] = array(
        '#type' => 'item',
        '#title' => $label,
        '#tree' => TRUE,
      );
      foreach ($this->get_blocks($region, $context) as $block) {
        if (!empty($block->context)) {
          $form['blocks'][$region][$block->bid] = array(
            '#value' => check_plain($block->info),
            '#weight' => $block->weight,
            '#type' => 'markup',
            '#tree' => TRUE,
            'weight' => array('#type' => 'weight', '#delta' => $weight_delta, '#default_value' => $block->weight),
          );
        }
      }
    }
    return $form;
  }

  /**
   * Options form submit handler.
   */
  function options_form_submit($values) {
    $blocks = array();
    $block_info = $this->get_blocks();

    // Retrieve blocks from submitted JSON string.
    if (!empty($values['state'])) {
      $edited = $this->json_decode($values['state']);
    }
    else {
      $edited = array();
    }

    foreach ($edited as $region => $block_data) {
      foreach ($block_data as $position => $data) {
        if (isset($block_info[$data->bid])) {
          $blocks[$data->bid] = array(
            'module' => $block_info[$data->bid]->module,
            'delta' => $block_info[$data->bid]->delta,
            'region' => $region,
            'weight' => $data->weight,
          );
        }
      }
    }
    return array('blocks' => $blocks);
  }

  /**
   * Context editor form for blocks.
   */
  function editor_form($context) {
    $form = array();
    drupal_add_library('system', 'ui.droppable');
    drupal_add_library('system', 'ui.sortable');
    drupal_add_js(drupal_get_path('module', 'context_ui') . '/json2.js');
    drupal_add_js(drupal_get_path('module', 'context_ui') . '/theme/filter.js');
    drupal_add_js(drupal_get_path('module', 'context') . '/plugins/context_reaction_block.js');
    drupal_add_css(drupal_get_path('module', 'context') . '/plugins/context_reaction_block.css');

    // We might be called multiple times so use a static to ensure this is set just once.
    static $once;
    if (!isset($once)) {
      $settings = array(
        'path' => drupal_is_front_page() ? base_path() : url($_GET['q']),
        'params' => (object) array_diff_key($_GET, array('q' => '')),
        'scriptPlaceholder' => theme('context_block_script_placeholder', array('text' => '')),
      );
      drupal_add_js(array('contextBlockEditor' => $settings), 'setting');
      $once = TRUE;
    }

    $form['state'] = array(
      '#type' => 'hidden',
      '#attributes' => array('class' => array('context-block-editor-state')),
    );
    $form['browser'] = array(
      '#markup' => theme('context_block_browser', array(
        'blocks' => $this->get_blocks(NULL, NULL, $this->rebuild_needed()),
        'context' => $context
      )),
    );
    $this->rebuild_needed(FALSE);
    return $form;
  }

  /**
   * Submit handler context editor form.
   */
  function editor_form_submit(&$context, $values) {
    $edited = !empty($values['state']) ? (array) $this->json_decode($values['state']) : array();

    $options = array();

    // Take the existing context values and remove blocks that belong affected regions.
    $affected_regions = array_keys($edited);
    if (!empty($context->reactions['block']['blocks'])) {
      $options = $context->reactions['block'];
      foreach ($options['blocks'] as $key => $block) {
        if (in_array($block['region'], $affected_regions)) {
          unset($options['blocks'][$key]);
        }
      }
    }

    // Iterate through blocks and add in the ones that belong to the context.
    foreach ($edited as $region => $blocks) {
      foreach ($blocks as $weight => $block) {
        if ($block->context === $context->name) {
          $split = explode('-', $block->bid);
          $options['blocks'][$block->bid] = array(
            'module' => array_shift($split),
            'delta' => implode('-', $split),
            'region' => $region,
            'weight' => $weight,
          );
        }
      }
    }

    return $options;
  }

  /**
   * Settings form for variables.
   */
  function settings_form() {
    $form = array();
    $form['context_reaction_block_all_regions'] = array(
      '#title' => t('Show all regions'),
      '#type' => 'checkbox',
      '#default_value' => variable_get('context_reaction_block_all_regions', FALSE),
      '#description' => t('Show all regions including those that are empty. Enable if you are administering your site using the inline editor.')
    );
    return $form;
  }

  /**
   * Execute.
   */
  function execute(&$page) {
    global $theme;

    // The theme system might not yet be initialized. We need $theme.
    drupal_theme_initialize();

    // If the context_block querystring param is set, switch to AJAX rendering.
    // Note that we check the output buffer for any content to ensure that we
    // are not in the middle of a PHP template render.
    if (isset($_GET['context_block']) && !ob_get_contents()) {
      return $this->render_ajax($_GET['context_block']);
    }

    // Populate all block regions
    $all_regions = $this->system_region_list($theme);

    // Load all region content assigned via blocks.
    foreach (array_keys($all_regions) as $region) {
      if ($this->is_enabled_region($region)) {
        if ($blocks = $this->block_get_blocks_by_region($region)) {

          // Are the blocks already sorted.
          $blocks_sorted = TRUE;

          // If blocks have already been placed in this region (most likely by
          // Block module), then merge in blocks from Context.
          if (isset($page[$region])) {
            $page[$region] = array_merge($page[$region], $blocks);

            // Restore the weights that Block module manufactured
            // @see _block_get_renderable_array()
            foreach ($page[$region] as &$block) {
              if (isset($block['#block']->weight)) {
                $block['#weight'] = $block['#block']->weight;
                $blocks_sorted = FALSE;
              }
            }
          }
          else {
            $page[$region] = $blocks;
          }

          $page[$region]['#sorted'] = $blocks_sorted;
        }
      }
    }
  }

  /**
   * Return a list of enabled regions for which blocks should be built.
   * Split out into a separate method for easy overrides in extending classes.
   */
  protected function is_enabled_region($region) {
    global $theme;
    $regions = array_keys($this->system_region_list($theme));
    return in_array($region, $regions, TRUE);
  }

  /**
   * Determine whether inline editing requirements are met and that the current
   * user may edit.
   */
  protected function is_editable_region($region, $reset = FALSE) {
    // Check requirements.
    // Generally speaking, it does not make sense to allow anonymous users to
    // edit a context inline. Though it may be possible to save (and restore)
    // an edited context to an anonymous user's cookie or session, it's an
    // edge case and probably not something we want to encourage anyway.
    static $requirements;
    if (!isset($requirements) || $reset) {
      global $user;
      if ($user->uid && user_access('administer contexts') && variable_get('context_ui_dialog_enabled', FALSE)) {
        $requirements = TRUE;
        drupal_add_library('system', 'ui.droppable');
        drupal_add_library('system', 'ui.sortable');
        drupal_add_js(drupal_get_path('module', 'context') . '/plugins/context_reaction_block.js');
        drupal_add_css(drupal_get_path('module', 'context') . '/plugins/context_reaction_block.css');
      }
      else {
        $requirements = FALSE;
      }
    }
    // Check that this region is not locked by the theme.
    global $theme;
    $info = system_get_info('theme', $theme);
    if ($info && isset($info['regions_locked']) && in_array($region, $info['regions_locked'])) {
      return FALSE;
    }
    // Check that this region is not hidden
    $visible = $this->system_region_list($theme, REGIONS_VISIBLE);
    return $requirements && $this->is_enabled_region($region) && isset($visible[$region]);
  }

  /**
   * Add markup for making a block editable.
   */
  protected function editable_block($block) {
    if (!empty($block->content)) {
      $block->content['#theme_wrappers'][] = 'context_block_edit_wrap';
    }
    else {
      // the block alter in context.module should ensure that blocks are never
      // empty if the inline editor is present but in the case that they are,
      // warn that editing the context is likely to cause this block to be dropped
      drupal_set_message(t('The block with delta @delta from module @module is not compatible with the inline editor and will be dropped from the context containing it if you edit contexts here', array('@delta' => $block->delta, '@module' => $block->module)), 'warning');
    }
    return $block;
  }

  /**
   * Add markup for making a region editable.
   */
  protected function editable_region($region, $build) {
    if ($this->is_editable_region($region) &&
        (!empty($build) ||
         variable_get('context_reaction_block_all_regions', FALSE) ||
         context_isset('context_ui', 'context_ui_editor_present'))
    ) {
      global $theme;
      $regions = $this->system_region_list($theme);
      $name = isset($regions[$region]) ? $regions[$region] : $region;
      // The negative weight + sorted will push our region marker to the top of the region
      $build['context'] = array(
        '#prefix' => "<div class='context-block-region' id='context-block-region-{$region}'>",
        '#markup' => "<span class='region-name'>{$name}</span>" .
                     "<a class='context-ui-add-link'>" . t('Add a block here.') . '</a>',
        '#suffix' => '</div>',
        '#weight' => -100,
      );
      $build['#sorted'] = FALSE;
    }

    return $build;
  }

  /**
  * Get a renderable array of a region containing all enabled blocks.
  */
  function block_get_blocks_by_region($region) {
    module_load_include('module', 'block', 'block');

    $build = array();
    if ($list = $this->block_list($region)) {
      $build = _block_get_renderable_array($list);
    }
    if ($this->is_editable_region($region)) {
      $build = $this->editable_region($region, $build);
    }
    return $build;
  }

  /**
   * An alternative version of block_list() that provides any context enabled blocks.
   */
  function block_list($region) {
    module_load_include('module', 'block', 'block');

    $context_blocks = &drupal_static('context_reaction_block_list');;
    $contexts = context_active_contexts();
    if (!isset($context_blocks)) {
      $info = $this->get_blocks();
      $context_blocks = array();
      foreach ($contexts as $context) {
        $options = $this->fetch_from_context($context);
        if (!empty($options['blocks'])) {
          foreach ($options['blocks'] as $context_block) {
            $bid = "{$context_block['module']}-{$context_block['delta']}";
            if (isset($info[$bid])) {
              $block = (object) array_merge((array) $info[$bid], $context_block);
              $block->context = $context->name;
              $block->title = isset($info[$block->bid]->title) ? $info[$block->bid]->title : NULL;
              $block->cache = isset($info[$block->bid]->cache) ? $info[$block->bid]->cache : DRUPAL_NO_CACHE;
              $context_blocks[$block->region][$block->bid] = $block;
            }
          }
        }
      }
      
      $this->is_editable_check($context_blocks);
      global $theme;
      $active_regions = $this->system_region_list($theme);
      foreach ($context_blocks as $r => $blocks) {
        //only render blocks in an active region
        if (array_key_exists($r, $active_regions)) {
          $context_blocks[$r] = _block_render_blocks($blocks);

          // Make blocks editable if allowed.
          if ($this->is_editable_region($r)) {
            foreach ($context_blocks[$r] as $key => $block) {
              $context_blocks[$r][$key] = $this->editable_block($block);
            }
          }
        }

        // Sort blocks.
        uasort($context_blocks[$r], array('context_reaction_block', 'block_sort'));
      }
    }
    return isset($context_blocks[$region]) ? $context_blocks[$region] : array();
  }

  /**
   * Determine if there is an active context editor block, and set a flag.  We will set a flag so 
   * that we can make sure that blocks with empty content have some default content.  This is
   * needed so the save of the context inline editor does not remove the blocks with no content.
   */
  function is_editable_check($context_blocks) {
    foreach ($context_blocks as $r => $blocks) {
      if (isset($blocks['context_ui-editor'])) {
        $block = $blocks['context_ui-editor'];
        // see if the editor is actually enabled, lifted from _block_render_blocks
        if (!count(module_implements('node_grants')) && ($_SERVER['REQUEST_METHOD'] == 'GET' || $_SERVER['REQUEST_METHOD'] == 'HEAD') && ($cid = _block_get_cache_id($block)) && ($cache = cache_get($cid, 'cache_block'))) {
          $array = $cache->data;
        }
        else {
          $array = module_invoke($block->module, 'block_view', $block->delta);
          drupal_alter(array('block_view', "block_view_{$block->module}_{$block->delta}"), $array, $block);
        }
        if(!empty($array['content'])) {
          context_set('context_ui', 'context_ui_editor_present', TRUE);
        }
        break;
      }
    }
  }
  
  /**
   * Generate the safe weight range for a block being added to a region such that
   * there are enough potential unique weights to support all blocks.
   */
  protected function max_block_weight() {
    $blocks = $this->get_blocks();
    $block_count = 0;
    foreach ($blocks as $region => $block_list) {
      $block_count += count($block_list);
    }
    // Add 2 to make sure there's space at either end of the block list
    return round(($block_count + 2) / 2);
  }

  /**
   * Check or set whether a rebuild of the block info cache is needed.
   */
  function rebuild_needed($set = NULL) {
    if (isset($set) && $set != variable_get('context_block_rebuild_needed', FALSE)) {
      variable_set('context_block_rebuild_needed', $set);
    }
    return (bool) variable_get('context_block_rebuild_needed', FALSE);
  }

  /**
   * Helper function to generate a list of blocks from a specified region. If provided a context object,
   * will generate a full list of blocks for that region distinguishing between system blocks and
   * context-provided blocks.
   *
   * @param $region
   *   The string identifier for a theme region. e.g. "left"
   * @param $context
   *   A context object.
   *
   * @return
   *   A keyed (by "module_delta" convention) array of blocks.
   */
  function get_blocks($region = NULL, $context = NULL, $reset = FALSE) {
    static $block_info;
    $theme_key = variable_get('theme_default', 'garland');

    if (!isset($block_info) || $reset) {
      $block_info = array();
      if (!$reset) {
        $block_info = context_cache_get('block_info');
      }
      if (empty($block_info)) {
        if (module_exists('block')) {
          $block_blocks = _block_rehash($theme_key);
          $block_info = array();
          // Change from numeric keys to module-delta.
          foreach ($block_blocks as $block) {
            $block = (object) $block;
            unset($block->theme, $block->status, $block->weight, $block->region, $block->custom, $block->visibility, $block->pages);
            $block->bid = "{$block->module}-{$block->delta}";
            $block_info[$block->bid] = $block;
          }
        }
        else {
          $block_info = array();
          foreach (module_implements('block_info') as $module) {
            $module_blocks = module_invoke($module, 'block_info');
            if (!empty($module_blocks)) {
              foreach ($module_blocks as $delta => $block) {
                $block = (object) $block;
                $block->module = $module;
                $block->delta = $delta;
                $block->bid = "{$block->module}-{$block->delta}";
                $block_info[$block->bid] = $block;
              }
            }
          }
        }
        context_cache_set('block_info', $block_info);
      }
      // Allow other modules that may declare blocks dynamically to alter
      // this list.
      drupal_alter('context_block_info', $block_info);

      // Gather only region info from the database.
      if (module_exists('block')) {
        $result = db_select('block')
          ->fields('block')
          ->condition('theme', $theme_key)
          ->execute()
          ->fetchAllAssoc('bid');

        drupal_alter('block_list', $result);
        drupal_alter('context_block_list', $result);

        foreach ($result as $row) {
          if (isset($block_info["{$row->module}-{$row->delta}"])) {
            $block_info["{$row->module}-{$row->delta}"] = (object) array_merge((array) $row, (array) $block_info["{$row->module}-{$row->delta}"]);
            unset($block_info["{$row->module}-{$row->delta}"]->status);
            unset($block_info["{$row->module}-{$row->delta}"]->visibility);
          }
        }
      }
    }

    $blocks = array();

    // No region specified, provide all blocks.
    if (!isset($region)) {
      $blocks = $block_info;
    }
    // Region specified.
    else {
      foreach ($block_info as $bid => $block) {
        if (isset($block->region) && $block->region == $region) {
          $blocks[$bid] = $block;
        }
      }
    }

    // Add context blocks if provided.
    if (is_object($context) && $options = $this->fetch_from_context($context)) {
      if (!empty($options['blocks'])) {
        foreach ($options['blocks'] as $block) {
          if (
            isset($block_info["{$block['module']}-{$block['delta']}"]) && // Block is valid.
            (!isset($region) || (!empty($region) && $block['region'] == $region)) // No region specified or regions match.
          ) {
            $context_block = $block_info["{$block['module']}-{$block['delta']}"];
            $context_block->weight = $block['weight'];
            $context_block->region = $block['region'];
            $context_block->context = !empty($context->name) ? $context->name : 'tempname';
            $blocks[$context_block->bid] = $context_block;
          }
        }
      }
      uasort($blocks, array('context_reaction_block', 'block_sort'));
    }
    return $blocks;
  }

  /**
   * Sort callback.
   */
  static function block_sort($a, $b) {
    return ($a->weight - $b->weight);
  }

  /**
   * Compatibility wrapper around json_decode().
   */
  protected function json_decode($json, $assoc = FALSE) {
    // Requires PHP 5.2.
    if (function_exists('json_decode')) {
      return json_decode($json, $assoc);
    }
    else {
      watchdog('context', 'Please upgrade your PHP version to one that supports json_decode.');
    }
  }

  /**
   * Block renderer for AJAX requests. Triggered when $_GET['context_block']
   * is set. See ->execute() for how this is called.
   */
  function render_ajax($param) {
    // Besure the page isn't a 404 or 403.
    $headers = drupal_get_http_header();
    if (array_key_exists('status', $headers) && ($headers['status'] == "404 Not Found" || $headers['status'] == "403 Forbidden")) {
      return;
    }
    // Set the header right away. This will inform any players in the stack
    // that we are in the middle of responding to an AJAX request.
    drupal_add_http_header('Content-Type', 'text/javascript; charset=utf-8');

    if (strpos($param, ',') !== FALSE) {
      list($bid, $context) = explode(',', $param);
      list($module, $delta) = explode('-', $bid, 2);
      // Check token to make sure user has access to block.
      if (!(user_access('administer contexts') || user_access('context ajax block access') || $this->context_block_ajax_rendering_allowed($bid))) {
        echo drupal_json_encode(array('status' => 0));
        exit;
      }

      // Ensure $bid is valid.
      $info = $this->get_blocks();
      if (isset($info[$bid])) {
        module_load_include('module', 'block', 'block');
        $block = $info[$bid];
        $block->title = isset($block->title) ? $block->title : '';
        $block->context = $context;        
        $block->region = '';
        $rendered_blocks = _block_render_blocks(array($block)); // For E_STRICT warning
        $block = array_shift($rendered_blocks);
        if (empty($block->content['#markup'])) {
          $block->content['#markup'] = "<div class='context-block-empty'>" . t('This block appears empty when displayed on this page.') . "</div>";
        }
        $block = $this->editable_block($block);
        $renderable_block = _block_get_renderable_array(array($block)); // For E_STRICT warning
        echo drupal_json_encode(array(
          'status' => 1,
          'block' => drupal_render($renderable_block),
        ));
        drupal_exit();
      }
    }
    echo drupal_json_encode(array('status' => 0));
    drupal_exit();
  }

  /**
   * Provide caching for system_region_list since it can get called
   * frequently. Evaluate for removal once https://drupal.org/node/1873450
   * lands or system_region_list is otherwise cached in core
   */
  protected function system_region_list($theme_key, $show = REGIONS_ALL) {
    static $cache = array();
    if (!isset($cache[$theme_key])) {
      $cache[$theme_key] = array();
    }
    if (!isset($cache[$theme_key][$show])) {
      $cache[$theme_key][$show] = system_region_list($theme_key, $show);
    }
    return $cache[$theme_key][$show];
  }

  /**
   * Allow modules to selectively allow ajax rendering of a specific block
   */
  private function context_block_ajax_rendering_allowed($bid) {
    $allowed = FALSE;
    foreach (module_invoke_all('context_allow_ajax_block_access', $bid) as $module_allow) {
      $allowed = $allow || $module_allow;
      if ($allowed) {
        break;
      }
    }
    return $allowed;
  }
}
