<?php

/*

 * Enano - an open-source CMS capable of wiki functions, Drupal-like sidebar blocks, and everything in between

 * Copyright (C) 2006-2009 Dan Fuhry

 *

 * This program is Free Software; you can redistribute and/or modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied

 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for details.

 */

/**

 * Framework for parsing and rendering various formats. In Enano by default, this is MediaWiki-style wikitext being

 * rendered to XHTML, but this framework allows other formats to be supported as well.

 *

 * @package Enano

 * @subpackage Content

 * @author Dan Fuhry <dan@enanocms.org>

 * @copyright (C) 2009 Enano CMS Project

 * @license GNU General Public License, version 2 or later <http://www.gnu.org/licenses/gpl-2.0.html>

 */

class Carpenter

{

	/**

 	* Parser token

 	* @const string

 	*/

	const PARSER_TOKEN = "\xFF";

	/**

 	* Parsing engine

 	* @var string

 	*/

	private $parser = 'mediawiki';

	/**

 	* Rendering engine

 	* @var string

 	*/

	private $renderer = 'xhtml';

	/**

 	* Rendering flags

 	*/

	public $flags = RENDER_WIKI_DEFAULT;

	/**

 	* List of rendering rules

 	* @var array

 	*/

	private $rules = array(

			'lang',

			'templates',

			'blockquote',

			'code',

			'tables',

			'heading',

			'hr',

			// note: can't be named list ("list" is a PHP language construct)

			'multilist',

			'bold',

			'italic',

			'underline',

			'image',

			'externalwithtext',

			'externalnotext',

			'mailtowithtext',

			'mailtonotext',

			'internallink',

			'paragraph',

			'blockquotepost'

		);

	/**

 	* List of render hooks

 	* @var array

 	*/

	private $hooks = array();

	/* private $rules = array('prefilter', 'delimiter', 'code', 'function', 'html', 'raw', 'include', 'embed', 'anchor',

 					'heading', 'toc', 'horiz', 'break', 'blockquote', 'list', 'deflist', 'table', 'image',

 					'phplookup', 'center', 'newline', 'paragraph', 'url', 'freelink', 'interwiki',

 					'wikilink', 'colortext', 'strong', 'bold', 'emphasis', 'italic', 'underline', 'tt',

 					'superscript', 'subscript', 'revise', 'tighten'); */

	/**

 	* Render the text!

 	* @param string Text to render

 	* @return string

 	*/

	public function render($text)

	{

		$parser_class = "Carpenter_Parse_" . ucwords($this->parser);

		$renderer_class = "Carpenter_Render_" . ucwords($this->renderer);

		// empty? (don't remove this. the parser will shit bricks later about rules returning empty strings)

		if ( trim($text) === '' )

			return $text;

		// include files, if we haven't already

		if ( !class_exists($parser_class) )

		{

			require_once( ENANO_ROOT . "/includes/wikiengine/parse_{$this->parser}.php");

		}

		if ( !class_exists($renderer_class) )

		{

			require_once( ENANO_ROOT . "/includes/wikiengine/render_{$this->renderer}.php");

		}

		$parser = new $parser_class;

		$renderer = new $renderer_class;

		// run prehooks

		foreach ( $this->hooks as $hook )

		{

			if ( $hook['when'] === PO_FIRST )

			{

				$text = call_user_func($hook['callback'], $text);

				if ( !is_string($text) || empty($text) )

				{

					trigger_error("Hook returned empty/invalid text: " . print_r($hook['callback'], true), E_USER_WARNING);

					// *sigh*

					$text = '';

				}

			}

		}

		// perform render

		foreach ( $this->rules as $rule )

		{

			// run prehooks

			foreach ( $this->hooks as $hook )

			{

				if ( $hook['when'] === PO_BEFORE && $hook['rule'] === $rule )

				{

					$text = call_user_func($hook['callback'], $text);

					if ( !is_string($text) || empty($text) )

					{

						trigger_error("Hook returned empty/invalid text: " . print_r($hook['callback'], true), E_USER_WARNING);

						// *sigh*

						$text = '';

					}

				}

			}

			// execute rule

			$text_before = $text;

			$text = $this->perform_render_step($text, $rule, $parser, $renderer);

			if ( empty($text) )

			{

				trigger_error("Wikitext was completely empty after rule \"$rule\"; restoring backup", E_USER_WARNING);

				$text = $text_before;

			}

			unset($text_before);

			// run posthooks

			foreach ( $this->hooks as $hook )

			{

				if ( $hook['when'] === PO_AFTER && $hook['rule'] === $rule )

				{

					$text = call_user_func($hook['callback'], $text);

					if ( !is_string($text) || empty($text) )

					{

						trigger_error("Hook returned empty/invalid text: " . print_r($hook['callback'], true), E_USER_WARNING);

						// *sigh*

						$text = '';

					}

				}

			}

			RenderMan::tag_strip_push('final', $text, $final_stripdata);

		}

		RenderMan::tag_unstrip('final', $text, $final_stripdata);

		// run posthooks

		foreach ( $this->hooks as $hook )

		{

			if ( $hook['when'] === PO_LAST )

			{

				$text = call_user_func($hook['callback'], $text);

				if ( !is_string($text) || empty($text) )

				{

					trigger_error("Hook returned empty/invalid text: " . print_r($hook['callback'], true), E_USER_WARNING);

					// *sigh*

					$text = '';

				}

			}

		}

		return (( defined('ENANO_DEBUG') && isset($_GET['parserdebug']) ) ? '<pre>' . htmlspecialchars($text) . '</pre>' : $text) . "\n\n";

	}

