<?php

/**
 * Hoa
 *
 *
 * @license
 *
 * New BSD License
 *
 * Copyright © 2007-2017, Hoa community. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the Hoa nor the names of its contributors may be
 *       used to endorse or promote products derived from this software without
 *       specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS AND CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

namespace Psy\Readline\Hoa;

/**
 * Class \Hoa\Stream.
 *
 * Static register for all streams (files, sockets etc.).
 */
abstract class Stream implements IStream, EventListenable
{
    use EventListens;

    /**
     * Name index in the stream bucket.
     */
    const NAME = 0;

    /**
     * Handler index in the stream bucket.
     */
    const HANDLER = 1;

    /**
     * Resource index in the stream bucket.
     */
    const RESOURCE = 2;

    /**
     * Context index in the stream bucket.
     */
    const CONTEXT = 3;

    /**
     * Default buffer size.
     */
    const DEFAULT_BUFFER_SIZE = 8192;

    /**
     * Current stream bucket.
     */
    protected $_bucket = [];

    /**
     * Static stream register.
     */
    private static $_register = [];

    /**
     * Buffer size (default is 8Ko).
     */
    protected $_bufferSize = self::DEFAULT_BUFFER_SIZE;

    /**
     * Original stream name, given to the stream constructor.
     */
    protected $_streamName = null;

    /**
     * Context name.
     */
    protected $_context = null;

    /**
     * Whether the opening has been deferred.
     */
    protected $_hasBeenDeferred = false;

    /**
     * Whether this stream is already opened by another handler.
     */
    protected $_borrowing = false;

    /**
     * Set the current stream.
     * If not exists in the register, try to call the
     * `$this->_open()` method. Please, see the `self::_getStream()` method.
     */
    public function __construct(string $streamName, ?string $context = null, bool $wait = false)
    {
        $this->_streamName = $streamName;
        $this->_context = $context;
        $this->_hasBeenDeferred = $wait;
        $this->setListener(
            new EventListener(
                $this,
                [
                    'authrequire',
                    'authresult',
                    'complete',
                    'connect',
                    'failure',
                    'mimetype',
                    'progress',
                    'redirect',
                    'resolve',
                    'size',
                ]
            )
        );

        if (true === $wait) {
            return;
        }

        $this->open();

        return;
    }

    /**
     * Get a stream in the register.
     * If the stream does not exist, try to open it by calling the
     * $handler->_open() method.
     */
    private static function &_getStream(
        string $streamName,
        self $handler,
        ?string $context = null
    ): array {
        $name = \md5($streamName);

        if (null !== $context) {
            if (false === StreamContext::contextExists($context)) {
                throw new StreamException('Context %s was not previously declared, cannot retrieve '.'this context.', 0, $context);
            }

            $context = StreamContext::getInstance($context);
        }

        if (!isset(self::$_register[$name])) {
            self::$_register[$name] = [
                self::NAME     => $streamName,
                self::HANDLER  => $handler,
                self::RESOURCE => $handler->_open($streamName, $context),
                self::CONTEXT  => $context,
            ];
            Event::register(
                'hoa://Event/Stream/'.$streamName,
                $handler
            );
            // Add :open-ready?
            Event::register(
                'hoa://Event/Stream/'.$streamName.':close-before',
                $handler
            );
        } else {
            $handler->_borrowing = true;
        }

        if (null === self::$_register[$name][self::RESOURCE]) {
            self::$_register[$name][self::RESOURCE]
                = $handler->_open($streamName, $context);
        }

        return self::$_register[$name];
    }

    /**
     * Open the stream and return the associated resource.
     * Note: This method is protected, but do not forget that it could be
     * overloaded into a public context.
     */
    abstract protected function &_open(string $streamName, ?StreamContext $context = null);

    /**
     * Close the current stream.
     * Note: this method is protected, but do not forget that it could be
     * overloaded into a public context.
     */
    abstract protected function _close(): bool;

