<?php

/**
 * @file
 * Advanced aggregation bundler module.
 */

/**
 * @addtogroup default_variables
 * @{
 */

/**
 * Default for maximum number of CSS bundles used in a themes region.
 */
define('ADVAGG_BUNDLER_MAX_CSS', 2);

/**
 * Default for maximum number of JS bundles used in a themes region.
 */
define('ADVAGG_BUNDLER_MAX_JS', 5);

/**
 * Default of the last used time before the bundle is considered outdated.
 *
 * Value of 1209600 is 2 weeks in seconds.
 */
define('ADVAGG_BUNDLER_OUTDATED', 1209600);

/**
 * Default value to see if the bundler should be active or passive.
 *
 * If it is passive, the bundler will only do analysis and not split up the
 * aggregate.
 */
define('ADVAGG_BUNDLER_ACTIVE', TRUE);

/**
 * Default value to for bundler, set to file size.
 */
define('ADVAGG_BUNDLER_GROUPING_LOGIC', 1);

/**
 * If 4 the admin section gets unlocked.
 */
define('ADVAGG_BUNDLER_ADMIN_MODE', 4);

/**
 * @} End of "addtogroup default_variables".
 */

/**
 * @addtogroup hooks
 * @{
 */

/**
 * Implements hook_menu().
 */
function advagg_bundler_menu() {
  $file_path = drupal_get_path('module', 'advagg_bundler');
  $config_path = advagg_admin_config_root_path();

  $items[$config_path . '/advagg/bundler'] = array(
    'title' => 'Bundler',
    'description' => 'Adjust Bundler settings.',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('advagg_bundler_admin_settings_form'),
    'type' => MENU_LOCAL_TASK,
    'access arguments' => array('administer site configuration'),
    'file path' => $file_path,
    'file' => 'advagg_bundler.admin.inc',
    'weight' => 10,
  );

  return $items;
}

/**
 * Implements hook_advagg_hooks_implemented_alter().
 */
function advagg_bundler_advagg_hooks_implemented_alter(&$hooks, $all) {
  if ($all) {
    $hooks['advagg_bundler_analysis_alter'] = array();
  }
}

/**
 * Implements hook_init().
 */
function advagg_bundler_init() {
  if (advagg_bundler_enabled()) {
    $GLOBALS['conf']['advagg_core_groups'] = FALSE;
  }
}

/**
 * Implements hook_form_FORM_ID_alter().
 */
function advagg_bundler_form_advagg_admin_settings_form_alter(&$form, $form_state) {
  if (advagg_bundler_enabled()) {
    $form['global']['advagg_core_groups']['#disabled'] = TRUE;
    $form['global']['advagg_core_groups']['#description'] = t('The bundler submodule disables core grouping logic.');
    $form['global']['advagg_core_groups']['#states'] = array();
  }
}

/**
 * @} End of "addtogroup hooks".
 */

/**
 * Returns TRUE if the bundler will run.
 */
function advagg_bundler_enabled() {
  if (variable_get('advagg_bundler_active', ADVAGG_BUNDLER_ACTIVE) && (variable_get('advagg_bundler_max_css', ADVAGG_BUNDLER_MAX_CSS) || variable_get('advagg_bundler_max_js', ADVAGG_BUNDLER_MAX_JS))) {
    return TRUE;
  }
}

/**
 * Given a filename return a bundle key.
 *
 * @param string $filename
 *   Filename.
 * @param bool $force
 *   Bypass the cache and get a fresh version of the analysis.
 * @param bool $safesql
 *   Turn off SQL language that might cause errors.
 * @param int $depth
 *   Used to prevent endless loops.
 *
 * @return string
 *   String to be used for the grouping key.
 */
