<?php

/**

 * Zend Framework

 *

 * LICENSE

 *

 * This source file is subject to the new BSD license that is bundled

 * with this package in the file LICENSE.txt.

 * It is also available through the world-wide-web at this URL:

 * http://framework.zend.com/license/new-bsd

 * If you did not receive a copy of the license and are unable to

 * obtain it through the world-wide-web, please send an email

 * to license@zend.com so we can send you a copy immediately.

 *

 * @category   Zend

 * @package    Zend_Wildfire

 * @subpackage Plugin

 * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)

 * @license    http://framework.zend.com/license/new-bsd     New BSD License

 * @version    $Id: FirePhp.php 24593 2012-01-05 20:35:02Z matthew $

 */

/** Zend_Controller_Request_Abstract */

require_once('Zend/Controller/Request/Abstract.php');

/** Zend_Controller_Response_Abstract */

require_once('Zend/Controller/Response/Abstract.php');

/** Zend_Wildfire_Channel_HttpHeaders */

require_once 'Zend/Wildfire/Channel/HttpHeaders.php';

/** Zend_Wildfire_Protocol_JsonStream */

require_once 'Zend/Wildfire/Protocol/JsonStream.php';

/** Zend_Wildfire_Plugin_Interface */

require_once 'Zend/Wildfire/Plugin/Interface.php';

/**

 * Primary class for communicating with the FirePHP Firefox Extension.

 *

 * @category   Zend

 * @package    Zend_Wildfire

 * @subpackage Plugin

 * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)

 * @license    http://framework.zend.com/license/new-bsd     New BSD License

 */

class Zend_Wildfire_Plugin_FirePhp implements Zend_Wildfire_Plugin_Interface

{

    /**

     * Plain log style.

     */

    const LOG = 'LOG';

    /**

     * Information style.

     */

    const INFO = 'INFO';

    /**

     * Warning style.

     */

    const WARN = 'WARN';

    /**

     * Error style that increments Firebug's error counter.

     */

    const ERROR = 'ERROR';

    /**

     * Trace style showing message and expandable full stack trace.

     */

    const TRACE = 'TRACE';

    /**

     * Exception style showing message and expandable full stack trace.

     * Also increments Firebug's error counter.

     */

    const EXCEPTION = 'EXCEPTION';

    /**

     * Table style showing summary line and expandable table

     */

    const TABLE = 'TABLE';

    /**

     * Dump variable to Server panel in Firebug Request Inspector

     */

    const DUMP = 'DUMP';

    /**

     * Start a group in the Firebug Console

     */

    const GROUP_START = 'GROUP_START';

    /**

     * End a group in the Firebug Console

     */

    const GROUP_END = 'GROUP_END';

    /**

     * The plugin URI for this plugin

     */

    const PLUGIN_URI = 'http://meta.firephp.org/Wildfire/Plugin/ZendFramework/FirePHP/1.6.2';

    /**

     * The protocol URI for this plugin

     */

    const PROTOCOL_URI = Zend_Wildfire_Protocol_JsonStream::PROTOCOL_URI;

    /**

     * The structure URI for the Dump structure

     */

    const STRUCTURE_URI_DUMP = 'http://meta.firephp.org/Wildfire/Structure/FirePHP/Dump/0.1';

    /**

     * The structure URI for the Firebug Console structure

     */

    const STRUCTURE_URI_FIREBUGCONSOLE = 'http://meta.firephp.org/Wildfire/Structure/FirePHP/FirebugConsole/0.1';

    /**

     * Singleton instance

     * @var Zend_Wildfire_Plugin_FirePhp

     */

    protected static $_instance = null;

    /**

     * Flag indicating whether FirePHP should send messages to the user-agent.

     * @var boolean

     */

    protected $_enabled = true;

    /**

     * The channel via which to send the encoded messages.

     * @var Zend_Wildfire_Channel_Interface

     */

    protected $_channel = null;

    /**

     * Messages that are buffered to be sent when protocol flushes

     * @var array

     */

    protected $_messages = array();

    /**

     * Options for the object

     * @var array

     */

