<?php

namespace Moodle;

abstract class H5PEditorEndpoints {

  /**
   * Endpoint for retrieving library data necessary for displaying
   * content types in the editor.
   */
  const LIBRARIES = 'libraries';

  /**
   * Endpoint for retrieving a singe library's data necessary for displaying
   * main libraries
   */
  const SINGLE_LIBRARY = 'single-library';

  /**
   * Endpoint for retrieving the currently stored content type cache
   */
  const CONTENT_TYPE_CACHE = 'content-type-cache';

  /**
   * Endpoint for retrieving the currently stored content hub metadata cache
   */
  const CONTENT_HUB_METADATA_CACHE = 'content-hub-metadata-cache';

  /**
   * Endpoint for installing libraries from the Content Type Hub
   */
  const LIBRARY_INSTALL = 'library-install';

  /**
   * Endpoint for uploading libraries used by the editor through the Content
   * Type Hub.
   */
  const LIBRARY_UPLOAD = 'library-upload';

  /**
   * Endpoint for uploading files used by the editor.
   */
  const FILES = 'files';

  /**
   * Endpoint for retrieveing translation files
   */
  const TRANSLATIONS = 'translations';

  /**
   * Endpoint for filtering parameters.
   */
  const FILTER = 'filter';

  /**
   * Endpoint for installing libraries from the Content Type Hub
   */
  const GET_HUB_CONTENT = 'get-hub-content';
}


  /**
 * Class H5PEditorAjax
 * @package modules\h5peditor\h5peditor
 */
class H5PEditorAjax {

  /**
   * @var H5PCore
   */
  public $core;

  /**
   * @var H5peditor
   */
  public $editor;

  /**
   * @var H5peditorStorage
   */
  public $storage;

  /**
   * H5PEditorAjax constructor requires core, editor and storage as building
   * blocks.
   *
   * @param H5PCore $H5PCore
   * @param H5peditor $H5PEditor
   * @param H5peditorStorage $H5PEditorStorage
   */
  public function __construct(H5PCore $H5PCore, H5peditor $H5PEditor, H5peditorStorage $H5PEditorStorage) {
    $this->core = $H5PCore;
    $this->editor = $H5PEditor;
    $this->storage = $H5PEditorStorage;
  }

  /**
   * @param $endpoint
   */
  public function action($endpoint) {
    switch ($endpoint) {
      case H5PEditorEndpoints::LIBRARIES:
        H5PCore::ajaxSuccess($this->editor->getLibraries(), TRUE);
        break;

      case H5PEditorEndpoints::SINGLE_LIBRARY:
        // pass on arguments
        $args = func_get_args();
        array_shift($args);
        $library = call_user_func_array(
          array($this->editor, 'getLibraryData'), $args
        );
        H5PCore::ajaxSuccess($library, TRUE);
        break;

      case H5PEditorEndpoints::CONTENT_TYPE_CACHE:
        if (!$this->isHubOn()) return;
        H5PCore::ajaxSuccess($this->getContentTypeCache(!$this->isContentTypeCacheUpdated()), TRUE);
        break;

      case H5PEditorEndpoints::CONTENT_HUB_METADATA_CACHE:
        if (!$this->isHubOn()) return;
        header('Cache-Control: no-cache');
        header('Content-Type: application/json; charset=utf-8');
        print '{"success":true,"data":' . $this->core->getUpdatedContentHubMetadataCache(func_get_arg(1)) . '}';
        break;

      case H5PEditorEndpoints::LIBRARY_INSTALL:
        if (!$this->isPostRequest()) return;

        $token = func_get_arg(1);
        if (!$this->isValidEditorToken($token)) return;

        $machineName = func_get_arg(2);
        $this->libraryInstall($machineName);
        break;

      case H5PEditorEndpoints::LIBRARY_UPLOAD:
        if (!$this->isPostRequest()) return;

        $token = func_get_arg(1);
        if (!$this->isValidEditorToken($token)) return;

        $uploadPath = func_get_arg(2);
        $contentId = func_get_arg(3);
        $this->libraryUpload($uploadPath, $contentId);
        break;

      case H5PEditorEndpoints::FILES:
        $token = func_get_arg(1);
        $contentId = func_get_arg(2);
        if (!$this->isValidEditorToken($token)) return;
        $this->fileUpload($contentId);
        break;

      case H5PEditorEndpoints::TRANSLATIONS:
        $language = func_get_arg(1);
        H5PCore::ajaxSuccess($this->editor->getTranslations($_POST['libraries'], $language));
        break;

      case H5PEditorEndpoints::FILTER:
        $token = func_get_arg(1);
        if (!$this->isValidEditorToken($token)) return;
        $this->filter(func_get_arg(2));
        break;

      case H5PEditorEndpoints::GET_HUB_CONTENT:
        if (!$this->isPostRequest() || !$this->isValidEditorToken(func_get_arg(1))) {
          return;
        }
        $this->getHubContent(func_get_arg(2), func_get_arg(3));
        break;
    }
  }

