<?php
// $Id$

define('CONTEST_PENDING_PHASE', 0);
define('CONTEST_VOTING_PHASE', 1);
define('CONTEST_BLACKOUT_PHASE', 2);
define('CONTEST_CLOSED_PHASE', 3);

/**
 * Implementation of hook_access
 */
function contest_access($op, $node, $account) {
  if ($op == 'create' || $op == 'update' || $op == 'delete') {
    return user_access('manage contests');
  }
  else if ($op == 'view') {
    if ($node->contest_phase == CONTEST_PENDING_PHASE) {
      return user_access('manage contests');
    }
  }
}

/**
 * Implementation of hook_help
 */
function contest_help($path, $arg) {
  switch ($path) {
    case 'admin/help#contest':
      return '<p>'. t('The contest module allows a contest creator to add multiple nodes to a contest which will then be placed into a round robin contest of 1 on 1.  Each time the user reloads the page, another tuple will appear for them to choose from. So if you have a lot of nodes to \'fight\' against each other, then more fun for the user!') .'</p>';
  }
}

/**
 * Implementation of hook_perm
 */
function contest_perm() {
  return array('administer contests', 'manage contests', 'vote in contest');
}

/**
 * Implementation of hook_menu
 */
function contest_menu() {
  $items = array();
  $items['contest/%node/change_phase/voting'] = array(
    'title' => 'Change to voting phase',
    'page callback' => 'contest_set_voting_phase',
    'page arguments' => array(1),
    'access callback' => 'user_access',
    'access arguments' => array('manage contests'),
    'type' => MENU_CALLBACK,
  );
  $items['contest/%node/change_phase/blackout'] = array(
    'title' => 'Change to voting phase',
    'page callback' => 'contest_set_blackout_phase',
    'page arguments' => array(1),
    'access callback' => 'user_access',
    'access arguments' => array('manage contests'),
    'type' => MENU_CALLBACK,
  );
  $items['contest/%node/change_phase/closed'] = array(
    'title' => 'Change to voting phase',
    'page callback' => 'contest_set_closed_phase',
    'page arguments' => array(1),
    'access callback' => 'user_access',
    'access arguments' => array('manage contests'),
    'type' => MENU_CALLBACK,
  );
  $items['contest/js/vote'] = array(
    'page callback' => 'contest_js_vote',
    'access arguments' => array('vote in contest'),
    'type' => MENU_CALLBACK,
  );
  return $items;
}

/**
 * Implementation of hook_node_info
 */
function contest_node_info() {
  return array(
    'contest' => array(
      'name' => t('Contest'),
      'module' => 'contest',
      'description' => t('Creates a contest consisting of N nodes which then participate in a round-robin contest'),
      'has_title' => TRUE,
      'title_label' => t('Contest Title'),
      'has_body' => TRUE,
      'body_label' => t('Contest details'),
      'locked' => TRUE,
    )
  );
}

/**
 * Return types of allowed contests
 */
function contest_types() {
  static $contest_types;
  if (!isset($contest_types)) {
    $contest_types = array(
      'nodes' => t('Nodes'),
      'users' => t('Users'),
    );
  }
  return $contest_types;
}

/**
 * Implementation of hook_form
 */
