<?php
// $Id: feedapi.module,v 1.23.2.15 2007-08-12 14:57:20 aronnovak Exp $

/**
 * @file
 * Handle the submodules (for feed and item processing)
 * Provide a basic management of feeds
 */

define('FEEDAPI_NEVER_DELETE_OLD', -1);

/**
 * Implementation of hook_help().
 */
function feedapi_help($section) {
  switch ($section) {
    case 'admin/help#feedapi':
      return t('
        Provides feed management interface and handle underlying processors and parsers for any type of feeds.
        <br />Feeds are based on content-types. Before you can create a feed, you have to go
        to the admin/content/types/add page. There choose a name for the content-type,
        then enable the "Is a feed content type" checkbox under the Feed API group.
        Next choose the processors and parsers that you want to use. At least one parser
        and one processor must be enabled. Then create the content-type. Make sure
        that permissions are given to the users who will handle the feeds.
      ');
  }
}

/**
 * Implementation of hook_menu().
 */
function feedapi_menu($may_cache) {
  if ($may_cache) {
     $items[] = array(
       'path' => 'admin/content/feed',
       'title' => t('Feed'),
       'callback' => 'feedapi_management_page',
       'access' => user_access('administer feedapi'),
     );
     $items[] = array(
       'path' => 'admin/content/feed/list',
       'title' => t('List'),
       'type' => MENU_DEFAULT_LOCAL_TASK,
       'weight' => -15,
     );
     $items[] = array('path' => 'admin/settings/feedapi',
       'title' => t('FeedAPI settings'),
       'callback' => 'drupal_get_form',
       'callback arguments' => array('feedapi_admin_settings'),
       'type' => MENU_NORMAL_ITEM,
       'access' => user_access('administer feedapi'),
     );
  }
  else if (arg(0) == 'node' && is_numeric(arg(1))) {
    $node = node_load(arg(1));
    if (isset($node->feed)) {
      global $user;
      $own_feed = $node->uid == $user->uid && user_access('edit own '. $node->type . ' content') ? TRUE : FALSE;
      $items[] = array('path' => 'node/'. $node->nid. '/refresh',
        'title' => t('Refresh'),
        'callback' => 'feedapi_invoke_feedapi',
        'callback arguments' => array("refresh", $node->feed),
        'type' => MENU_LOCAL_TASK,
        'access' => variable_get('feedapi_feed_show_commands_link', TRUE) && (user_access('administer feedapi') || $own_feed),
      );
    }
  }
  return $items;
}

/**
 * Implementation of hook_nodeapi().
 */
function feedapi_nodeapi(&$node, $op, $teaser, $page) {
  if (isset($node->feed) || _feedapi_is_enabled($node->type)) {
    switch ($op) {
      case 'insert':
        $node->feed->nid = $node->nid;
        if (isset($node->feed->url) && isset($node->feed->feed_type)) {
          db_query("INSERT INTO {feedapi} (
            nid, url, link, feed_type, processors,
            parsers, refresh, checked) VALUES
            (%d, '%s', '%s', '%s', '%s', '%s', %d, %d)", 
            $node->feed->nid,
            $node->feed->url,
            $node->feed->options->link,
            $node->feed->feed_type,
            serialize($node->feed->processors),
            serialize($node->feed->parsers),
            900,
            0
          );
          _feedapi_store_settings(array('nid' => $node->nid), $node->feed->settings);
        }
        break;
      case 'update':
        if (isset($node->feed)) {
          $old_config = node_load($node->nid);
          foreach ($old_config->feed->processors as $processor) {
            if (!in_array($processor, $node->feed->processors)) {
              $items = module_invoke($processor, 'feedapi_item_fetch_items', $node->feed);
              foreach ($items as $item) {
                module_invoke($processor, 'feedapi_item_delete', $item);
              }
            }
          }
          // Store the common things
          if ($node->url_updated == TRUE) {
            db_query("UPDATE {feedapi} SET
              url = '%s', link = '%s',
              refresh = %d,  items_delete = %d WHERE nid = %d", 
              $node->feed->url,
              $node->feed->options->link,
              $node->feedapi['feedapi_refresh'],
              $node->feedapi['feedapi_items_delete'],
              $node->nid
          );
          }
          else {
            db_query("UPDATE {feedapi} SET refresh = %d,  items_delete = %d WHERE nid = %d",
              $node->feedapi['feedapi_refresh'],
              $node->feedapi['feedapi_items_delete'],
              $node->nid
            );
          }
          _feedapi_store_settings(array('nid' => $node->nid), $node->feedapi);
        }
        break;
      case 'load':
        $node->feed = db_fetch_object(db_query('SELECT * FROM {feedapi} WHERE nid = %d', $node->nid));
        $node->feed->nid = $node->nid;
        $node->feed->settings = _feedapi_get_settings(array('nid' => $node->nid));
        $node->feed->processors = unserialize($node->feed->processors);
        $node->feed->parsers = unserialize($node->feed->parsers);
        break;
      case 'delete':
        // Could be a performance problem - think of thousands of node feed items.
        feedapi_invoke_feedapi('purge', $node->feed);
        db_query("DELETE FROM {feedapi} WHERE nid = %d", $node->nid);
        break;
      case 'submit':
        if (!isset($node->nid)) {
          // Here the full node form will be processed
          $feed->url = $node->feedapi_url;
          $settings = _feedapi_get_settings(array('node_type' => $node->type));
          $assigned = _feedapi_assign_parser_processor($feed->url, $settings);
          $feed->processors = $assigned['processors'];
          $feed->parsers = $assigned['parsers'];
          $feed->feed_type = $assigned['type'];
          $feed = _feedapi_call_parsers($feed, $feed->parsers);
          $feed->settings = $settings;
          $node->feed = $feed;
          if (empty($node->title)) {
            $node->title = $feed->title;
          }
          if (empty($node->body)) {
            $node->body = $feed->description;
          }
        }
        else {
          // @todo: maybe alter the node-editing form to empty title and body field if the url is altered
          $old_config = node_load($node->nid);
          if ($node->feedapi['feedapi_url'] != $old_config->feed->url) {
            $feed->url = $node->feedapi['feedapi_url'];
            $feed = _feedapi_call_parsers($feed, $old_config->feed->parsers);
            $node->title = empty($node->title) ? $feed->title : $node->title;
            $node->body = empty($node->body) ? $feed->description : $node->body;
            $node->feed->options->link = $feed->options->link;
            $node->feed->url = $feed->url;
            $node->url_updated = TRUE;
          }
        }
        break;
    }
  }
}