function advagg_bundler_analysis($filename = '', $force = FALSE, $safesql = FALSE, $depth = 0) {
  // Cache query in a static.
  static $analysis = array();
  if (empty($analysis)) {
    // See if we have a cached version of this. Generate cache ID.
    $query = db_select('advagg_aggregates_versions', 'aav')
      ->condition('aav.root', 1)
      ->condition('aav.atime', REQUEST_TIME - max(172800, variable_get('advagg_bundler_outdated', ADVAGG_BUNDLER_OUTDATED), '>'), '>');
    $query->addExpression('COUNT(aggregate_filenames_hash)', 'counter');
    $count = $query->execute()->fetchField();
    $ideal_cid = 'advagg:bundler_analysis:' . $count;

    if (!$force) {
      // Generate cache IDs.
      $counts = range(max(0, $count - 3), $count + 3);
      foreach ($counts as $count) {
        $cache_ids[] = 'advagg:bundler_analysis:' . $count;
      }

      // Get a range of cached bundler_analysis data.
      $cache_hits = cache_get_multiple($cache_ids, 'cache_advagg_aggregates');
      if (!empty($cache_hits)) {
        if (isset($cache_hits[$ideal_cid])) {
          $cache = $cache_hits[$ideal_cid];
        }
        elseif (!$force && module_exists('httprl') && httprl_is_background_callback_capable()) {
          // Setup callback options array.
          $callback_options = array(
            array(
              'function' => 'advagg_bundler_analysis',
            ),
            $filename, TRUE,
          );
          // Queue up the request.
          httprl_queue_background_callback($callback_options);
          // Execute request.
          httprl_send_request();

          // Use most recent bundler_analysis data.
          $max = 0;
          foreach ($cache_hits as $data) {
            if ($data->created > $max) {
              $max = $data->created;
              $cache = $data;
            }
          }
        }
      }
    }

    if ($force || empty($cache->data)) {
      try {
        $analysis = advagg_bundler_analyisis_query($safesql);
        // Save results to the cache.
        cache_set($ideal_cid, $analysis, 'cache_advagg_aggregates', CACHE_TEMPORARY);
      }
      catch (PDOException $e) {
        if ($depth > 2) {
          throw $e;
        }
        $depth++;
        return advagg_bundler_analysis($filename, TRUE, TRUE, $depth);
      }
    }
    else {
      $analysis = $cache->data;
    }
  }

  // If no filename is given pass back then entire query results.
  if (empty($filename)) {
    return $analysis;
  }

  // Return a key to be used in groupings.
  if (!empty($analysis[$filename])) {
    return $analysis[$filename];
  }

  // We need to return a value that can be used as an array key if the query
  // didn't give us anything.
  return 0;
}

/**
 * Run the analysis query and return the analysis array.
 *
 * "Magic Query"; only needs to run once. Results are cached.
 * This is what the raw SQL looks like:
 *
 * @code
 *  SELECT
 *    af.filename AS filename,
 *    af.filesize AS filesize,
 *    af.mtime AS mtime,
 *    af.changes AS changes,
 *    af.linecount AS linecount,
 *    af.filename_hash AS filename_hash,
 *    aa.counter AS counter,
 *    aa.hashlist AS hashlist
 *   FROM advagg_files af
 *   INNER JOIN (
 *    SELECT
 *     aa.filename_hash AS filename_hash,
 *     LPAD(CAST(COUNT(aav.aggregate_filenames_hash) AS char(8)), 8, '0') AS counter,
 *     HEX(SHA1(GROUP_CONCAT(DISTINCT aa.aggregate_filenames_hash ORDER BY aa.aggregate_filenames_hash ASC))) AS hashlist
 *    FROM advagg_aggregates aa
 *    INNER JOIN advagg_aggregates_versions aav
 *     ON aav.aggregate_filenames_hash = aa.aggregate_filenames_hash
 *     AND aav.root = 1
 *     AND aav.atime > (UNIX_TIMESTAMP() - 1209600)
 *    GROUP BY aa.filename_hash
 *   ) aa ON af.filename_hash = aa.filename_hash
 * @endcode
 *
 * @param bool $safesql
 *   Turn off SQL language that might cause errors.
 *
 * @return array
 *   The analysis array.
 */