function contest_form(&$node, &$param) {
  $type = node_get_types('type', $node);

  $form = array();
  $form['title'] = array(
    '#type' => 'textfield',
    '#title' => check_plain($type->title_label),
    '#default_value' => $node->title,
    '#required' => TRUE,
  );
  $form['body'] = array(
    '#type' => 'textarea',
    '#title' => check_plain($type->body_label),
    '#default_value' => $node->body,
    '#rows' => 10,
    '#required' => TRUE,
  );
  if (module_exists('filter')) {
    $node->format = isset($node->format) ? $node->format : FILTER_FORMAT_DEFAULT;
    $form['format'] = filter_form($node->format);
  }
  $form['contest_type'] = array(
    '#type' => 'radios',
    '#title' => t('Type of contest'),
    '#default_value' => $node->contest_type,
    '#options' => contest_types(),
    '#required' => TRUE,
  );
  $form['contestants'] = array(
    '#type' => 'textarea',
    '#title' => t('Nodes for contest'),
    '#description' => t('The nodes that are participating in this competition (type one ID per line)'),
    '#default_value' => implode("\n", $node->contestants),
    '#rows' => 15,
    '#required' => TRUE,
  );
  $form['contenders_per_vote'] = array(
    '#type' => 'textfield',
    '#title' => t('Contenders per showdown'),
    '#description' => t('The number of contenders that the user must choose between per vote-off (between 2 and 99)'),
    '#default_value' => ($node->contenders_per_vote) ? $node->contenders_per_vote : 2,
    '#size' => 2,
    '#maxlength' => 2,
    '#required' => TRUE,
  );

  $form['contest_phase'] = array(
    '#type' => 'radios',
    '#title' => t('Select the phase of the contest'),
    '#description' => t("Pending means the contest is not yet ready for users to vote for, voting means users can vote and see the current results, blackout means the users can vote but not see the results while closed means the users will only see the results of the contest."),
    '#options' => _contest_get_phases(),
    '#default_value' => isset($node->contest_phase) ? $node->contest_phase : CONTEST_PENDING_PHASE,
    '#required' => TRUE,
  );

  return $form;
}

/**
 * Implementation of hook_validate
 *
 * At time to contest create/edit, make sure the expressed nodes are valid
 */
function contest_validate($node) {
  // Validate the number of contestants
  $size = 2;
  if (!preg_match('/^[1-9][0-9]*$/', $node->contenders_per_vote) || $node->contenders_per_vote < 2) {
    form_set_error('contenders_per_vote', t('Invalid number of contenders per vote.  Please select a value between 2 and 99'));
  }
  else {
    $size = $node->contenders_per_vote;
  }

  // Validate that the contestants are published for users to view
  $contestants = explode("\n", preg_replace('/\r\n|\r/', "\n", trim($node->contestants)));
  $contestants = array_unique($contestants);
  if (sizeof($contestants) < $size) {
    form_set_error('contestants', t('Need more contestants'));
    return;
  }
  $check = TRUE;
  foreach ($contestants as $contestant) {
    if (!preg_match('/^[1-9][0-9]*$/', $contestant)) {
      form_set_error('contestants', t('Invalid format of contestant ID specified: @contestant', array('@contestant' => $contestant)));
      $check = FALSE;
    }
    else {
      if ('users' === $node->contest_type) {
        $result = db_result(db_query("SELECT uid FROM {users} WHERE uid=%d AND status = 1", $contestant));
      }
      else {
        $result = db_result(db_query("SELECT nid FROM {node} WHERE nid=%d AND status = 1", $contestant));
      }
      if ($result != $contestant) {
        form_set_error('contestants', t('Contestant is not published: @contestant', array('@contestant' => $contestant)));
        $check = FALSE;
      }
    }
  }
  if ($check === FALSE) {
    return;
  }

  // Validate the current status of the contest
  if ($node->contest_phase < CONTEST_PENDING_PHASE || $node->contest_phase > CONTEST_CLOSED_PHASE) {
    form_set_error('contest_phase', t('Invalid contest phase.  Choose correctly from the list.'));
  }
}

/**
 * Implementation of hook_insert
 */
function contest_insert($node) {
  $contestants = explode("\n", preg_replace('/\r\n|\r/', "\n", trim($node->contestants)));
  $contestants = serialize(array_unique($contestants));
  db_query("INSERT INTO {contest} (nid, contest_type, contestants, contenders_per_vote, contest_phase) VALUES (%d, '%s', '%s', %d, %d)",
    $node->nid, $node->contest_type, $contestants, $node->contenders_per_vote, $node->contest_phase);
}

/**
 * Implementation of hook_update
 */
function contest_update($node) {
  cache_clear_all("contest-$node->nid-contestants", 'cache');
  $contestants = explode("\n", preg_replace('/\r\n|\r/', "\n", trim($node->contestants)));
  $contestants = serialize(array_unique($contestants));
  db_query("UPDATE {contest} SET contest_type='%s', contestants='%s', contenders_per_vote=%d, contest_phase=%d WHERE nid=%d",
    $node->contest_type, $contestants, $node->contenders_per_vote, $node->contest_phase, $node->nid);
}