/**
 * Implementation of hook_perm().
 */
function feedapi_perm() {
  return array('administer feedapi', 'advanced feedapi options');
}

/**
 * Implementation of hook_link().
 */
function feedapi_link($type, $node = NULL, $teaser = FALSE) {
  if ($type == 'node' && isset($node->feed)) {
    if (variable_get('feedapi_feed_show_feed_origin_link', TRUE) && strlen($node->feed->link) > 0) {
      $links['feedapi_original'] = array(
      'title' => t('Link to the site'),
      'href' => $node->feed->link,
      );
      return $links;
    }
  }
}

/**
 * Do various things with feed. Handle the core data and call the
 * underyling modules (parsers/processors) too
 *
 * @param $op
 *  "load"    Load the feed items basic data into the $feed->items[]
 * "refresh"  Re-download the feed and process newly arrived item
 * 
 * @param $feed
 *  A feed object. If only the ID is known, you should pass something like this: $feed->nid = X 
 * @param $param
 *  Depends on the $op value.
 */
function feedapi_invoke_feedapi($op, &$feed, $param = NULL) {
  if (!is_object($feed)) {
    return FALSE;
  }
  if (!isset($feed->processors)) {
    $node = node_load($feed->nid);
    if (!isset($node->feed)) {
      return FALSE;
    }
    $feed = $node->feed;
  }
  _feedapi_sanitize_processors($feed);
  switch ($op) {
    case 'load':
      $feed->items = array();
      foreach ($feed->processors as $weight) {
        foreach ($weight as $processor) {
          $items = module_invoke($processor, "feedapi_item_fetch_items", $feed);
          if (is_array($items)) {
            foreach ($items as $item) {
              $feed->items[] = $item;
            }
          }
        }
      }
      break;

    case 'refresh':
      $cron = $param;
      feedapi_invoke_feedapi("load", $feed);
      if (!is_array($feed->processors) || count($feed->processors) == 0) {
        if (!$cron) {
          drupal_set_message(t("This feed (%url) doesn't have any processor. It's not possible to refresh the feed.", array('%url' => $feed->url)), "error");
          drupal_goto('node/'. $feed->nid);
        }
        return;
      }
      $processors = $feed->processors;
      // Force the processors to delete old items and determine the max. create elements
      $max_new_items = variable_get('feedapi_refresh_once', 10);
      $refresh = feedapi_expire($feed,  $cron === TRUE ? FALSE : TRUE);
      if ($refresh == FALSE) {
        return;
      }
      $feed = _feedapi_call_parsers($feed, $feed->parsers);
      $feed->processors = $processors;
      $items = array_reverse($feed->items);
      $updated = 0;
      $new = 0;
      // Walk through the items
      foreach ($items as $item) {
        // Call each item parser
        $is_updated = FALSE;
        $is_new = FALSE;
        foreach ($feed->processors as $weight) {
          foreach ($weight as $processor) {
            if (!module_invoke($processor, 'feedapi_item_unique', $item, $feed->nid, $feed->settings['processors'][$processor])) {
              module_invoke($processor, 'feedapi_item_update', $item, $feed->nid, $feed->settings['processors'][$processor]);
              $is_updated = TRUE;
            }
            else {
              module_invoke($processor, 'feedapi_item_save', $item, $feed->nid, $feed->settings['processors'][$processor]);
              $is_new = TRUE;
            }
          }
        }
        $new = $is_new ? $new + 1 : $new;
        $updated = ($is_updated && !$is_new) ? $updated + 1 : $updated;
        // If we consumed the max new item limit -> stop
        if ($max_new_items == $new) {
          break;
        }
      }
      db_query("UPDATE {feedapi} SET checked = %d WHERE nid = %d", time(), $feed->nid);
      foreach (module_implements('feedapi_after_refresh') as $module) {
        $func = $module. '_feedapi_after_refresh';
        $func($feed);
      }
      if (!$cron) {
        drupal_set_message(t("%new new item(s) were saved. %updated existing item(s) were updated.", array("%new" => $new, "%updated" => $updated)));
        drupal_goto('node/'. $feed->nid);
      }
      break;

    case 'purge':
      feedapi_invoke_feedapi("load", $feed);
      // Delete items from the processors
      foreach ($feed->items as $item) {
        foreach($feed->processors as $weight) {
          foreach ($weight as $processor) {
            // FIXME: it's possible now to delete an item from another processor as an incident
            module_invoke($processor, 'feedapi_item_delete', $item, $feed->settings['processors'][$processor]);
          }
        }
      }
      break;
  }
}

