<?php

    /**
     * Class containing helper functions for dealing with "big data".
     * @author Sam Mousa <sam@befound.nl>
     */
    class BigData {



        /**
         * This function combines json_encode and echo.
         * If a stream is passed (or is part of the array) it's content will be
         * directly streamed instead of reading it into memory first.
         * Supported flags:
         * JSON_FORCE_OBJECT
         * @param array $json
         * @param int $options Same flags used in JSON_ENCODE.
         */
        public static function json_echo($json, $options = 0)
        {
            // Scan array for any streams.
            $hasStream = array_reduce($json, array('BigData', 'hasStream'), false);

            // If there is no stream we are done.
            if (!$hasStream)
            {
                echo json_encode($json, $options);
            }
            else
            {
                self::json_echo_data($json, ($options & JSON_FORCE_OBJECT) == JSON_FORCE_OBJECT);
            }

        }

        protected static function hasStream(&$result, $item)
        {
            if ($result === true)
            {
                return true;
            }
            elseif(is_array($item))
            {
                return array_reduce($item, array('BigData', 'hasStream'), false);
            }
            // Should use get_resource_type to do stricter check.
            elseif (self::isStream($item))
            {
                return true;
            }
            else
            {
                return false;
            }
        }


        protected static function isStream($item)
        {
            return is_object($item) && get_class($item) == 'BigFile';
        }

        protected static function isAssociative($array)
        {
            foreach ($array as $key => $value)
            {
                if (is_string($key))
                {
                    return true;
                }
            }
            return false;
        }


        protected static function json_echo_data($json)
        {
            if (self::isStream($json))
            {
                self::json_echo_stream($json);
            }
            elseif ((is_array($json) && self::isAssociative($json)) || is_object($json))
            {
                self::json_echo_object($json);
            }
            elseif (is_array($json))
            {
                self::json_echo_array($json);
            }
            elseif (is_numeric($json))
            {
                self::json_echo_number($json);
            }
            elseif (is_string($json))
            {
                self::json_echo_string($json);
            }
            elseif (is_null($json))
            {
                echo json_encode(null);
            }
        }

        protected static function json_echo_array($json)
        {
            echo '[';
                foreach ($json as $key => $entry)
                {
                    echo json_encode($key) . ':';
                    self::json_echo_data($entry);
                    echo ', '; // The extra comma is allowed: { 1: 'test', 2: 'test',} is valid.
                }
                echo ']';
        }

        protected static function json_echo_number($json)
        {
            echo $json;
        }

        protected static function json_echo_object($json)
        {
            echo '{';
                end($json);
                $lastKey = key($json);
                reset($json);
                foreach ($json as $key => $entry)
                {
                    echo json_encode($key) . ':';
                    self::json_echo_data($entry);
                    if ($lastKey !== $key)
                    {
                        echo ', '; // The extra comma is allowed: { 1: 'test', 2: 'test',} is valid.
                    }
                }
                echo '}';
        }

        /**
         * @param string $json
         */
        protected static function json_echo_string($json)
        {
            echo json_encode($json);
        }

        protected static function json_echo_stream(BigFile $data)
        {
            // Encode stream to base64.
            echo '"';
            $data->render();
            echo '"';
        }


        /**
         * @param string $name
         */
        protected static function tag($name, $data)
        {
            echo "<$name>$data</$name>\n";
        }
        /**
         * This function encodes PHP data to an XMLRPC response.
         */
        public static function xmlrpc_echo($data)
        {
            if (self::isStream($data))
            {
                self::xmlrpc_echo_stream($data);
            }
            elseif ((is_array($data) && self::isAssociative($data)) || is_object($data))
            {
                self::xmlrpc_echo_object($data);
            }
            elseif (is_array($data))
            {
                self::xmlrpc_echo_array($data);
            }
            elseif (is_numeric($data))
            {
                self::xmlrpc_echo_number($data);
            }
            elseif (is_string($data))
            {
                self::xmlrpc_echo_string($data);
            }

        }

        protected static function xmlrpc_echo_array($data)
        {
            echo '<array>';
            echo '<data>';
            foreach ($data as $element)
            {
                echo '<value>';
                self::xmlrpc_echo($element);
                echo '</value>';
            }
            echo '</data>';
            echo '</array>';
        }

        /**
         * Prints XMLRPC numeric types.
         * @param type $data
         */
        protected static function xmlrpc_echo_number($data)
        {
            if (floor($data) == $data){
                self::tag('int', $data);
            }
            else {
                self::tag('double', $data);
            }
        }

        protected static function xmlrpc_echo_object($data)
        {
            echo '<struct>';
            foreach ($data as $key => $value)
            {
                echo '<member>';
                echo self::tag('name', "<![CDATA[$key]]>");
                echo '<value>';
                self::xmlrpc_echo($value);
                echo '</value>';

                echo '</member>';
            }
            echo '</struct>';
        }

        protected static function xmlrpc_echo_stream($data)
        {
            echo '<string>'; // a Base64 tag would be more sensible here but it would break all current implementations
            $data->render();
            echo '</string>';
        }

        /**
         * @param string $data
         */
        protected static function xmlrpc_echo_string($data)
        {
            self::tag('string', "<![CDATA[$data]]>");
        }
    }

    class BigFile {

        public $fileName;
        protected $deleteAfterUse;
        protected $defaultEcho;

        public function __construct($fileName, $deleteAfterUse = true, $defaultEcho ='base64')
        {
            $this->fileName = $fileName;
            $this->deleteAfterUse = $deleteAfterUse;
            $this->defaultEcho = $defaultEcho;

        }

        public function render($type = null)
        {
            if (!isset($type))
            {
                $type = $this->defaultEcho;
            }
            if (method_exists($this, "echo_{$type}"))
            {
                call_user_func(array($this, "echo_{$type}"));
            }
            if ($this->deleteAfterUse)
            {
                unlink($this->fileName);
            }
        }

        protected function echo_base64()
        {
            $fileHandle = fopen($this->fileName, 'r');
            stream_filter_append($fileHandle, 'convert.base64-encode', STREAM_FILTER_READ);
            fpassthru($fileHandle);
            fclose($fileHandle);
        }
    }

?>
