<?php

/**
 * @file
 * Reusable API for l10n remote updates using $source objects
 *
 * These functions may not be safe for the installer as they use variables and report using watchdog
 */

/**
 * Threshold for timestamp comparison.
 *
 * Eliminates a difference between the download time
 * (Database: l10n_update_file.timestamp) and the actual .po file timestamp.
 */
define('L10N_UPDATE_TIMESTAMP_THRESHOLD', 2);

module_load_include('inc', 'l10n_update');

/**
 * Fetch update information for all projects / all languages.
 *
 * @param boolean $refresh
 *   TRUE = refresh the release data.
 *   We refresh anyway if the data is older than a day.
 *
 * @return array
 *   Available releases indexed by project and language.
 */
function l10n_update_available_releases($refresh = FALSE) {
  $frequency = variable_get('l10n_update_check_frequency', 0) * 24 * 3600;
  if (!$refresh && ($cache = cache_get('l10n_update_available_releases', 'cache_l10n_update')) && (!$frequency || $cache->created > REQUEST_TIME - $frequency)) {
    return $cache->data;
  }
  else {
    $projects = l10n_update_get_projects(TRUE);
    $languages = l10n_update_language_list();
    $local = variable_get('l10n_update_check_mode', L10N_UPDATE_CHECK_ALL) & L10N_UPDATE_CHECK_LOCAL;
    $remote = variable_get('l10n_update_check_mode', L10N_UPDATE_CHECK_ALL) & L10N_UPDATE_CHECK_REMOTE;
    $available = l10n_update_check_projects($projects, array_keys($languages), $local, $remote);
    cache_set('l10n_update_available_releases', $available, 'cache_l10n_update', $frequency ? REQUEST_TIME + $frequency : CACHE_PERMANENT);
    return $available;
  }
}

/**
 * Check latest release for project, language.
 *
 * @param $projects
 *   Projects to check (objects).
 * @param $languages
 *   Array of language codes to check, none to check all.
 * @param $check_local
 *   Check local translation file.
 * @param $check_remote
 *   Check remote translation file.
 *
 * @return array
 *   Available sources indexed by project, language.
 */
function l10n_update_check_projects($projects, $languages = NULL, $check_local = TRUE, $check_remote = TRUE) {
  $languages = $languages ? $languages : array_keys(l10n_update_language_list());
  $result = array();
  foreach ($projects as $name => $project) {
    foreach ($languages as $lang) {
      $source = l10n_update_source_build($project, $lang);
      if ($update = l10n_update_source_check($source, $check_local, $check_remote)) {
        $result[$name][$lang] = $update;
      }
    }
  }
  return $result;
}

/**
 * Compare available releases with history and get list of downloadable updates.
 *
 * @param $history
 *   Update history of projects.
 * @param $available
 *   Available project releases.
 * @return array
 *   Projects to be updated: 'not yet downloaded', 'newer timestamp available',
 *   'new version available'.
 *   Up to date projects are not included in the array.
 */
function l10n_update_build_updates($history, $available) {
  $updates = array();
  foreach ($available as $name => $project_updates) {
    foreach ($project_updates as $lang => $update) {
      if (!empty($update->timestamp)) {
        $current = !empty($history[$name][$lang]) ? $history[$name][$lang] : NULL;
        // Add when not current, timestamp newer or version difers (newer version)
        if (_l10n_update_source_compare($current, $update) == -1 || $current->version != $update->version) {
          $updates[$name][$lang] = $update;
        }
      }
    }
  }
  return $updates;
}

/**
 * Check updates for active projects and languages.
 *
 * @param $count
 *   Number of package translations to check.
 * @param $before
 *   Unix timestamp, check only updates that haven't been checked for this time.
 * @param $limit
 *   Maximum number of updates to do. We check $count translations
 *   but we stop after we do $limit updates.
 * @return array
 */
