<?php
 
namespace DrSlump\Protobuf\Codec\Binary;
 
/**
 * Implements reading primitives for Protobuf binary streams
 *
 * Important: There are no checks in place for overflows, so you must
 * be aware of PHP's integer and floating point limits.
 *
 * @note Protobuf uses little-endian order
 */
class Reader
{
    /** @var resource */
    protected $_fd;
 
    /**
     * Create a new reader from a file descriptor or a string of bytes
     *
     * @param resource|string $fdOrString
     */
    public function __construct($fdOrString)
    {
        if (is_resource($fdOrString)) {
            $this->_fd = $fdOrString;
        } else {
            // @todo Could this be faster by using a custom String wrapper?
            $this->_fd = fopen('data://text/plain,' . urlencode($fdOrString), 'rb');
        }
    }
 
    public function __destruct()
    {
        fclose($this->_fd);
    }
 
    /**
     * Obtain a number of bytes from the string
     *
     * @throws \RuntimeException
     * @param int $length
     * @return string
     */
    public function read($length)
    {
        // Protect against 0 byte reads when an EOF
        if ($length < 1) return '';
 
        $bytes = fread($this->_fd, $length);
        if (FALSE === $bytes) {
            throw new \RuntimeException('Failed to read ' . $length . ' bytes');
        }
 
        return $bytes;
    }
 
    /**
     * Check if we have reached the end of the stream
     *
     * @return bool
     */
    public function eof()
    {
        return feof($this->_fd);
    }
 
    /**
     * Obtain the current position in the stream
     *
     * @return int
     */
    public function pos()
    {
        return ftell($this->_fd);
    }
 
    /**
     * Obtain a byte
     *
     * @return int
     */
    public function byte()
    {
        return ord($this->read(1));
    }
 
    /**
     * Decode a varint
     *
     * @return int
     */
    public function varint()
    {
        $result = $shift = 0;
        do {
            $byte = $this->byte();
            $result |= ($byte & 0x7f) << $shift;
            $shift += 7;
        } while ($byte > 0x7f);
 
        return $result;
    }
 
    /**
     * Decodes a zigzag integer of the given bits
     *
     * @param int $bits - Either 32 or 64
     */
    public function zigzag()
    {
        $number = $this->varint();
        return ($number >> 1) ^ (-($number & 1));
    }
 
    /**
     * Decode a fixed 32bit integer with sign
     *
     * @return int
     */
    public function sFixed32()
    {
        $bytes = $this->read(4);
        if ($this->isBigEndian()) {
            $bytes = strrev($bytes);
        }
 
        list(, $result) = unpack('l', $bytes);
        return $result;
    }
 
    /**
     * Decode a fixed 32bit integer without sign
     *
     * @return int
     */
    public function fixed32()
    {
        $bytes = $this->read(4);
 
        if (PHP_INT_SIZE < 8) {
            list(, $lo, $hi) = unpack('v*', $bytes);
            $result = $hi << 16 | $lo;
        } else {
            list(, $result) = unpack('V*', $bytes);
        }
 
        return $result;
    }
 
    /**
     * Decode a fixed 62bit integer with sign
     *
     * @return int
     */
    public function sFixed64()
    {
        $bytes = $this->read(8);
 
        list(, $lo0, $lo1, $hi0, $hi1) = unpack('v*', $bytes);
        return ($hi1 << 16 | $hi0) << 32 | ($lo1 << 16 | $lo0);
    }
 
    /**
     * Decode a fixed 62bit integer without sign
     *
     * @return int
     */
    public function fixed64()
    {
        return $this->sFixed64();
    }
 
    /**
     * Decode a 32bit float
     *
     * @return float
     */
    public function float()
    {
        $bytes = $this->read(4);
        if ($this->isBigEndian()) {
            $bytes = strrev($bytes);
        }
 
        list(, $result) = unpack('f', $bytes);
        return $result;
    }
 
    /**
     * Decode a 64bit double
     *
     * @return float
     */
    public function double()
    {
        $bytes = $this->read(8);
        if ($this->isBigEndian()) {
            $bytes = strrev($bytes);
        }
 
        list(, $result) = unpack('d', $bytes);
        return $result;
    }
 
    /**
     * Check if the current architecture is Big Endian
     *
     * @return bool
     */
    public function isBigEndian()
    {
        static $endianness;
 
        if (NULL === $endianness) {
            list(,$result) = unpack('L', pack('V', 1));
            $endianness = $result !== 1;
        }
 
        return $endianness;
    }
}