    protected $_options = array(

        'traceOffset' => 1, /* The offset in the trace which identifies the source of the message */

        'maxTraceDepth' => 99, /* Maximum depth for stack traces */

        'maxObjectDepth' => 10, /* The maximum depth to traverse objects when encoding */

        'maxArrayDepth' => 20, /* The maximum depth to traverse nested arrays when encoding */

        'includeLineNumbers' => true /* Whether to include line and file info for each message */

    );

    /**

     * Filters used to exclude object members when encoding

     * @var array

     */

    protected $_objectFilters = array();

    /**

     * A stack of objects used during encoding to detect recursion

     * @var array

     */

    protected $_objectStack = array();

    /**

     * Create singleton instance.

     *

     * @param string $class OPTIONAL Subclass of Zend_Wildfire_Plugin_FirePhp

     * @return Zend_Wildfire_Plugin_FirePhp Returns the singleton Zend_Wildfire_Plugin_FirePhp instance

     * @throws Zend_Wildfire_Exception

     */

    public static function init($class = null)

    {

        if (self::$_instance !== null) {

            require_once 'Zend/Wildfire/Exception.php';

            throw new Zend_Wildfire_Exception('Singleton instance of Zend_Wildfire_Plugin_FirePhp already exists!');

        }

        if ($class !== null) {

            if (!is_string($class)) {

                require_once 'Zend/Wildfire/Exception.php';

                throw new Zend_Wildfire_Exception('Third argument is not a class string');

            }

            if (!class_exists($class)) {

                require_once 'Zend/Loader.php';

                Zend_Loader::loadClass($class);

            }

            self::$_instance = new $class();

            if (!self::$_instance instanceof Zend_Wildfire_Plugin_FirePhp) {

                self::$_instance = null;

                require_once 'Zend/Wildfire/Exception.php';

                throw new Zend_Wildfire_Exception('Invalid class to third argument. Must be subclass of Zend_Wildfire_Plugin_FirePhp.');

            }

        } else {

            self::$_instance = new self();

        }

        return self::$_instance;

    }

    /**

     * Constructor

     * @return void

     */

    protected function __construct()

    {

        $this->_channel = Zend_Wildfire_Channel_HttpHeaders::getInstance();

        $this->_channel->getProtocol(self::PROTOCOL_URI)->registerPlugin($this);

    }

    /**

     * Get or create singleton instance

     *

     * @param bool $skipCreate True if an instance should not be created

     * @return Zend_Wildfire_Plugin_FirePhp

     */

    public static function getInstance($skipCreate=false)

    {

        if (self::$_instance===null && $skipCreate!==true) {

            return self::init();

        }

        return self::$_instance;

    }

    /**

     * Destroys the singleton instance

     *

     * Primarily used for testing.

     *

     * @return void

     */

    public static function destroyInstance()

    {

        self::$_instance = null;

    }

    /**

     * Enable or disable sending of messages to user-agent.

     * If disabled all headers to be sent will be removed.

     *

     * @param boolean $enabled Set to TRUE to enable sending of messages.

     * @return boolean The previous value.

     */

    public function setEnabled($enabled)

    {

        $previous = $this->_enabled;

        $this->_enabled = $enabled;

        if (!$this->_enabled) {

            $this->_messages = array();

            $this->_channel->getProtocol(self::PROTOCOL_URI)->clearMessages($this);

        }

        return $previous;

    }

    /**

     * Determine if logging to user-agent is enabled.

     *

     * @return boolean Returns TRUE if logging is enabled.

     */

    public function getEnabled()

    {

        return $this->_enabled;

    }

    /**

     * Set a single option

     *

     * @param  string $key The name of the option

     * @param  mixed $value The value of the option

     * @return mixed The previous value of the option

     */

    public function setOption($key, $value)

    {

      if (!array_key_exists($key,$this->_options)) {

        throw new Zend_Wildfire_Exception('Option with name "'.$key.'" does not exist!');

      }

      $previous = $this->_options[$key];

      $this->_options[$key] = $value;

      return $previous;

    }

    /**

     * Retrieve a single option

     *

     * @param  string $key The name of the option

     * @return mixed The value of the option

     */

    public function getOption($key)

    {

      if (!array_key_exists($key,$this->_options)) {

        throw new Zend_Wildfire_Exception('Option with name "'.$key.'" does not exist!');

      }

      return $this->_options[$key];

    }