function l10n_update_check_translations($count, $before, $limit = 1) {
  $projects = l10n_update_get_projects();
  $updated = $checked = array();

  // Select active projects x languages ordered by last checked time
  $q = db_select('l10n_update_project', 'p');
  $q->leftJoin('l10n_update_file', 'f', 'p.name = f.project');
  $q->innerJoin('languages', 'l', 'l.language = f.language');
  $q->condition('p.status', 1);
  $q->condition('l.enabled', 1);
  // If the file is not there, or it is there, but we did not check since $before.
  $q->condition(db_or()->isNull('f.status')->condition(db_and()->condition('f.status', 1)->condition('f.last_checked', $before, '<')));
  $q->range(0, $count);
  $q->fields('p', array('name'));
  $q->fields('f');
  $q->addField('l', 'language', 'lang');
  $q->orderBy('last_checked');
  $result = $q->execute();

  if ($result) {
    $local = variable_get('l10n_update_check_mode', L10N_UPDATE_CHECK_ALL) & L10N_UPDATE_CHECK_LOCAL;
    $remote = variable_get('l10n_update_check_mode', L10N_UPDATE_CHECK_ALL) & L10N_UPDATE_CHECK_REMOTE;
    foreach ($result as $check) {
      if (count($updated) >= $limit) {
        break;
      }
      $checked[] = $check;
      if (!empty($projects[$check->name])) {
        $project = $projects[$check->name];
        $update = NULL;
        $source = l10n_update_source_build($project, $check->lang);
        $current = $check->filename ? $check : NULL;
        if ($available = l10n_update_source_check($source, $local, $remote)) {
          if (!$current || _l10n_update_source_compare($current, $available) == -1 || $current->version != $available->version) {
            $update = $available;
          }
        }
        if ($update) {
          // The update functions will update data and timestamps too
          l10n_update_source_update($update, variable_get('l10n_update_import_mode', LOCALE_IMPORT_KEEP));
          $updated[] = $update;
        }
        elseif ($current) {
          // No update available, just update timestamp for this row
          db_update('l10n_update_file')
            ->fields(array(
              'last_checked' => REQUEST_TIME,
            ))
            ->condition('project', $current->project)
            ->condition('language', $current->language)
            ->execute();
        }
        elseif ($source) {
          // Create a new record just for keeping last checked time
          $source->last_checked = REQUEST_TIME;
          drupal_write_record('l10n_update_file', $source);
        }
      }
    }
  }
  return array($checked, $updated);
}

/**
 * Build abstract translation source, to be mapped to a file or a download.
 *
 * @param $project
 *   Project object.
 * @param $langcode
 *   Language code.
 * @param $filename
 *   File name of translation file. May contains placeholders.
 * @return object
 *   Source object, which may have these properties:
 *   - 'project': Project name.
 *   - 'language': Language code.
 *   - 'type': Source type 'download' or 'localfile'.
 *   - 'uri': Local file path.
 *   - 'fileurl': Remote file URL for downloads.
 *   - 'filename': File name.
 *   - 'keep': TRUE to keep the downloaded file.
 *   - 'timestamp': Last update time of the file.
 */
function l10n_update_source_build($project, $langcode, $filename = L10N_UPDATE_DEFAULT_FILENAME) {
  $source = clone $project;
  $source->project = $project->name;
  $source->language = $langcode;
  $source->filename = l10n_update_build_string($source, $filename);
  return $source;
}

/**
 * Check local and remote sources for the file.
 *
 * @param $source
 *   Translation source object.
 *   @see l10n_update_source_build()
 * @param $check_local
 *   File object of local translation file.
 * @param $check_remote
 *   File object of remote translation file.
 * @return object
 *   File object of most recent translation; local or remote.
 */
function l10n_update_source_check($source, $check_local = TRUE, $check_remote = TRUE) {
  $local = $remote = NULL;
  if ($check_local) {
    $check = clone $source;
    if (l10n_update_source_check_file($check)) {
      $local = $check;
    }
  }
  if ($check_remote) {
    $check = clone $source;
    if (l10n_update_source_check_download($check)) {
      $remote = $check;
    }
  }

  // Get remote if newer than local only, they both can be empty
  return _l10n_update_source_compare($local, $remote) < 0 ? $remote : $local;
}