function advagg_bundler_analyisis_query($safesql) {
  // Return a count of how many root bundles all files are used in. Count is
  // padded with eight zeros so the count can be key sorted as a string
  // without worrying about it getting put in the wrong order.
  // Return the bundle_md5's value; we need something more unique than count
  // when grouping together.
  // Return the filename. Used for lookup.
  // We join the advagg bundles and files together making sure to only use
  // root bundles that have been used in the last 2 weeks. This prevents an
  // old site structure from influencing new bundles.
  // Grouping by the filename gives us the count and makes it so we don't
  // return a lot of rows.
  $db_type = Database::getConnection()->databaseType();
  $schema = Database::getConnection()->schema();
  if ($safesql) {
    $mssql_group_concat = FALSE;
    $mssql_lpad = FALSE;
    $mssql_md5 = FALSE;
    $pg9 = FALSE;
  }
  else {
    $mssql_group_concat = method_exists($schema, 'functionExists') && $schema->functionExists('GROUP_CONCAT');
    $mssql_lpad = method_exists($schema, 'functionExists') && $schema->functionExists('LPAD');
    $mssql_md5 = method_exists($schema, 'functionExists') && $schema->functionExists('MD5');
    if ($db_type === 'pgsql') {
      $database_connection = Database::getConnection();
      $pg9 = FALSE;
      if (version_compare($database_connection->version(), '9') >= 0) {
        $pg9 = TRUE;
      }
    }
  }

  // Create join query for the advagg_aggregates table.
  $subquery_aggregates = db_select('advagg_aggregates', 'aa');

  // Counter column.
  $fields = array('counter');
  if ($db_type === 'sqlsrv' && !$mssql_lpad) {
    // MS SQL does not support LPAD.
    $subquery_aggregates->addExpression("RIGHT(REPLICATE('0',8) + CAST(COUNT(aav.aggregate_filenames_hash) AS char(8)),8)", 'counter');
  }
  elseif ($db_type === 'sqlite') {
    // SQLite does not support LPAD.
    $subquery_aggregates->addExpression("substr('00000000' || CAST(COUNT(aav.aggregate_filenames_hash) AS char(8)), -8, 8)", 'counter');
  }
  else {
    $subquery_aggregates->addExpression("LPAD(CAST(COUNT(aav.aggregate_filenames_hash) AS char(8)), 8, '0')", 'counter');
  }

  // Hashlist column.
  if ($db_type === 'mysql') {
    $fields[] = 'hashlist';
    db_query('SET SESSION group_concat_max_len = 65535');
    $subquery_aggregates->addExpression('HEX(SHA1(GROUP_CONCAT(DISTINCT aa.aggregate_filenames_hash ORDER BY aa.aggregate_filenames_hash ASC)))', 'hashlist');
  }
  elseif ($db_type === 'pgsql') {
    if ($pg9) {
      $fields[] = 'hashlist';
      $subquery_aggregates->addExpression("MD5(STRING_AGG(DISTINCT(aa.aggregate_filenames_hash), ',' ORDER BY aa.aggregate_filenames_hash ASC))", 'hashlist');
    }
  }
  elseif ($db_type === 'sqlite') {
    $fields[] = 'hashlist';
    $subquery_aggregates->addExpression('GROUP_CONCAT(DISTINCT aa.aggregate_filenames_hash)', 'hashlist');
    $subquery_aggregates->orderBy("aa.aggregate_filenames_hash", "ASC");
  }
  elseif ($db_type === 'sqlsrv' && $mssql_group_concat) {
    $fields[] = 'hashlist';
    if ($mssql_md5) {
      $subquery_aggregates->addExpression('MD5(GROUP_CONCAT(DISTINCT aa.aggregate_filenames_hash))', 'hashlist');
    }
    else {
      $subquery_aggregates->addExpression('GROUP_CONCAT(DISTINCT aa.aggregate_filenames_hash)', 'hashlist');
    }
    // The ORDER BY clause is invalid in views, inline functions,
    // derived tables, subqueries, and common table expressions, unless TOP or
    // FOR XML is also specified. So no point in doing an order-by like in the
    // other cases.
  }

  // Create join for the advagg_aggregates_versions table.
  // 1209600 = 2 weeks.
  $time = REQUEST_TIME - max(172800, variable_get('advagg_bundler_outdated', ADVAGG_BUNDLER_OUTDATED), '>');
  $subquery_aggregates->join('advagg_aggregates_versions', 'aav', "aav.aggregate_filenames_hash=aa.aggregate_filenames_hash AND aav.root=1 AND aav.atime > $time");

  $subquery_aggregates = $subquery_aggregates->fields('aa', array('filename_hash'))
    ->groupBy('aa.filename_hash');

  // Create main query for the advagg_files table.
  $af_fields = array(
    'filename',
    'filesize',
    'mtime',
    'changes',
    'linecount',
    'filename_hash',
  );
  // Make drupal_get_installed_schema_version() available.
  include_once DRUPAL_ROOT . '/includes/install.inc';
  if (drupal_get_installed_schema_version('advagg') >= 7211) {
    $af_fields[] = 'filesize_processed';
  }

  $query = db_select('advagg_files', 'af');
  $query->join($subquery_aggregates, 'aa', 'af.filename_hash=aa.filename_hash');
  $query = $query->fields('af', $af_fields)
    ->fields('aa', $fields);
  $query->comment('Query called from ' . __FUNCTION__ . '()');
  $results = $query->execute();

  $analysis = array();
  foreach ($results as $row) {
    // Implement slower GROUP_CONCAT functionality for non mysql databases.
    if (empty($row->hashlist)) {
      $subquery_aggregates_versions = db_select('advagg_aggregates_versions', 'aav')
        ->fields('aav')
        ->condition('aav.root', 1)
        ->condition('aav.atime', REQUEST_TIME - max(172800, variable_get('advagg_bundler_outdated', ADVAGG_BUNDLER_OUTDATED), '>'), '>');

      $subquery_aggregates = db_select('advagg_aggregates', 'aa');
      $subquery_aggregates->join($subquery_aggregates_versions, 'aav', 'aav.aggregate_filenames_hash=aa.aggregate_filenames_hash');
      $subquery_aggregates = $subquery_aggregates->fields('aa', array('aggregate_filenames_hash'))
        ->condition('aa.filename_hash', $row->filename_hash)
        ->groupBy('aa.aggregate_filenames_hash')
        ->orderBy('aa.aggregate_filenames_hash', 'ASC');
      $subquery_aggregates->comment('Query called from ' . __FUNCTION__ . '()');
      $aa_results = $subquery_aggregates->execute();
      $aa_rows = array();
      foreach ($aa_results as $aa_row) {
        $aa_rows[] = $aa_row->aggregate_filenames_hash;
      }
      $row->hashlist = implode(',', $aa_rows);
    }

    $row->hashlist = drupal_hash_base64($row->hashlist);
    $analysis[$row->filename] = array(
      'group_hash' => $row->counter . ' ' . $row->hashlist,
      'mtime' => $row->mtime,
      'filesize' => $row->filesize,
      'filesize_processed' => empty($row->filesize_processed) ? $row->filesize : $row->filesize_processed,
      'linecount' => $row->linecount,
      'changes' => $row->changes,
    );
  }
  arsort($analysis);

  // Invoke hook_advagg_bundler_analysis_alter() to give installed modules a
  // chance to alter the analysis array.
  drupal_alter('advagg_bundler_analysis', $analysis);

  return $analysis;
}