<?php

###############################################################################
#
# Copyright (c) 2009 Logimake, Inc.
#
# Orignially distributed by bugzappy at http://www.bugzappy.com
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
##############################################################################
#
# Bugzappy's PHP Debug Ouput class
#
# Please post questions and comments at:
#
#	http://www.bugzappy.com/2009/04/23/debug-output-class
#
# or send email to:
#
#	bugzappy@logimake.com
#
##############################################################################



/* We make use of the Zend_Registry because it keeps the global variable space
 * un-cluttered and it avoids name clashes. If we want to use this class without
 * making use of Zend_Registry, you can easily modify this code for that purpose.
 */

require_once 'Zend/Registry.php';


/* DebugOutput class
 *
 * This class follows the singleton pattern. It is also its own factory, which
 * is weaker than having a separate factrory class. But in this case I don't
 * think the extra complexity is needed.
 *
 * The one nice feature about this class is that it has a 'deferred ouput' mode.
 * In that mode, all the debug output commands add to a list of output messages.
 * The output messages are not echoed to the reponse. Instead they are stored
 * in a variable ni the singleton. It's then a simple static method call to
 * retrieve that list of outputs and process it. This is useful if you want your
 * debugged output to be grouped ni your HML output. so it does not break the
 * structure and layout of your output.
 *
 * This class is used entirely with static calls. Access to the singleton is
 * completely encaspulated within these static methods. The singleton is stored
 * in the Zend_Registry for the duration of the script execution. In the code,
 * the methods prefixed with an underscore ("_") are non-static, and protected.
 * These methods can be called by the static methods of the class, which in
 * turn can be called by any portion of your code without having to instantiate
 * an object, or even call the factory to get the singleton.
 *
 * Outputting debugging messages is really not something that should force the
 * developer to use OOP. So that's why I encapsulated everything in static
 * methods. Furthermore, I added a couple convenience methods outside the scope
 * of the class, at the bottom of this file. This way you can act totally
 * procedural, and write something like
 * 		_debug($myVariable, 'my var is equal to');
 *
 */

class DebugOutput
{

	const NO_OUTPUT = 'no_output';
	const INLINE_PRE_OUTPUT = 'inline_pre_output';
	const INLINE_COMMENT_OUTPUT = 'inline_comment_output';
	const DEFERRED_OUTPUT = 'DEFERRED_OUTPUT';
	const REGISTRY_INDEX = 'DebugOutput_Singleton';

	protected $outputType;
	protected $deferredOutput;


	protected static function getSingelton()
	{
    	if (Zend_Registry::isRegistered(self::REGISTRY_INDEX)) {
    		$singleton = Zend_Registry::get(self::REGISTRY_INDEX);
		}
		else
		{
			$singleton = new self();
			Zend_Registry::set(self::REGISTRY_INDEX, $singleton);
		}
		return $singleton;
	}


	protected function __construct()
	{
		$this->outputType = self::NO_OUTPUT;
	}


	public static function setOutputType($outputType)
	{
		$singleton = self::getSingelton();

		switch ($outputType) {
			case self::INLINE_PRE_OUTPUT:
			case self::INLINE_COMMENT_OUTPUT:
			case self::DEFERRED_OUTPUT:
			case self::NO_OUTPUT:
				return $singleton->_setOutputType($outputType);
				break;
			default:
				return $singleton->_setOutputType(self::NO_OUTPUT);
		}
	}


	protected function _setOutputType($outputType)
	{
		$this->outputType = $outputType;
	}


	public static function output($d, $label="*debug* ", $exitHere = false)
	{
		$singleton = self::getSingelton();
		return $singleton->_output($d, $label, $exitHere);
	}

	protected function _output($d, $label, $exitHere)
	{
		if ($this->outputType != self::NO_OUTPUT )
		{

			if ($this->outputType == self::DEFERRED_OUTPUT)
			{
				if (!isset($this->deferredOutput) || !is_array($this->deferredOutput))
					$this->deferredOutput = array();
				$this->deferredOutput[] = array('label' => $label, 'value' => $d);
			}
			else
			{
				switch ($this->outputTyp)
				{
					case self::INLINE_PRE_OUTPUT :
						$__debugUtilLabelPrefix = "\n<pre>\n";
						$__debugUtilLabelSuffix = ":\n\n";
						$__debugUtilDataPrefix = "";
						$__debugUtilDataSuffix = "\n</pre>\n";
						break;
					case self::INLINE_COMMENT_OUTPUT :
					default:
						$__debugUtilLabelPrefix = "\n<!--\n";
						$__debugUtilLabelSuffix = ":\n\n";
						$__debugUtilDataPrefix = "";
						$__debugUtilDataSuffix = "\n-->\n";
						break;
				}
				echo $__debugUtilLabelPrefix . $label . $__debugUtilLabelSuffix;
				echo $__debugUtilDataPrefix;
				print_r($d);
				echo $__debugUtilDataSuffix;
			}
		}
		if ($exitHere)
		{
			if ($this->outputType == self::DEFERRED_OUTPUT)
			{
				echo "<p>Exiting early; deferred debug output shown here:</p>\n";
				echo $this->_getDeferredOutputAsPre();
			}
			exit();
		}
	}


	public function getDeferredOutput()
	{
		$singleton = self::getSingelton();
		return $singleton->_getDeferredOutput();
	}


	protected function _getDeferredOutput()
	{
		if ($this->outputType == self::DEFERRED_OUTPUT)
		{
			if (!isset($this->deferredOutput) || !is_array($this->deferredOutput))
				$this->deferredOutput = array();
			return $this->deferredOutput;
		}
		else
			return null;
	}


	public function getDeferredOutputAsPre()
	{
		$singleton = self::getSingelton();
		return $singleton->_getDeferredOutputAsPre();
	}


	protected function _getDeferredOutputAsPre()
	{
		if ($this->outputType == self::DEFERRED_OUTPUT)
		{
			if (!isset($this->deferredOutput) || !is_array($this->deferredOutput))
				$this->deferredOutput = array();
			$str = "";
			foreach ($this->deferredOutput as $debugElement)
			{
				$label = $debugElement['label'];
				$d = $debugElement['value'];
				$__debugUtilLabelPrefix = "\n<pre>\n";
				$__debugUtilLabelSuffix = ":\n\n";
				$__debugUtilDataPrefix = "";
				$__debugUtilDataSuffix = "\n</pre>\n";
				$str .= $__debugUtilLabelPrefix . $label . $__debugUtilLabelSuffix;
				$str .= $__debugUtilDataPrefix;
				$str .= print_r($d, true);
				$str .= $__debugUtilDataSuffix;
			}

			return $str;
		}
		else
			return "";
	}
}


function _debugAndStop($d, $label="*debug* ")
{
	_debug($d, $label, true);
}

function _debug($d, $label='*debug* ', $exitHere=false)
{
	DebugOutput::output($d, $label, $exitHere);
}