/**
 * Check remote file object.
 *
 * @param $source
 *   Remote translation file object. The object will be update
 *   with data of the remote file:
 *   - 'type': Fixed value 'download'.
 *   - 'fileurl': File name and path.
 *   - 'timestamp': Last updated time.
 *   @see l10n_update_source_build()
 * @return object
 *   An object containing the HTTP request headers, response code, headers,
 *   data, redirect status and updated timestamp.
 *   NULL if failure.
 */
function l10n_update_source_check_download($source) {
  $url = l10n_update_build_string($source, $source->l10n_path);
  $result = l10n_update_http_check($url);
  if ($result && !empty($result->updated)) {
    $source->type = 'download';
    // There may have been redirects so we store the resulting url
    $source->fileurl = isset($result->redirect_url) ? $result->redirect_url : $url;
    $source->timestamp = $result->updated;
    return $result;
  }
}

/**
 * Check whether we've got the file in the filesystem under 'translations'.
 *
 * It will search, similar to modules and themes:
 * - translations
 * - sites/all/translations
 * - sites/mysite/translations
 *
 * Using name as the key will return just the last one found.
 *
 * @param $source
 *   Translation file object. The object will be updated with data of local file.
 *   - 'type': Fixed value 'localfile'.
 *   - 'uri': File name and path.
 *   - 'timestamp': Last updated time.
 *   @see l10n_update_source_build()
 * @param $directory
 *   Files directory.
 * @return Object
 *  File object (filename, basename, name)
 *  NULL if failure.
 */
function l10n_update_source_check_file($source, $directory = 'translations') {
  $filename = '/' . preg_quote($source->filename) . '$/';

  // Using the 'name' key will return
  if ($files = drupal_system_listing($filename, $directory, 'name', 0)) {
    $file = current($files);
    $source->type = 'localfile';
    $source->uri = $file->uri;
    $source->timestamp = filemtime($file->uri);
    return $file;
  }
}

/**
 * Download and import or just import source, depending on type.
 *
 * @param $source
 *   Translation source object with information about the file location.
 *   Object will be updated with :
 *   - 'last_checked': Timestamp of current time;
 *   - 'import_date': Timestamp of current time;
 * @param $mode
 *   Download mode. How to treat exising and modified translations.
 * @return boolean
 *   TRUE on success, NULL on failure.
 */
function l10n_update_source_update($source, $mode) {
  if ($source->type == 'localfile' || l10n_update_source_download($source)) {
    if (l10n_update_source_import($source, $mode)) {
      l10n_update_source_history($source);
      return TRUE;
    }
  }
}

/**
 * Import source into locales table.
 *
 * @param $source
 *   Translation source object with information about the file location.
 *   Object will be updated with :
 *   - 'last_checked': Timestamp of current time;
 *   - 'import_date': Timestamp of current time;
 * @param $mode
 *   Download mode. How to treat exising and modified translations.
 * @return boolean
 *   Result array on success, FALSE on failure.
 */
function l10n_update_source_import($source, $mode) {
  if (!empty($source->uri) && $result = l10n_update_import_file($source->uri, $source->language, $mode)) {
    $source->last_checked = REQUEST_TIME;

    // We override the file timestamp here. The default file time stamp is the
    // release date from the l.d.o server. We change the timestamp to the
    // creation time on the webserver. On multi sites that share a common
    // sites/all/translations directory, the sharing sites use the local file
    // creation date as release date. Without this correction the local
    // file is always newer than the l.d.o. file, which results in unnecessary
    // translation import.
    $source->timestamp = time();

    return $result;
  }
}