  /**
   * Handles uploaded files from the editor, making sure they are validated
   * and ready to be permanently stored if saved.
   *
   * Marks all uploaded files as
   * temporary so they can be cleaned up when we have finished using them.
   *
   * @param int $contentId Id of content if already existing content
   */
  private function fileUpload($contentId = NULL) {
    $file = new H5peditorFile($this->core->h5pF);
    if (!$file->isLoaded()) {
      H5PCore::ajaxError($this->core->h5pF->t('File not found on server. Check file upload settings.'));
      return;
    }

    // Make sure file is valid and mark it for cleanup at a later time
    if ($file->validate()) {
      $file_id = $this->core->fs->saveFile($file, 0);
      $this->storage->markFileForCleanup($file_id, 0);
    }
    $file->printResult();
  }

  /**
   * Handles uploading libraries so they are ready to be modified or directly saved.
   *
   * Validates and saves any dependencies, then exposes content to the editor.
   *
   * @param {string} $uploadFilePath Path to the file that should be uploaded
   * @param {int} $contentId Content id of library
   */
  private function libraryUpload($uploadFilePath, $contentId) {
    // Verify h5p upload
    if (!$uploadFilePath) {
      H5PCore::ajaxError($this->core->h5pF->t('Could not get posted H5P.'), 'NO_CONTENT_TYPE');
      exit;
    }

    $file = $this->saveFileTemporarily($uploadFilePath, TRUE);
    if (!$file) return;

    $this->processContent($contentId);
  }

  /**
   * Process H5P content from local H5P package.
   *
   * @param integer $contentId The Local Content ID / vid. TODO Remove when JI-366 is fixed
   */
  private function processContent($contentId) {
    // Check if the downloaded package is valid
    if (!$this->isValidPackage()) {
      return; // Validation errors
    }

    // Install any required dependencies (libraries) from the package
    // (if permission allows it, of course)
    $storage = new H5PStorage($this->core->h5pF, $this->core);
    $storage->savePackage(NULL, NULL, TRUE);

    // Make content available to editor
    $files = $this->core->fs->moveContentDirectory($this->core->h5pF->getUploadedH5pFolderPath(), $contentId);

    // Clean up
    $this->storage->removeTemporarilySavedFiles($this->core->h5pF->getUploadedH5pFolderPath());

    // Mark all files as temporary
    // TODO: Uncomment once moveContentDirectory() is fixed. JI-366
    /*foreach ($files as $file) {
      $this->storage->markFileForCleanup($file, 0);
    }*/

    H5PCore::ajaxSuccess(array(
      'h5p' => $this->core->mainJsonData,
      'content' => $this->core->contentJsonData,
      'contentTypes' => $this->getContentTypeCache()
    ));
  }

  /**
   * Validates security tokens used for the editor
   *
   * @param string $token
   *
   * @return bool
   */
  private function isValidEditorToken($token) {
    $isValidToken = $this->editor->ajaxInterface->validateEditorToken($token);
    if (!$isValidToken) {
      H5PCore::ajaxError(
        $this->core->h5pF->t('Invalid security token.'),
        'INVALID_TOKEN'
      );
      return FALSE;
    }
    return TRUE;
  }