    /**
     * Open the stream.
     */
    final public function open(): self
    {
        $context = $this->_context;

        if (true === $this->hasBeenDeferred()) {
            if (null === $context) {
                $handle = StreamContext::getInstance(\uniqid());
                $handle->setParameters([
                    'notification' => [$this, '_notify'],
                ]);
                $context = $handle->getId();
            } elseif (true === StreamContext::contextExists($context)) {
                $handle = StreamContext::getInstance($context);
                $parameters = $handle->getParameters();

                if (!isset($parameters['notification'])) {
                    $handle->setParameters([
                        'notification' => [$this, '_notify'],
                    ]);
                }
            }
        }

        $this->_bufferSize = self::DEFAULT_BUFFER_SIZE;
        $this->_bucket = self::_getStream(
            $this->_streamName,
            $this,
            $context
        );

        return $this;
    }

    /**
     * Close the current stream.
     */
    final public function close()
    {
        $streamName = $this->getStreamName();

        if (null === $streamName) {
            return;
        }

        $name = \md5($streamName);

        if (!isset(self::$_register[$name])) {
            return;
        }

        Event::notify(
            'hoa://Event/Stream/'.$streamName.':close-before',
            $this,
            new EventBucket()
        );

        if (false === $this->_close()) {
            return;
        }

        unset(self::$_register[$name]);
        $this->_bucket[self::HANDLER] = null;
        Event::unregister(
            'hoa://Event/Stream/'.$streamName
        );
        Event::unregister(
            'hoa://Event/Stream/'.$streamName.':close-before'
        );

        return;
    }

    /**
     * Get the current stream name.
     */
    public function getStreamName()
    {
        if (empty($this->_bucket)) {
            return null;
        }

        return $this->_bucket[self::NAME];
    }

    /**
     * Get the current stream.
     */
    public function getStream()
    {
        if (empty($this->_bucket)) {
            return null;
        }

        return $this->_bucket[self::RESOURCE];
    }

    /**
     * Get the current stream context.
     */
    public function getStreamContext()
    {
        if (empty($this->_bucket)) {
            return null;
        }

        return $this->_bucket[self::CONTEXT];
    }

    /**
     * Get stream handler according to its name.
     */
    public static function getStreamHandler(string $streamName)
    {
        $name = \md5($streamName);

        if (!isset(self::$_register[$name])) {
            return null;
        }

        return self::$_register[$name][self::HANDLER];
    }

    /**
     * Set the current stream. Useful to manage a stack of streams (e.g. socket
     * and select). Notice that it could be unsafe to use this method without
     * taking time to think about it two minutes. Resource of type “Unknown” is
     * considered as valid.
     */
    public function _setStream($stream)
    {
        if (false === \is_resource($stream) &&
            ('resource' !== \gettype($stream) ||
             'Unknown' !== \get_resource_type($stream))) {
            throw new StreamException('Try to change the stream resource with an invalid one; '.'given %s.', 1, \gettype($stream));
        }

        $old = $this->_bucket[self::RESOURCE];
        $this->_bucket[self::RESOURCE] = $stream;

        return $old;
    }

    /**
     * Check if the stream is opened.
     */
    public function isOpened(): bool
    {
        return \is_resource($this->getStream());
    }

    /**
     * Set the timeout period.
     */
    public function setStreamTimeout(int $seconds, int $microseconds = 0): bool
    {
        return \stream_set_timeout($this->getStream(), $seconds, $microseconds);
    }

    /**
     * Whether the opening of the stream has been deferred.
     */
    protected function hasBeenDeferred()
    {
        return $this->_hasBeenDeferred;
    }

    /**
     * Check whether the connection has timed out or not.
     * This is basically a shortcut of `getStreamMetaData` + the `timed_out`
     * index, but the resulting code is more readable.
     */
    public function hasTimedOut(): bool
    {
        $metaData = $this->getStreamMetaData();

        return true === $metaData['timed_out'];
    }

    /**
     * Set blocking/non-blocking mode.
     */
    public function setStreamBlocking(bool $mode): bool
    {
        return \stream_set_blocking($this->getStream(), $mode);
    }

    /**
     * Set stream buffer.
     * Output using fwrite() (or similar function) is normally buffered at 8 Ko.
     * This means that if there are two processes wanting to write to the same
     * output stream, each is paused after 8 Ko of data to allow the other to
     * write.
     */
    public function setStreamBuffer(int $buffer): bool
    {
        // Zero means success.
        $out = 0 === \stream_set_write_buffer($this->getStream(), $buffer);

        if (true === $out) {
            $this->_bufferSize = $buffer;
        }

        return $out;
    }

