<?php

/**

 * Class for a set of entries for translation and their associated headers

 *

 * @version $Id: translations.php 291 2009-10-21 05:46:08Z nbachiyski $

 * @package pomo

 * @subpackage translations

 */

require_once dirname(__FILE__) . '/entry.php';

if ( !class_exists( 'Translations' ) ):

class Translations {

	var $entries = array();

	var $headers = array();

	/**

	 * Add entry to the PO structure

	 *

	 * @param object &$entry

	 * @return bool true on success, false if the entry doesn't have a key

	 */

	function add_entry($entry) {

		if (is_array($entry)) {

			$entry = new Translation_Entry($entry);

		}

		$key = $entry->key();

		if (false === $key) return false;

		$this->entries[$key] = &$entry;

		return true;

	}

	/**

	 * Sets $header PO header to $value

	 *

	 * If the header already exists, it will be overwritten

	 *

	 * TODO: this should be out of this class, it is gettext specific

	 *

	 * @param string $header header name, without trailing :

	 * @param string $value header value, without trailing \n

	 */

	function set_header($header, $value) {

		$this->headers[$header] = $value;

	}

	function set_headers(&$headers) {

		foreach($headers as $header => $value) {

			$this->set_header($header, $value);

		}

	}

	function get_header($header) {

		return isset($this->headers[$header])? $this->headers[$header] : false;

	}

	function translate_entry(&$entry) {

		$key = $entry->key();

		return isset($this->entries[$key])? $this->entries[$key] : false;

	}

	function translate($singular, $context=null) {

		$entry = new Translation_Entry(array('singular' => $singular, 'context' => $context));

		$translated = $this->translate_entry($entry);

		return ($translated && !empty($translated->translations))? $translated->translations[0] : $singular;

	}

	/**

	 * Given the number of items, returns the 0-based index of the plural form to use

	 *

	 * Here, in the base Translations class, the commong logic for English is implmented:

	 * 	0 if there is one element, 1 otherwise

	 *

	 * This function should be overrided by the sub-classes. For example MO/PO can derive the logic

	 * from their headers.

	 *

	 * @param integer $count number of items

	 */

	function select_plural_form($count) {

		return 1 == $count? 0 : 1;

	}

	function get_plural_forms_count() {

		return 2;

	}

	function translate_plural($singular, $plural, $count, $context = null) {

		$entry = new Translation_Entry(array('singular' => $singular, 'plural' => $plural, 'context' => $context));

		$translated = $this->translate_entry($entry);

		$index = $this->select_plural_form($count);

		$total_plural_forms = $this->get_plural_forms_count();

		if ($translated && 0 <= $index && $index < $total_plural_forms &&

				is_array($translated->translations) &&

				isset($translated->translations[$index]))

			return $translated->translations[$index];

		else

			return 1 == $count? $singular : $plural;

	}

	/**

	 * Merge $other in the current object.

	 *

	 * @param Object &$other Another Translation object, whose translations will be merged in this one

	 * @return void

	 **/

	function merge_with(&$other) {

		$this->entries = array_merge($this->entries, $other->entries);

	}

}

class Gettext_Translations extends Translations {

	/**

	 * The gettext implmentation of select_plural_form.

	 *

	 * It lives in this class, because there are more than one descendand, which will use it and

	 * they can't share it effectively.

	 *

	 */

	function gettext_select_plural_form($count) {

		if (!isset($this->_gettext_select_plural_form) || is_null($this->_gettext_select_plural_form)) {

			list( $nplurals, $expression ) = $this->nplurals_and_expression_from_header($this->get_header('Plural-Forms'));

			$this->_nplurals = $nplurals;

			$this->_gettext_select_plural_form = $this->make_plural_form_function($nplurals, $expression);

		}

		return call_user_func($this->_gettext_select_plural_form, $count);

	}

	function nplurals_and_expression_from_header($header) {

		if (preg_match('/^\s*nplurals\s*=\s*(\d+)\s*;\s+plural\s*=\s*(.+)$/', $header, $matches)) {

			$nplurals = (int)$matches[1];

			$expression = trim($this->parenthesize_plural_exression($matches[2]));

			return array($nplurals, $expression);

		} else {

			return array(2, 'n != 1');

		}

	}

	/**

	 * Makes a function, which will return the right translation index, according to the

	 * plural forms header

	 */

	function make_plural_form_function($nplurals, $expression) {

		$expression = str_replace('n', '$n', $expression);

		$func_body = "

			\$index = (int)($expression);

			return (\$index < $nplurals)? \$index : $nplurals - 1;";

		return create_function('$n', $func_body);

	}

	/**

	 * Adds parantheses to the inner parts of ternary operators in

	 * plural expressions, because PHP evaluates ternary oerators from left to right

	 * 

	 * @param string $expression the expression without parentheses

	 * @return string the expression with parentheses added

	 */

	function parenthesize_plural_exression($expression) {

		$expression .= ';';

		$res = '';

		$depth = 0;

		for ($i = 0; $i < strlen($expression); ++$i) {

			$char = $expression[$i];

			switch ($char) {

				case '?':

					$res .= ' ? (';

					$depth++;

					break;

				case ':':

					$res .= ') : (';

					break;

				case ';':

					$res .= str_repeat(')', $depth) . ';';

					$depth= 0;

					break;

				default:

					$res .= $char;

			}

		}

		return rtrim($res, ';');

	}

	function make_headers($translation) {

		$headers = array();

		// sometimes \ns are used instead of real new lines

		$translation = str_replace('\n', "\n", $translation);

		$lines = explode("\n", $translation);

		foreach($lines as $line) {

			$parts = explode(':', $line, 2);

			if (!isset($parts[1])) continue;

			$headers[trim($parts[0])] = trim($parts[1]);

		}

		return $headers;

	}

	function set_header($header, $value) {

		parent::set_header($header, $value);

		if ('Plural-Forms' == $header) {

			list( $nplurals, $expression ) = $this->nplurals_and_expression_from_header($this->get_header('Plural-Forms'));

			$this->_nplurals = $nplurals;

			$this->_gettext_select_plural_form = $this->make_plural_form_function($nplurals, $expression);

		}

	}

}

endif;

if ( !class_exists( 'NOOP_Translations' ) ):

/**

 * Provides the same interface as Translations, but doesn't do anything

 */

class NOOP_Translations {

	var $entries = array();

	var $headers = array();

	function add_entry($entry) {

		return true;

	}

	function set_header($header, $value) {

	}

	function set_headers(&$headers) {

	}

	function get_header($header) {

		return false;

	}

	function translate_entry(&$entry) {

		return false;

	}

	function translate($singular, $context=null) {

		return $singular;

	}

	function select_plural_form($count) {

		return 1 == $count? 0 : 1;

	}

	function get_plural_forms_count() {

		return 2;

	}

	function translate_plural($singular, $plural, $count, $context = null) {

			return 1 == $count? $singular : $plural;

	}

	function merge_with(&$other) {

	}

}

endif;