/**
 * Implementation of hook_load
 */
function contest_load($node) {
  $additions = db_fetch_object(db_query("SELECT * FROM {contest} WHERE nid=%d", $node->nid));
  $additions->contestants = unserialize($additions->contestants);
  $additions->contestant_objects = cache_get("contest-$node->nid-contestants");
  if (empty($additions->contestant_objects)) {
    $additions->contestant_objects = array();
    foreach ($additions->contestants as $contestant) {
      $additions->contestant_objects["contestant-$contestant"] = _contest_load_object($contestant, $node->contest_type);
    }
    cache_set("contest-$node->nid-contestants", $additions->contestant_objects);
  }
  else {
    $additions->contestant_objects = $additions->contestant_objects->data;
  }
  $additions->contest_phase = intval($additions->contest_phase);
  return $additions;
}

/*
function contest_link($type, $object, $teaser) {
  $links = array();
  if ($type === 'node' && !$teaser) {
    if ($object->type === 'contest' && user_access('manage contests')) {
      if ($object->contest_phase === CONTEST_PENDING_PHASE) {
        $links['contest_'. $object->nid .'_voting'] = array(
          'title' => t('Change to voting phase'),
          'href' => "contest/$object->nid/change_phase/voting",
          'attributes' => array('title' => t('Allow users to vote on this contest')),
        );
      }
      if ($object->contest_phase === CONTEST_VOTING_PHASE) {
        $links['contest_'. $object->nid .'_blackout'] = array(
          'title' => t('Change to blackout phase'),
          'href' => "contest/$object->nid/change_phase/blackout",
          'attributes' => array('title' => t('Allow users to vote on this contest but do not show the results')),
        );
      }
      if ($object->contest_phase === CONTEST_BLACKOUT_PHASE) {
        $links['contest_'. $object->nid .'_voting'] = array(
          'title' => t('Change to closed phase'),
          'href' => "contest/$object->nid/change_phase/closed",
          'attributes' => array('title' => t('Stop voting and allow users to see the results!')),
        );
      }
    }
  }
  return $links;
}
*/

/**
 * Implementation of hook_view
 */
function contest_view($node, $teaser = FALSE, $page = FALSE, $links = FALSE) {
  node_prepare($node);
  unset($node->content['body']);
  $content = '';
  if ($node->contest_phase === CONTEST_VOTING_PHASE || $node->contest_phase === CONTEST_BLACKOUT_PHASE) {
    $content .= theme('contest_entry_list', _contest_get_contender_forms($node));
  }
  $content .= theme('contest_details', $node->body);
  if ($node->contest_phase === CONTEST_VOTING_PHASE ||
      $node->contest_phase === CONTEST_CLOSED_PHASE ||
      user_access('administer contests') ||
      user_access('manage contests')) {
    $content .= theme('contest_results', contest_get_results($node));
  }
  if ($page) {
    $node->content['contest'] = array(
      '#value' => '<div id="contest-container">'. $content .'</div>'
    );
  }
  else {
    $node->content['contest'] = array(
      '#value' => $content
    );
  }
  return $node;
}

function contest_get_results($node) {
  $results = cache_get("contest-$node->nid-results");
  if ($node->contest_phase !== CONTEST_CLOSED_PHASE || empty($results)) {
    $contestants = $node->contestants;
    $results = array();
    foreach ($contestants as $contestant) {
      $criteria = array(
        'content_id' => $contestant,
        'content_type' => 'contest-'. $node->nid,
        'function' => 'count',
      );
      $results["contestant-$contestant"] = votingapi_select_results($criteria);
      $results["contestant-$contestant"] = (empty($results["contestant-$contestant"])) ? 0 : intval($results["contestant-$contestant"][0]['value']);
    }
    arsort($results, SORT_NUMERIC);
    if ($node->contest_phase === CONTEST_CLOSED_PHASE) {
      contest_set_results($node, $results);
    }
  }
  return $results;
}