/**
 * Delete expired items and return informations about the feed refreshing
 * 
 * @param $feed
 *  The feed object
 * @param $force
 *  If TRUE, do not examine that the feed needs refresh
 * @return
 *  FALSE if the feed don't have to be refreshed. (forbidden if the $force is TRUE)
 */
function feedapi_expire($feed, $force) {
  $needs_refresh = time() - $feed->checked > $feed->refresh;
  if (($needs_refresh || $force) && $feed->items_delete != FEEDAPI_NEVER_DELETE_OLD) {
    foreach ($feed->items as $item) {
      if (isset($item->arrived) || isset($item->timestamp)) {
        $diff = abs(time() - (isset($item->arrived) ? $item->arrived : $item->timestamp));
        if ($diff > $feed->items_delete) {
          foreach($feed->processors as $weight) {
            foreach ($weight as $processor) {
              module_invoke($processor, 'feedapi_item_delete', $item, $feed->nid);
            }
          }
        }
      }
    }
  }
  if ($needs_refresh == FALSE && $force == FALSE) {
    return FALSE;
  }
  return TRUE;
}

/**
 * Implementation of hook_form_alter().
 */
function feedapi_form_alter($form_id, &$form) {
  // Content type form.
  if ($form_id == 'node_type_form' && isset($form['identity']['type'])) {
    if (isset($form['#post']['feedapi'])) {
      // TODO: Drupal automatically stores mutilated 'feedapi_'. $form['#node_type']->type - remove.
      // TODO: Do better validation
      $type = !empty($form['#node_type']->type) ? $form['#node_type']->type : $form['#post']['type'];
      _feedapi_store_settings(array('node_type' => $type), $form['#post']['feedapi']);
    }
    if (!$settings = _feedapi_get_settings(array('node_type' => $form['#node_type']->type))) {
      $settings = array();
    }
    $form['feedapi'] = array(
      '#type' => 'fieldset',
      '#title' => t('Feed API'),
      '#collapsible' => TRUE,
      '#collapsed' => !$settings['enabled'],
      '#tree' => TRUE,
    );
    $form['feedapi']['enabled'] = array(
      '#type' => 'checkbox',
      '#title' => t('Is a feed content type'),
      '#description' => t('Check this box if you want to use this content type for downloading feeds to your site.'),
      '#default_value' => $settings['enabled'],
      '#weight' => -15,
    );
    $form['feedapi']['parsers'] = array(
      '#type' => 'fieldset',
      '#title' => t('Parser settings'),
      '#description' => t('Parsers create an object ready for processing from a feed, choose at least one.'),
      '#collapsible' => FALSE,
      '#tree' => TRUE,
    );
    $parsers = _feedapi_suitable_parsers('', TRUE);
    rsort($parsers);
    foreach ($parsers as $parser) {
      $form['feedapi']['parsers'][$parser] = array(
        '#type' => 'fieldset',
        '#title' => feedapi_get_natural_name($parser),
        '#collapsible' => TRUE,
        '#collapsed' => !($settings['parsers'][$parser]['enabled'] || (count($parsers) == 1)),
        '#tree' => TRUE,
        '#weight' => $settings['parsers'][$parser]['weight'], 
      );
      $form['feedapi']['parsers'][$parser]['enabled'] = array(
        '#type' => 'checkbox',
        '#title' => t('Enable'),
        '#description' => t('Check this box if you want to enable the @name parser on this feed.', array('@name' => t($parser))),
        '#default_value' => $settings['parsers'][$parser]['enabled'] || (count($parsers) == 1),
        '#weight' => -15,
      );
      $form['feedapi']['parsers'][$parser]['weight'] = array(
        '#type' => 'weight',
        '#delta' => 15,
        '#title' => t('Weight'),
        '#description' => t('Control the execution order. Parsers with lower weights come before parsers with higher weights.'),
        '#options' => $options,
        '#default_value' => $settings['parsers'][$parser]['weight'],
        '#weight' => -14,
      );
    }
    $form['feedapi']['processors'] = array(
      '#type' => 'fieldset',
      '#title' => t('Processor settings'),
      '#description' => t('Processors are any kind of add on modules that hook into the feed handling process on download time - you can decide here what should happen to feed items once they are downloaded and parsed.'),
      '#collapsible' => FALSE,
      '#tree' => TRUE,
      );
    $processors = _feedapi_suitable_processors('', TRUE);
    rsort($processors);
    foreach ($processors as $processor) {
      $form['feedapi']['processors'][$processor] = array(
        '#type' => 'fieldset',
        '#title' => feedapi_get_natural_name($processor),
        '#collapsible' => TRUE,
        '#collapsed' => !($settings['processors'][$processor]['enabled'] || (count($processors) == 1)),
        '#tree' => TRUE,
        '#weight' => $settings['processors'][$processor]['weight'],
      );
      $form['feedapi']['processors'][$processor]['enabled'] = array(
        '#type' => 'checkbox',
        '#title' => t('Enable'),
        '#description' => t('Check this box if you want to enable the @name processor on this feed.', array('@name' => t($processor))),
        '#default_value' => $settings['processors'][$processor]['enabled'],
        '#weight' => -15,
      );
      $form['feedapi']['processors'][$processor]['weight'] = array(
        '#type' => 'weight',
        '#delta' => 15,
        '#title' => t('Weight'),
        '#description' => t('Control the execution order. Processors with lower weights come before processors with higher weights.'),
        '#default_value' => $settings['processors'][$processor]['weight'],
        '#weight' => -14,
      );
    }
    $form['feedapi'] = array_merge_recursive($form['feedapi'], _feedapi_invoke_settings_form(array('node_type' => $form['#node_type']->type)));
    $submit = $form['submit'];
    $delete = $form['delete'];
    unset($form['submit']);
    unset($form['delete']);
    $form['submit'] = $submit;
    $form['delete'] = $delete;
  }
  
  // FeedAPI-enabled node form.
  if ($form['type']['#value'] .'_node_form' == $form_id && _feedapi_is_enabled($form['type']['#value'])) {
    $form['title']['#required'] = FALSE;
    // Modify form - add feedapi form snippet in submit-and-edit and edit mode...
    if (isset($form['#node']->nid) || (isset($form['#post']['op']) && $form['#post']['op'] != 'Submit')) {
      $form['feedapi'] = array(
        '#type' => 'fieldset',
        '#title' => t('Feed API'),
        '#collapsible' => TRUE,
        '#collapsed' => FALSE,
        '#tree' => TRUE,
      );
      $form['feedapi']['feedapi_url'] = array(
        '#type' => 'textfield',
        '#title' => t('Feed URL'),
        '#description' => t('Enter feed URL.'),
        '#default_value' => $form['#node']->feed->url ? $form['#node']->feed->url : $form['#post']['feedapi_url'],
      );
      $period = drupal_map_assoc(array(900, 1800, 3600, 7200, 10800, 21600, 32400, 43200, 64800, 86400, 172800, 259200, 604800, 1209600, 2419200), 'format_interval');
      $form['feedapi']['feedapi_refresh'] = array(
        '#type' => 'select',
        '#options' => $period,
        '#title' => t('Refresh interval'),
        '#default_value' => $form['#node']->feed->refresh ? $form['#node']->feed->refresh : $form['#post']['feedapi_refresh'],
      );
      $period = drupal_map_assoc(array(3600, 10800, 21600, 32400, 43200, 86400, 172800, 259200, 604800, 1209600, 2419200, 3628800, 4838400, 7257600, 15724800, 31536000), 'format_interval');
      $period[FEEDAPI_NEVER_DELETE_OLD] = t('Never');
      $form['feedapi']['feedapi_items_delete'] = array(
        '#type' => 'select',
        '#title' => t('Delete news items older than'),
        '#options' => $period,
        '#default_value' => $form['#node']->feed->items_delete ? $form['#node']->feed->items_delete : $form['#post']['feedapi_items_delete'],
      );
      // Retrieve form snippets from add on modules. 
      // Todo: only let users with "edit own feed settings" permission or "administer feeds" permission meddle with these per-node settings.
      $form_snippets = _feedapi_invoke_settings_form(array('node_type' => $form['type']['#value'], 'nid' => $form['#node']->nid));
      // Format snippets - make fieldsets out of them.
      foreach ($form_snippets as $k => $stage) {
        $form_snippets[$k]['#type'] = 'fieldset';
        $form_snippets[$k]['#title'] = feedapi_get_natural_name($k);
        $form_snippets[$k]['#collapsible'] = TRUE;
        $form_snippets[$k]['#collapsed'] = TRUE;
        $form_snippets[$k]['#tree'] = TRUE;
        foreach (array_keys($stage) as $m) {
          $form_snippets[$k][$m]['#type'] = 'fieldset';
          $form_snippets[$k][$m]['#title'] = feedapi_get_natural_name($m);
          $form_snippets[$k][$m]['#collapsible'] = TRUE;
          $form_snippets[$k][$m]['#collapsed'] = FALSE;
          $form_snippets[$k][$m]['#tree'] = TRUE;
        }
      }
      $form_snippets['#tree'] = TRUE;
      $form['feedapi'] = array_merge_recursive($form['feedapi'], $form_snippets);
    }
    // ... or wipe form and replace it by a short form in add mode.
    else {
      if (variable_get('feedapi_form_create', 'full') != 'full') {
        foreach (array_keys($form) as $k) {
          if (strpos($k, '#') !== 0) {
            unset($form[$k]);
          }
        }
      }
      if (variable_get('feedapi_form_create', 'full') == 'full') {
        $form['feedapi'] = array(
          '#type' => 'fieldset',
          '#title' => t('FeedAPI'),
          '#collapsible' => TRUE,
          '#collapsed' => FALSE,
        );
      }
      $form['feedapi']['feedapi_url'] = array(
        '#type' => 'textfield',
        '#title' => t('Feed URL'),
        '#description' => t('Enter feed URL.'),
      );
      if (variable_get('feedapi_form_create', 'full') != 'full') {
        $form['feedapi']['next'] = array(
          '#type' => 'button',
          '#value' => t('Submit and edit'),
        );
        $form['feedapi']['submit'] = array(
          '#type' => 'button',
          '#value' => t('Submit'),
        );
      }
    }
    
    // Process posted URL from only short form.
    // See  hook_nodeapi('submit') for the long form process
    if (count($form['#post']) && !isset($form['#node']->nid)) {
      if (!$form['#post']['feedapi_url']) {
        form_set_error('feedapi_url', t('Enter a URL'));
      }
      else if (db_result(db_query("SELECT COUNT(*) FROM {feedapi} WHERE url = '%s'", $form['#post']['feedapi_url'])) > 0) {
        form_set_error('feedapi_url', t('This URL (%url) is already created.', array('%url' => $form['#post']['feedapi_url'])));
      }
      else if (in_array($form['#post']['op'], array(t('Submit'), t('Submit and edit'))) && variable_get('feedapi_form_create', 'full') != 'full') {
        // Try to pull title and description directly from feed.
        // Todo: pull icons and logos in add on module.
        
        $feed = new stdClass();
        $feed->url = $form['#post']['feedapi_url'];
        $settings = _feedapi_get_settings(array('node_type' => $form['#node']->type));
        $assigned = _feedapi_assign_parser_processor($feed->url, $settings);
        $feed->link = $feed->options->link;
        $feed->processors = $assigned['processors'];
        $feed->parsers = $assigned['parsers'];
        $feed->feed_type = $assigned['type'];
        if (empty($feed->feed_type)) {
          form_set_error('feedapi', t('Error parsing feed.'));
        }
        else {
          $feed->type = $assigned['type'];
          $feed = _feedapi_call_parsers($feed, $feed->parsers);
        }
        if (!$feed->title) {  
          form_set_error('feedapi_url', t('Feed information could not be retrieved.'));  
        }
        else {
          $feed->settings = $settings;
          $node = _feedapi_create_node($feed, $form['#node']->type);
          if ($form['#post']['op'] == t('Submit')) {
            drupal_goto('node/'. $node->nid);
          }
          else if ($form['#post']['op'] == t('Submit and edit')) {
            drupal_goto('node/'. $node->nid .'/edit');
          }
        }
        
      }
    }
  }
}