/**
 * Download source file from remote server.
 *
 * If succesful this function returns the downloaded file in two ways:
 * - As a temporary $file object
 * - As a file path on the $source->uri property.
 *
 * @param $source
 *   Source object with all parameters
 *   - 'fileurl': url to download.
 *   - 'uri': alternate destination. If not present a temporary file
 *                 will be used and the path returned here.
 * @return object
 *   $file object if download successful.
 */
function l10n_update_source_download($source) {
  if (!empty($source->uri)) {
    $destination = $source->uri;
  }
  elseif ($directory = variable_get('l10n_update_download_store', '')) {
    $destination = $directory . '/' . $source->filename;
  }
  else {
    $destination = NULL;
  }
  if ($file = l10n_update_download_file($source->fileurl, $destination)) {
    $source->uri = $file;
    return $file;
  }
}

/**
 * Update the file history table and delete the file if temporary.
 *
 * @param $file
 *   Source object representing the file just imported or downloaded.
 */
function l10n_update_source_history($file) {
  // Update history table
  l10n_update_file_history($file);

  // If it's a downloaded file and not marked for keeping, delete the file.
  if ($file->type == 'download' && empty($file->keep)) {
    file_unmanaged_delete($file->uri);
    $file->uri = '';
  }
}

/**
 * Compare two update sources, looking for the newer one (bigger timestamp).
 *
 * This function can be used as a callback to compare two source objects.
 *
 * @param $current
 *   Source object of current project.
 * @param $update
 *   Source object of available update.
 * @return integer
 *   - '-1': $current < $update OR $current is missing
 *   - '0': $current == $update OR both $current and $updated are missing
 *   - '1': $current > $update OR $update is missing
 */
function _l10n_update_source_compare($current, $update) {
  if ($current && $update) {
    if (abs($current->timestamp - $update->timestamp) < L10N_UPDATE_TIMESTAMP_THRESHOLD) {
      return 0;
    }
    else {
      return $current->timestamp > $update->timestamp ? 1 : -1;
    }
  }
  elseif ($current && !$update) {
    return 1;
  }
  elseif (!$current && $update) {
    return -1;
  }
  else {
    return 0;
  }
}

/**
 * Prepare update list.
 *
 * @param $updates
 *   Array of update sources that may be indexed in multiple ways.
 * @param $projects
 *   Array of project names to be included, others will be filtered out.
 * @param $languages
 *   Array of language codes to be included, others will be filtered out.
 * @return array
 *   Plain array of filtered updates with directory applied.
 */
function _l10n_update_prepare_updates($updates, $projects = NULL, $languages = NULL) {
  $result = array();
  foreach ($updates as $key => $update) {
    if (is_array($update)) {
      // It is a sub array of updates yet, process and merge
      $result = array_merge($result, _l10n_update_prepare_updates($update, $projects, $languages));
    }
    elseif ((!$projects || in_array($update->project, $projects)) && (!$languages || in_array($update->language, $languages))) {
      $directory = variable_get('l10n_update_download_store', '');
      if ($directory && empty($update->uri)) {
        // If we have a destination folder set just if we have no uri
        if (empty($update->uri)) {
          $update->uri = $directory . '/' . $update->filename;
          $update->keep = TRUE;
        }
      }
      $result[] = $update;
    }
  }
  return $result;
}

/**
 * Language refresh. Runs a batch for loading the selected languages.
 *
 * To be used after adding a new language.
 *
 * @param $languages
 *   Array of language codes to check and download.
 */
function l10n_update_language_refresh($languages) {
  $projects = l10n_update_get_projects();
  if ($available = l10n_update_check_projects($projects, $languages)) {
    $history = l10n_update_get_history();
    if ($updates = l10n_update_build_updates($history, $available)) {
      module_load_include('batch.inc', 'l10n_update');
      // Filter out updates in other languages. If no languages, all of them will be updated
      $updates = _l10n_update_prepare_updates($updates);
      $batch = l10n_update_batch_multiple($updates, variable_get('l10n_update_import_mode', LOCALE_IMPORT_KEEP));
      batch_set($batch);
    }
  }
}