  /**
   * Handles installation of libraries from the Content Type Hub.
   *
   * Accepts a machine name and attempts to fetch and install it from the Hub if
   * it is valid. Will also install any dependencies to the requested library.
   *
   * @param string $machineName Name of library that should be installed
   */
  private function libraryInstall($machineName) {

    // Determine which content type to install from post data
    if (!$machineName) {
      H5PCore::ajaxError($this->core->h5pF->t('No content type was specified.'), 'NO_CONTENT_TYPE');
      return;
    }

    // Look up content type to ensure it's valid(and to check permissions)
    $contentType = $this->editor->ajaxInterface->getContentTypeCache($machineName);
    if (!$contentType) {
      H5PCore::ajaxError($this->core->h5pF->t('The chosen content type is invalid.'), 'INVALID_CONTENT_TYPE');
      return;
    }

    // Check install permissions
    if (!$this->editor->canInstallContentType($contentType)) {
      H5PCore::ajaxError($this->core->h5pF->t('You do not have permission to install content types. Contact the administrator of your site.'), 'INSTALL_DENIED');
      return;
    }
    else {
      // Override core permission check
      $this->core->mayUpdateLibraries(TRUE);
    }

    // Retrieve content type from hub endpoint
    $response = $this->callHubEndpoint(H5PHubEndpoints::CONTENT_TYPES . $machineName);
    if (!$response) return;

    // Session parameters has to be set for validation and saving of packages
    if (!$this->isValidPackage(TRUE)) return;

    // Save H5P
    $storage = new H5PStorage($this->core->h5pF, $this->core);
    $storage->savePackage(NULL, NULL, TRUE);

    // Clean up
    $this->storage->removeTemporarilySavedFiles($this->core->h5pF->getUploadedH5pFolderPath());

    // Successfully installed. Refresh content types
    H5PCore::ajaxSuccess($this->getContentTypeCache());
  }

  /**
   * End-point for filter parameter values according to semantics.
   *
   * @param {string} $libraryParameters
   */
  private function filter($libraryParameters) {
    $libraryParameters = json_decode($libraryParameters);
    if (!$libraryParameters) {
      H5PCore::ajaxError($this->core->h5pF->t('Could not parse post data.'), 'NO_LIBRARY_PARAMETERS');
      exit;
    }

    // Filter parameters and send back to client
    $validator = new H5PContentValidator($this->core->h5pF, $this->core);
    $validator->validateLibrary($libraryParameters, (object) array('options' => array($libraryParameters->library)));
    H5PCore::ajaxSuccess($libraryParameters);
  }

  /**
   * Download and use content from the HUB
   *
   * @param integer $hubId The Hub Content ID
   * @param integer $localContentId The Local Content ID
   */
  private function getHubContent($hubId, $localContentId) {
    // Download H5P file
    if (!$this->callHubEndpoint(H5PHubEndpoints::CONTENT . '/' . $hubId . '/export')) {
      return; // Download failed
    }

    $this->processContent($localContentId);
  }

  /**
   * Validates the package. Sets error messages if validation fails.
   *
   * @param bool $skipContent Will not validate cotent if set to TRUE
   *
   * @return bool
   */
  private function isValidPackage($skipContent = FALSE) {
    $validator = new H5PValidator($this->core->h5pF, $this->core);
    if (!$validator->isValidPackage($skipContent, FALSE)) {
      $this->storage->removeTemporarilySavedFiles($this->core->h5pF->getUploadedH5pPath());

      H5PCore::ajaxError(
        $this->core->h5pF->t('Validating h5p package failed.'),
        'VALIDATION_FAILED',
        NULL,
        $this->core->h5pF->getMessages('error')
      );
      return FALSE;
    }

    return TRUE;
  }