/**
 * Implementation of hook_cron().
 */
function feedapi_cron() {
  $result = db_query_range("SELECT nid FROM {feedapi} ORDER BY checked ASC", 0, variable_get('feedapi_cron_max', 5));
  while ($feed = db_fetch_array($result, $row++)) {
    $node = node_load($feed['nid']);
    feedapi_invoke_feedapi('refresh', $node->feed, TRUE);
  }
}

/**
 * Provide a UI for overviewing the existing feeds
 */
function feedapi_management_page() {
  $header = array(t('Preset'),
    t('Refresh interval'),
    t('Last refresh'),
    t('Title'),
    t('Commands')  
  );
  $rows = array();
  $result = db_query("SELECT nid from {feedapi} ORDER BY checked DESC");
  while ($nid = db_result($result, $row++)) {
    $node = node_load($nid);
    $commands = array(l(t('Delete'), 'node/'. $node->nid . '/delete'),
      l(t('Refresh'), 'node/'. $node->nid . '/refresh'),
      l(t('Edit'), 'node/'. $node->nid . '/edit'),
    );
    $ext_commands = module_invoke_all('feedapi_edit_option', $node->feed);
    if (count($ext_commands) > 0) {
      foreach ($ext_commands as $command) {
        $commands[] = l($command['name'], $command['link']);
      }
    }
    $preset = node_get_types('type', $node);
    $rows[] = array(
      l($preset->name, 'admin/content/types/'. $preset->type),
      format_interval($node->feed->refresh),
      $node->feed->checked == 0 ? t('Never') : format_interval(time() - $node->feed->checked) ." ". t("ago"),
      l($node->title, $node->feed->link),
      theme_item_list($commands)
    );
  }
  return theme_table($header, $rows);
}