function contest_forms() {
  $args = func_get_args();
  $form_id = $args[0];

  $forms = array();
  if (strpos($form_id, "contest_evaluate_form") === 0) {
    $forms[$form_id] = array('callback' => 'contest_evaluate_form');
  }
  return $forms;
}

function contest_set_results($node, $results) {
  cache_set("contest-$node->nid-results", $results);
}

/**
 * Return a contest evaluation form with the number of specified nodes
 */
function contest_evaluate_form($form_state, $node, $cid) {
  global $theme_key;
  $form = array('#cache' => TRUE);
  $form['#attributes']['class'] = 'contestant-form';
  $form['#validate'][] = 'contest_evaluate_form_validate';
  $form['#submit'][] = 'contest_evaluate_form_submit';

  $form['nid'] = array(
    '#type' => 'value',
    '#value' => $node->nid,
  );
  $form['cid'] = array(
    '#type' => 'value',
    '#value' => $cid,
  );

  if ($node->contest_type === 'users') {
    $theme = 'contest_user_view';
  }
  else {
    $theme = 'contest_node_view';
  }

  $form['op'] = array(
    '#prefix' => theme($theme, $node->contestant_objects["contestant-$cid"]),
    '#type' => 'submit',
//    '#type' => 'image_button',
//    '#src' => drupal_get_path('theme', $theme_key).'/images/contest-vote-button.gif',
    '#value' => t('Vote'),
    '#ahah' => array(
      'path' => 'contest/js/vote',
      'wrapper' => 'contest-container',
      'method' => 'replace',
      'effect' => 'fade'
    ),
  );
  return $form;
}

function contest_evaluate_form_submit($form, &$form_state) {
  global $user;
  $values = $form_state['values'];
  $op = $form_state['clicked_button']['#value'];
  if (t('Vote') === $op) {
    // Perform the voting
    $vote_id = $values['cid'];
    $nid = $values['nid'];
    $vote = array();
    $vote['content_type'] = "contest-$nid";
    $vote['content_id'] = $vote_id;
    $vote['value_type'] = 'points';
    $vote['value'] = 1;
    $criteria = array();
    votingapi_set_votes($vote, $criteria);
    if ($values['ahah'] !== TRUE) {
      drupal_set_message(t('Thank you for voting!'));
    }
  }
}

function contest_js_vote() {
  // Submit the form here
  $form_build_id = 'form_'. $_POST['form_build_id'];
  $cache = cache_get($form_build_id, 'cache_form');
  $form = $cache->data;
  $form_state = array('values' => $_POST);
  $form_state['values']['nid'] = $form['nid']['#value'];
  $form_state['values']['cid'] = $form['cid']['#value'];
  $form_state['values']['ahah'] = TRUE;
  $form_state['clicked_button']['#value'] = $form_state['values']['op'];
  contest_evaluate_form_submit($form, $form_state);

  // Rebuild a new form with new contestants
  $_POST = array();
  $node = $form['#parameters'][2];
  drupal_set_message(t('Thank you for voting!'));
  $content = theme('status_messages');
  $content .= node_view($node, TRUE, FALSE, FALSE);
  print drupal_to_js(array('status' => FALSE, 'data' => $content));
  cache_clear_all($form_build_id, 'cache_form');
}

function _contest_get_contender_forms($node) {
  $contenders = _contest_get_contenders($node);
  $forms = array();
  $id = 1;
  foreach ($contenders as $contender) {
    $forms[] = drupal_get_form("contest_evaluate_form-$id", $node, $contender);
    $id++;
  }
  return $forms;
}

function _contest_get_contenders($node) {
  $contestants = $node->contestants;
  $limit = $node->contenders_per_vote;
  $contenders = array();

  // Perform a seed to be on the safe side
  srand((float) microtime() * 10000000);
  $random_contestants = array_rand($contestants, $limit);
  foreach ($random_contestants as $value) {
    $contenders["contestant-$value"] = $contestants[$value];
  }
  $contenders_temp = $contenders;

  foreach ($contenders_temp as $key => $value) {
    $contenders[$key] = $value; // DO SOME THEMING STUFF SO IT WORKS BETTER FOR YOU THIS WAY!!!
  }
  return $contenders;
}