    /**

     * Retrieve all options

     *

     * @return array All options

     */

    public function getOptions()

    {

      return $this->_options;

    }

    /**

     * Specify a filter to be used when encoding an object

     *

     * Filters are used to exclude object members.

     *

     * @param string $Class The class name of the object

     * @param array $Filter An array of members to exclude

     * @return void

     */

    public function setObjectFilter($class, $filter) {

      $this->_objectFilters[$class] = $filter;

    }

    /**

     * Starts a group in the Firebug Console

     *

     * @param string $title The title of the group

     * @param array $options OPTIONAL Setting 'Collapsed' to true will initialize group collapsed instead of expanded

     * @return TRUE if the group instruction was added to the response headers or buffered.

     */

    public static function group($title, $options=array())

    {

        return self::send(null, $title, self::GROUP_START, $options);

    }

    /**

     * Ends a group in the Firebug Console

     *

     * @return TRUE if the group instruction was added to the response headers or buffered.

     */

    public static function groupEnd()

    {

        return self::send(null, null, self::GROUP_END);

    }

    /**

     * Logs variables to the Firebug Console

     * via HTTP response headers and the FirePHP Firefox Extension.

     *

     * @param  mixed  $var   The variable to log.

     * @param  string  $label OPTIONAL Label to prepend to the log event.

     * @param  string  $style  OPTIONAL Style of the log event.

     * @param  array  $options OPTIONAL Options to change how messages are processed and sent

     * @return boolean Returns TRUE if the variable was added to the response headers or buffered.

     * @throws Zend_Wildfire_Exception

     */

    public static function send($var, $label=null, $style=null, $options=array())

    {

        $firephp = self::getInstance();

        if (!$firephp->getEnabled()) {

            return false;

        }

        if ($var instanceof Zend_Wildfire_Plugin_FirePhp_Message) {

            if ($var->getBuffered()) {

                if (!in_array($var, self::$_instance->_messages)) {

                    self::$_instance->_messages[] = $var;

                }

                return true;

            }

            if ($var->getDestroy()) {

                return false;

            }

            $style = $var->getStyle();

            $label = $var->getLabel();

            $options = $var->getOptions();

            $var = $var->getMessage();

        }

        if (!self::$_instance->_channel->isReady()) {

            return false;

        }

        foreach ($options as $name => $value) {

            if ($value===null) {

                unset($options[$name]);

            }

        }

        $options = array_merge($firephp->getOptions(), $options);

        $trace = null;

        $skipFinalEncode = false;

        $meta = array();

        $meta['Type'] = $style;

        if ($var instanceof Exception) {

            $eTrace = $var->getTrace();

            $eTrace = array_splice($eTrace, 0, $options['maxTraceDepth']);

            $var = array('Class'=>get_class($var),

                         'Message'=>$var->getMessage(),

                         'File'=>$var->getFile(),

                         'Line'=>$var->getLine(),

                         'Type'=>'throw',

                         'Trace'=>$firephp->_encodeTrace($eTrace));

            $meta['Type'] = self::EXCEPTION;

            $skipFinalEncode = true;

        } else

        if ($meta['Type']==self::TRACE) {

            if (!$label && $var) {

                $label = $var;

                $var = null;

            }

            if (!$trace) {

                $trace = $firephp->_getStackTrace(array_merge($options,

                                                              array('maxTraceDepth'=>$options['maxTraceDepth']+1)));

            }

            $var = array('Class'=>$trace[0]['class'],

                         'Type'=>$trace[0]['type'],

                         'Function'=>$trace[0]['function'],

                         'Message'=>$label,

                         'File'=>isset($trace[0]['file'])?$trace[0]['file']:'',

                         'Line'=>isset($trace[0]['line'])?$trace[0]['line']:'',

                         'Args'=>isset($trace[0]['args'])?$firephp->_encodeObject($trace[0]['args']):'',

                         'Trace'=>$firephp->_encodeTrace(array_splice($trace,1)));

          $skipFinalEncode = true;

        } else

        if ($meta['Type']==self::TABLE) {

          $var = $firephp->_encodeTable($var);

          $skipFinalEncode = true;