/**
 * Get the module-defined natural name of FeedAPI parser or processor
 * If your module want to define such a name:
 * 
 *  function hook_help($section) {
 *    switch ($section) {
 *      case 'feedapi/full_name':
 *        return t('Natural name');
 *        break;
 *      }
 *    }
 */
function feedapi_get_natural_name($module) {
  $help = $module .'_help';
  $module_natural = function_exists($help) ? $help('feedapi/full_name') : t($module);
  return empty($module_natural) ? t($module) : $module_natural;
}

/**
 * Settings:
 *  Allowed HTML tags, number of feeds refreshed in one round
 */
function feedapi_admin_settings() {
  $form['feedapi_form_create'] = array(
    '#type' => 'radios', '#title' => t('Feed create form style'),
    '#default_value' => variable_get('feedapi_form_create', 'full'),
    '#options' => array('full' => t('Full'), 'simple' => 'Simplified'),
    '#description' => t('If it is set full, the feed creation form will be a full node creating form. Otherwise a simplified form will be shown.')
  );
  $form['feedapi_allowed_html_tags'] = array(
    '#type' => 'textfield', '#title' => t('Allowed HTML tags'), '#size' => 80, '#maxlength' => 255,
    '#default_value' => variable_get('feedapi_allowed_html_tags', '<a> <b> <br> <dd> <dl> <dt> <em> <i> <li> <ol> <p> <strong> <u> <ul>'),
    '#description' => t('The list of tags which are allowed in feeds, i.e., which will not be removed by Drupal.')
  );
  $form['feedapi_allow_html_all'] = array(
    '#type' => 'checkbox', '#title' => t('Allow all HTML tags'), '#size' => 80, '#maxlength' => 255,
    '#default_value' => variable_get('feedapi_allow_html_all', FALSE),
    '#description' => t('In this case the module does\'t filter any HTML elements from the incoming fields. This checkbox override the above list of allowed tags.')
  );
  if (variable_get('feedapi_allow_html_all', FALSE)) {
    $form['feedapi_allowed_html_tags']['#disabled'] = TRUE;
  }
  $form['feedapi_cron_max'] = array(
    '#type' => 'textfield', '#title' => t('Per-cron feeds refresh'), '#size' => 3, '#maxlength' => 10,
    '#default_value' => variable_get('feedapi_cron_max', 5),
    '#description' => t('How much feed should be refreshed in one cron run maximally')
  );
  
  $form['feedapi_refresh_once'] = array(
    '#type' => 'textfield', '#title' => t('Maximal number of items updated/created in one refresh round'), '#size' => 5, '#maxlength' => 7,
    '#default_value' => variable_get('feedapi_refresh_once', 10),
  );
  return system_settings_form($form);
}