function _contest_load_object($oid, $type) {
  if ($type === 'user') {
    return user_load(array('uid' => $oid));
  }
  else {
    return node_load($oid);
  }
}

function _contest_get_phases() {
  return array(
    CONTEST_PENDING_PHASE => t('Pending'),
    CONTEST_VOTING_PHASE => t('Voting'),
    CONTEST_BLACKOUT_PHASE => t('Blackout'),
    CONTEST_CLOSED_PHASE => t('Closed'),
  );
}

/**
 * Implementation of hook_votingapi_results_alter
 */
function contest_votingapi_results_alter(&$cache, $votes, $content_type, $content_id = NULL) {
  // Remove any extra rows that aren't necessary - we only need the counter in this instance
  if (strpos($content_type, 'contest-') === 0) {
    unset($cache['vote']['points']['sum']);
    unset($cache['vote']['points']['average']);
  }
}

function contest_set_voting_phase($node) {
  if (!isset($node->contest_phase)) {
    return drupal_not_found();
  }
  db_query("UPDATE {contest} SET contest_phase = %d WHERE nid = %d", CONTEST_VOTING_PHASE, $node->nid);
  drupal_goto("node/$node->nid");
}

function contest_set_blackout_phase($node) {
  if (!isset($node->contest_phase)) {
    return drupal_not_found();
  }
  db_query("UPDATE {contest} SET contest_phase = %d WHERE nid = %d", CONTEST_BLACKOUT_PHASE, $node->nid);
  drupal_goto("node/$node->nid");
}

function contest_set_closed_phase($node) {
  if (!isset($node->contest_phase)) {
    return drupal_not_found();
  }
  db_query("UPDATE {contest} SET contest_phase = %d WHERE nid = %d", CONTEST_CLOSED_PHASE, $node->nid);
  $results = contest_get_results($node);
  contest_set_results($node, $results);
  drupal_goto("node/$node->nid");
}

/**
 * Implementation of hook_theme
 */
function contest_theme() {
  $themes = array();
  $themes['contest_details'] = array(
    'arguments' => array(
      'details' => '',
    ),
  );
  $themes['contest_entry_list'] = array(
    'arguments' => array(
      'list' => array(),
    ),
  );
  $themes['contest_entry_list_item'] = array(
    'arguments' => array(
      'item' => array(),
      'attributes' => array()
    ),
  );
  $themes['contest_results'] = array(
    'arguments' => array(
      'results' => array(),
    ),
  );
  $themes['contest_node_view'] = array(
    'template' => 'contest_node_view',
    'arguments' => array(
      'node' => NULL
    ),
  );
  $themes['contest_user_view'] = array(
    'template' => 'contest_user_view',
    'arguments' => array(
      'account' => NULL
    ),
  );
  return $themes;
}

function theme_contest_details($details = '') {
  $output = '';
  $output .= '<div class="contest-details-container">';
    $output .= $details;
  $output .= '</div>';
  return $output;
}

function theme_contest_entry_list($list = array()) {
  $output = '<ul class="contest-entry-list clear-block">';
  foreach ($list as $item) {
    $output .= theme('contest_entry_list_item', $item);
  }
  $output .= '</ul>';
  return $output;
}

function theme_contest_entry_list_item($item = null, $attributes = array()) {
  if (!empty($item)) {
    if (!isset($attributes['class'])) {
      $attributes['class'] = '';
    }
    $attributes['class'] .= ' contest-entry';
    $output = '<li '. drupal_attributes($attributes) .'>'. $item .'</li>';
  }
  return $output;
}

function theme_contest_results($results = array()) {
  $sum = 0;
  $header = array(t('Node ID'), t('Votes'));
  $rows = array();
  foreach ($results as $nid => $value) {
    $rows[] = array(str_replace('contestant-', '', $nid), $value);
  }
  return theme('table', $header, $rows);
}