	/**

 	* Performs a step in the rendering process.

 	* @param string Text to render

 	* @param string Rule to execute

 	* @param object Parser instance

 	* @param object Renderer instance

 	* @return string

 	* @access private

 	*/

	private function perform_render_step($text, $rule, $parser, $renderer)

	{

		// First look for a direct function

		if ( function_exists("parser_{$this->parser}_{$this->renderer}_{$rule}") )

		{

			return call_user_func("parser_{$this->parser}_{$this->renderer}_{$rule}", $text, $this->flags);

		}

		// We don't have that, so start looking for other ways or means of doing this

		if ( method_exists($parser, $rule) && method_exists($renderer, $rule) )

		{

			// Both the parser and render have callbacks they want to use.

			$pieces = $parser->$rule($text);

			$text = call_user_func(array($renderer, $rule), $text, $pieces);

		}

		else if ( method_exists($parser, $rule) && !method_exists($renderer, $rule) && isset($renderer->rules[$rule]) )

		{

			// The parser has a callback, but the renderer does not

			$pieces = $parser->$rule($text);

			$text = $this->generic_render($text, $pieces, $renderer->rules[$rule]);

		}

		else if ( !method_exists($parser, $rule) && isset($parser->rules[$rule]) && method_exists($renderer, $rule) )

		{

			// The parser has no callback, but the renderer does

			$text = preg_replace_callback($parser->rules[$rule], array($renderer, $rule), $text);

		}

		else if ( isset($parser->rules[$rule]) && isset($renderer->rules[$rule]) )

		{

			// This is a straight-up regex only rule

			$text = preg_replace($parser->rules[$rule], $renderer->rules[$rule], $text);

		}

		else

		{

			// Either the renderer or parser does not support this rule, ignore it

		}

		return $text;

	}

	/**

 	* Generic renderer

 	* @access protected

 	*/

	protected function generic_render($text, $pieces, $rule)

	{

		foreach ( $pieces as $i => $piece )

		{

			$replacement = $rule;

			// if the piece is an array, replace $1, $2, etc. in the rule with each value in the piece

			if ( is_array($piece) )

			{

				$j = 0;

				foreach ( $piece as $part )

				{

					$j++;

					$replacement = str_replace(array("\\$j", "\${$j}"), $part, $replacement);

				}

			}

			// else, just replace \\1 or $1 in the rule with the piece

			else

			{

				$replacement = str_replace(array("\\1", "\$1"), $piece, $replacement);

			}

			$text = str_replace(self::generate_token($i), $replacement, $text);

		}

		return $text;

	}

	/**

 	* Add a hook into the parser.

 	* @param callback Function to call

 	* @param int PO_* constant

 	* @param string If PO_{BEFORE,AFTER} used, rule

 	*/

	public function hook($callback, $when, $rule = false)

	{

		if ( !is_int($when) )

			return null;

		if ( ($when == PO_BEFORE || $when == PO_AFTER) && !is_string($rule) )

			return null;

		if ( ( is_string($callback) && !function_exists($callback) ) || ( is_array($callback) && !method_exists($callback[0], $callback[1]) ) || ( !is_string($callback) && !is_array($callback) ) )

		{

			trigger_error("Attempt to hook with undefined function/method " . print_r($callback, true), E_USER_ERROR);

			return null;

		}

		$this->hooks[] = array(

				'callback' => $callback,

				'when'     => $when,

				'rule'     => $rule

			);

	}

	/**

 	* Disable a render stage

 	* @param string stage

 	* @return null

 	*/

	public function disable_rule($rule)

	{

		foreach ( $this->rules as $i => $current_rule )

		{

			if ( $current_rule === $rule )

			{

				unset($this->rules[$i]);

				return null;

			}

		}

		return null;

	}

	/**

 	* Disables all rules.

 	* @return null

 	*/

	public function disable_all_rules()

	{

		$this->rules = array();

		return null;

	}

	/**

 	* Enables a rule

 	* @param string rule

 	* @return null

 	*/

	public function enable_rule($rule)

	{

		$this->rules[] = $rule;

		return null;

	}

	/**

 	* Make a rule exclusive (the only one called)

 	* @param string stage

 	* @return null

 	*/

	public function exclusive_rule($rule)

	{

		if ( is_string($rule) )

			$this->rules = array($rule);

		return null;

	}

	/**

 	* Generate a token

 	* @param int Token index

 	* @return string

 	* @static

 	*/

	public static function generate_token($i)

	{

		return self::PARSER_TOKEN . $i . self::PARSER_TOKEN;

	}

	/**

 	* Tokenize string

 	* @param string

 	* @param array Matches

 	* @return string

 	* @static

 	*/

	public static function tokenize($text, $matches)

	{

		$matches = array_values($matches);

		foreach ( $matches as $i => $match )

		{

			$text = str_replace_once($match, self::generate_token($i), $text);

		}

		return $text;

	}

}