/**
 * Get the list of the parsers for the given feed type
 * 
 * @param $type
 *  The descriptor of the feed type. For eg. "XML feed"
 * @param $all
 *  If you set this to TRUE, all the parsers will be returned (not check the type)
 * @return
 *  An associative array with the names of the suitable parsers
 */
function _feedapi_suitable_parsers($type, $all = FALSE) {
  $req = array('feedapi_type', 'feedapi_parse', 'feedapi_compatible');
  return _feedapi_check_requirement($type, $req, $all);
}

/**
 * Execute the enabled parsers and create an unified output
 *
 * @param $feed
 *  Feed object
 * @param $parsers
 *  Structure: array(
 *    "primary" => "parser_primary",
 *    "secondary" => array("parser1", "parser2", "parserN")
 *  );
 * @return
 *  The object of the parser data
 */
function _feedapi_call_parsers($feed, $parsers) {
  $nid = $feed->nid;
  if (module_exists($parsers["primary"])) {
    $parser_output =  module_invoke($parsers["primary"], "feedapi_parse", $feed);
    $feed = (object) array_merge((array) $feed, (array) $parser_output);
  }
  // Call the turned on parsers, create an union of returned options
  foreach ($parsers["secondary"] as $parser) {
    $feed_ext = module_invoke($parser, "feedapi_parse", $feed);
    $feed->options = (object) ((array) $feed->options + (array) $feed_ext->options);
  }
  $feed->nid = $nid;
  foreach (module_implements('feedapi_after_parse') as $module) {
    $func = $module. '_feedapi_after_parse';
    $func($feed);
  }
  // Filter bad or not allowed tags
  if (!variable_get('feedapi_allow_html_all', FALSE)) {
    $allowed = preg_split('/\s+|<|>/', variable_get('feedapi_allowed_html_tags', '<a> <b> <br> <dd> <dl> <dt> <em> <i> <li> <ol> <p> <strong> <u> <ul>'), -1, PREG_SPLIT_NO_EMPTY);
    foreach (array('title', 'description') as $property) {
      if (isset($feed->{$property})) {
        if (is_string($feed->{$property})) {
          $feed->{$property} = filter_xss($feed->{$property}, $allowed);
        }
      }
    }
    for ($i = 0; $i < count($feed->items); $i++) {
      $feed->items[$i]->title = filter_xss($feed->items[$i]->title, $allowed);
      $feed->items[$i]->description = filter_xss($feed->items[$i]->description, $allowed);
    }
  }
  return $feed;
}