  /**
   * Saves a file or moves it temporarily. This is often necessary in order to
   * validate and store uploaded or fetched H5Ps.
   *
   * Sets error messages if saving fails.
   *
   * @param string $data Uri of data that should be saved as a temporary file
   * @param boolean $move_file Can be set to TRUE to move the data instead of saving it
   *
   * @return bool|object Returns false if saving failed or the path to the file
   *  if saving succeeded
   */
  private function saveFileTemporarily($data, $move_file = FALSE) {
    $file = $this->storage->saveFileTemporarily($data, $move_file);
    if (!$file) {
      H5PCore::ajaxError(
        $this->core->h5pF->t('Failed to download the requested H5P.'),
        'DOWNLOAD_FAILED'
      );
      return FALSE;
    }

    return $file;
  }

  /**
   * Calls provided hub endpoint and downloads the response to a .h5p file.
   *
   * @param string $endpoint Endpoint without protocol
   *
   * @return bool
   */
  private function callHubEndpoint($endpoint) {
    $path = $this->core->h5pF->getUploadedH5pPath();
    $response = $this->core->h5pF->fetchExternalData(H5PHubEndpoints::createURL($endpoint), NULL, TRUE, empty($path) ? TRUE : $path);
    if (!$response) {
      H5PCore::ajaxError(
        $this->core->h5pF->t('Failed to download the requested H5P.'),
        'DOWNLOAD_FAILED',
        NULL,
        $this->core->h5pF->getMessages('error')
      );
      return FALSE;
    }

    return TRUE;
  }

  /**
   * Checks if request is a POST. Sets error message on fail.
   *
   * @return bool
   */
  private function isPostRequest() {
    if ($_SERVER['REQUEST_METHOD'] !== 'POST') {
      H5PCore::ajaxError(
        $this->core->h5pF->t('A post message is required to access the given endpoint'),
        'REQUIRES_POST',
        405
      );
      return FALSE;
    }
    return TRUE;
  }

  /**
   * Checks if H5P Hub is enabled. Sets error message on fail.
   *
   * @return bool
   */
  private function isHubOn() {
    if (!$this->core->h5pF->getOption('hub_is_enabled', TRUE)) {
      H5PCore::ajaxError(
        $this->core->h5pF->t('The hub is disabled. You can enable it in the H5P settings.'),
        'HUB_DISABLED',
        403
      );
      return false;
    }
    return true;
  }

  /**
   * Checks if Content Type Cache is up to date. Immediately tries to fetch
   * a new Content Type Cache if it is outdated.
   * Sets error message if fetching new Content Type Cache fails.
   *
   * @return bool
   */
  private function isContentTypeCacheUpdated() {

    // Update content type cache if enabled and too old
    $ct_cache_last_update = $this->core->h5pF->getOption('content_type_cache_updated_at', 0);
    $outdated_cache       = $ct_cache_last_update + (60 * 60 * 24 * 7); // 1 week
    if (time() > $outdated_cache) {
      $success = $this->core->updateContentTypeCache();
      if (!$success) {
        return false;
      }
    }
    return true;
  }

  /**
   * Gets content type cache for globally available libraries and the order
   * in which they have been used by the author
   *
   * @param bool $cacheOutdated The cache is outdated and not able to update
   */
  private function getContentTypeCache($cacheOutdated = FALSE) {
    $canUpdateOrInstall = ($this->core->h5pF->hasPermission(H5PPermission::INSTALL_RECOMMENDED) ||
                           $this->core->h5pF->hasPermission(H5PPermission::UPDATE_LIBRARIES));
    return array(
      'outdated' => $cacheOutdated && $canUpdateOrInstall,
      'libraries' => $this->editor->getLatestGlobalLibrariesData(),
      'recentlyUsed' => $this->editor->ajaxInterface->getAuthorsRecentlyUsedLibraries(),
      'apiVersion' => array(
        'major' => H5PCore::$coreApi['majorVersion'],
        'minor' => H5PCore::$coreApi['minorVersion']
      ),
      'details' => $this->core->h5pF->getMessages('info')
    );
  }
}