    /**
     * Disable stream buffering.
     * Alias of $this->setBuffer(0).
     */
    public function disableStreamBuffer(): bool
    {
        return $this->setStreamBuffer(0);
    }

    /**
     * Get stream buffer size.
     */
    public function getStreamBufferSize(): int
    {
        return $this->_bufferSize;
    }

    /**
     * Get stream wrapper name.
     */
    public function getStreamWrapperName(): string
    {
        if (false === $pos = \strpos($this->getStreamName(), '://')) {
            return 'file';
        }

        return \substr($this->getStreamName(), 0, $pos);
    }

    /**
     * Get stream meta data.
     */
    public function getStreamMetaData(): array
    {
        return \stream_get_meta_data($this->getStream());
    }

    /**
     * Whether this stream is already opened by another handler.
     */
    public function isBorrowing(): bool
    {
        return $this->_borrowing;
    }

    /**
     * Notification callback.
     */
    public function _notify(
        int $ncode,
        int $severity,
        $message,
        $code,
        $transferred,
        $max
    ) {
        static $_map = [
            \STREAM_NOTIFY_AUTH_REQUIRED => 'authrequire',
            \STREAM_NOTIFY_AUTH_RESULT   => 'authresult',
            \STREAM_NOTIFY_COMPLETED     => 'complete',
            \STREAM_NOTIFY_CONNECT       => 'connect',
            \STREAM_NOTIFY_FAILURE       => 'failure',
            \STREAM_NOTIFY_MIME_TYPE_IS  => 'mimetype',
            \STREAM_NOTIFY_PROGRESS      => 'progress',
            \STREAM_NOTIFY_REDIRECTED    => 'redirect',
            \STREAM_NOTIFY_RESOLVE       => 'resolve',
            \STREAM_NOTIFY_FILE_SIZE_IS  => 'size',
        ];

        $this->getListener()->fire($_map[$ncode], new EventBucket([
            'code'        => $code,
            'severity'    => $severity,
            'message'     => $message,
            'transferred' => $transferred,
            'max'         => $max,
        ]));
    }

    /**
     * Call the $handler->close() method on each stream in the static stream
     * register.
     * This method does not check the return value of $handler->close(). Thus,
     * if a stream is persistent, the $handler->close() should do anything. It
     * is a very generic method.
     */
    final public static function _Hoa_Stream()
    {
        foreach (self::$_register as $entry) {
            $entry[self::HANDLER]->close();
        }

        return;
    }

    /**
     * Transform object to string.
     */
    public function __toString(): string
    {
        return $this->getStreamName();
    }

    /**
     * Close the stream when destructing.
     */
    public function __destruct()
    {
        if (false === $this->isOpened()) {
            return;
        }

        $this->close();

        return;
    }
}

/**
 * Class \Hoa\Stream\_Protocol.
 *
 * The `hoa://Library/Stream` node.
 *
 * @license    New BSD License
 */
class _Protocol extends ProtocolNode
{
    /**
     * Component's name.
     *
     * @var string
     */
    protected $_name = 'Stream';

    /**
     * ID of the component.
     *
     * @param string $id ID of the component
     *
     * @return mixed
     */
    public function reachId(string $id)
    {
        return Stream::getStreamHandler($id);
    }
}

/*
 * Shutdown method.
 */
\register_shutdown_function([Stream::class, '_Hoa_Stream']);

/**
 * Add the `hoa://Library/Stream` node. Should be use to reach/get an entry
 * in the stream register.
 */
$protocol = Protocol::getInstance();
$protocol['Library'][] = new _Protocol();

.NET Framework

Project Request

ProjectC

Vehicle Maintenance

Movie Navigator

Customers Exchange

ATM

.NET Core

Mail Daemon

Custom

Buns of code

PHP

Mediabox

Loan Castle

Content Management

Laravel

Phone Check

Frontend

Forex Wall

Business projects

Certification Center

Amerikas Auto

Pet projects

Geolocation Assistant

Web Dynamics

Blackball

Good old times

DOS Clock

BrainOut

Airport Administrator

Atomizer

Mediabox