/**
 * Create a node of a given type from a given feed.
 */
function _feedapi_create_node(&$feed, $type) {
  $node = new stdClass();
  $node->type = $type;
  // Let's use the content-type's defaults
  $options = variable_get('node_options_'. $node->type, FALSE);
  if (is_array($options)) {
    $node->status = in_array('status', $options) ? 1 : 0;
    $node->promote = in_array('promote', $options) ? 1 : 0;
    $node->sticky = in_array('sticky', $options) ? 1 : 0;
  }
  global $user;
  $node->uid = $user->uid;
  $node->title = $feed->title;
  $node->created = time();
  $node->body = $feed->description;
  $node->feed = $feed;
  node_save($node);
  return $node;
}

/**
 * Stores settings per content type or per node.
 */
function _feedapi_store_settings($args, $settings) {
  if ($args['nid']) {
    // Filter - only processors and parsers settings will be stored.
    $store_settings = array();
    if ($settings['processors']) {
      $store_settings['processors'] = $settings['processors'];
    }
    if ($settings['parsers']) {
      $store_settings['parsers'] = $settings['parsers'];
    }
    db_query("UPDATE {feedapi} SET settings = '%s' WHERE nid = %d", serialize($store_settings), $args['nid']);
    module_invoke_all('feedapi_after_settings', $args['nid'], $settings);
  }
  elseif ($args['node_type']) {
    variable_set('feedapi_settings_'. $args['node_type'], $settings);
  }
}

/**
 * Returns TRUE if feedapi is enabled for given node type.
 */
function _feedapi_is_enabled($node_type) {
  $settings = _feedapi_get_settings(array('node_type' => $node_type));
  return $settings['enabled'] ? TRUE : FALSE;
}

/**
 * Retrieve settings per content type or per node.
 * $args = array(
 *     'node_type' => '<type>',
 *     'nid' => <id>,
 *   )
 * Todo: add caching. Watch out: cache permutations of node_type or node_type+nid or nid seperately.
 */
function _feedapi_get_settings($args) {
  if (isset($args['nid'])) {
    if ($settings = db_fetch_object(db_query('SELECT settings FROM {feedapi} WHERE nid = %d', $args['nid']))) {
      if ($settings = unserialize($settings->settings)) {
        return $settings;
      }
    }
  }
  // Fallback: node_type.
  if (isset($args['node_type'])) {
    if ($settings = variable_get('feedapi_settings_'. $args['node_type'], FALSE)) {
      return $settings;
    }
  }
  return FALSE;
}

/**
 * Set default value of $form elements if present in $settings.
 */
function _feedapi_populate($form, $settings) {
  static $i;
  $i++;
  foreach ($form as $k => $v) {
    if (is_array($v)) {
      if (array_key_exists('#default_value', $v)) {
        if (isset($settings[$k])) {
          $form[$k]['#default_value'] = $settings[$k];
          $form[$k]['#disabled'] = user_access('advanced feedapi options') ? FALSE : TRUE;
        }
      }
      else if (!array_key_exists('#type', $v)){
        $form[$k] = _feedapi_populate($form[$k], $settings[$k]);
      }
    }
  }
  $i--;
  return $form;
}

/**
 * Invokes feedapi_settings_form hook.
 * $args = array(
 *     'node_type' => '<type>',
 *     'nid' => <id>,
 *   )
 */
function _feedapi_invoke_settings_form($args) {
  $form = array();
  if (isset($args['nid']) && isset($args['node_type'])) {
    // 1) Get settings for corresponding content type
    //    Which parsers / processors are enabled is a per content-type setting.
    if ($settings = _feedapi_get_settings(array('node_type' => $args['node_type']))) {
      // 2) retrieve forms.
      foreach (_feedapi_suitable_parsers('', TRUE) as $module) {
        if ($settings['parsers'][$module]['enabled']) {
          $result = array();  
          $result = module_invoke($module, 'feedapi_settings_form', 'parsers');
          if (is_array($result)) {
            $form['parsers'][$module] = $result;
          }
        }
      }
      foreach (_feedapi_suitable_processors('', TRUE) as $module) {
        if ($settings['processors'][$module]['enabled']) {
          $result = array();
          $result = module_invoke($module, 'feedapi_settings_form', 'processors');
          if (is_array($result)) {
            $form['processors'][$module] = $result;
          }
        }
      }
      
      // 3. now get per node settings and populate form.
      if ($settings = _feedapi_get_settings($args)) {
        $form = _feedapi_populate($form, $settings);
      }
    }
  }
  else if (isset($args['node_type'])) {
    foreach(_feedapi_suitable_parsers('', TRUE) as $module) {
      $result = array();  
      $result = module_invoke($module, 'feedapi_settings_form', 'parsers');
      if (is_array($result)) {
        $form['parsers'][$module] = $result;
      }
    }
    foreach(_feedapi_suitable_processors('', TRUE) as $module) {
      $result = array();
      $result = module_invoke($module, 'feedapi_settings_form', 'processors');
      if (is_array($result)) {
        $form['processors'][$module] = $result;
      }
    }
    if ($settings = _feedapi_get_settings($args)) {
      $form = _feedapi_populate($form, $settings);
    }
  }
  return $form;
}

/**
 * Auto-detect one possible parser and one feed and item processor to the given URL
 * It follows the order of the modules from the module's settings page
 *
 * @param $node
 */
function _feedapi_assign_parser_processor($url, $settings) {
  $parsers = _feedapi_suitable_parsers('', TRUE);
  // Get the parsers' weight
  $sorted_parsers = array();
  foreach ($parsers as $parser) {
    if ($settings['parsers'][$parser]['enabled']) {
      $sorted_parsers[$settings['parsers'][$parser]['weight']][] = $parser;
    }
  }
  $success = FALSE;
  $keys = array_keys($sorted_parsers);
  if (count($keys) > 0) {
    $low = min($keys);
    $max = max($keys);
    // Call the ordered parsers to find all the compatible
    $parsers = array();
    $parsers['secondary'] = array();
    for ($i = $low; $i <= $max; $i++) {
      if (isset($sorted_parsers[$i])) {
        foreach ($sorted_parsers[$i] as $parser) {
          $type = module_invoke($parser, 'feedapi_compatible', $url);
          if (!isset($parsers['primary']) && is_string($type)) {
            $success = TRUE;
            $parsers['primary'] = $parser;
          }
          else if (is_string($type)) {
            $parsers['secondary'][] = $parser;
          }
        }
      }
    }
  }
  if (!$success) {
    // We can't found a suitable parser at all
    return array('type' => '', 'parser' => '', 'processor_item' => '');
  }
  // Get the feed item processor's weight
  $processors = _feedapi_suitable_processors($type);
  $processors = array_intersect($processors, array_keys($settings['processors']));
  foreach ($processors as $processor) {
    if ($settings['processors'][$processor]['enabled']) {
      $sorted_processors[$settings['processors'][$processor]['weight']][] = $processor;
    }
  }
  return array(
    'type' => $type,
    'parsers' => $parsers,
    'processors' => $sorted_processors
  );
}

/**
 * Collect a list of an arrays that fulfill the given requirements (hooks and type)
 * 
 * @param $type
 *  The descriptor of the feed type. For eg. "XML feed"
 * @param $all
 *  If you set this to TRUE, all the feed processors will be returned (not check the type)
 * @return
 *  An associative array with the names of the suitable feed processors
 */
function _feedapi_check_requirement($type, $hooks, $all) {
  $possible = array();
  $suitable = array();
  for ($i = count($hooks) - 1; $i >= 0; $i--) {
    $hooks[$i] = module_implements($hooks[$i]);
  }
  $possible = call_user_func_array('array_intersect', $hooks);
  foreach ($possible as $parser) {
    $types = module_invoke($parser, "feedapi_type");
    if (in_array($type, $types) || $all) {
      $suitable[] = $parser;
    }
  }
  return drupal_map_assoc($suitable);
}

/**
 * Get the list of the item processors for the given feed type
 *
 * @param $type
 *  The descriptor of the feed type. For eg. "XML feed"
 * @param $all
 *  If you set this to TRUE, all the item processors will be returned (not check the type)
 * @return
 *  An associative array with the names of the suitable feed processors
 */
function _feedapi_suitable_processors($type, $all = FALSE) {
  $req = array('feedapi_type', 'feedapi_item_save', 'feedapi_item_update',
               'feedapi_item_delete', 'feedapi_item_load',
               'feedapi_item_unique', 'feedapi_item_fetch_items',
  );
  return _feedapi_check_requirement($type, $req, $all);
}

/**
 * Remove non-existing processors from the processors arrays
 */
function _feedapi_sanitize_processors(&$feed) {
  if (is_array($feed->processors)) {
    foreach ($feed->processors as $processors) {
      foreach ($processors as $key => $processor) {
        if (!module_exists($processor)) {
          unset($feed->processors[$key]);
        }
      }
    }
  }
}