<?php
/*
 * Copyright 2015 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

namespace Google\FlatBuffers;

class ByteBuffer
{
    /**
     * @var string $_buffer;
     */
    public $_buffer;

    /**
     * @var int $_pos;
     */
    private $_pos;

    /**
     * @var bool $_is_little_endian
     */
    private static $_is_little_endian = null;

    public static function wrap($bytes)
    {
        $bb = new ByteBuffer(0);
        $bb->_buffer = $bytes;

        return $bb;
    }

    /**
     * @param $size
     */
    public function __construct($size)
    {
        $this->_buffer = str_repeat("\0", $size);
    }

    /**
     * @return int
     */
    public function capacity()
    {
        return strlen($this->_buffer);
    }

    /**
     * @return int
     */
    public function getPosition()
    {
        return $this->_pos;
    }

    /**
     * @param $pos
     */
    public function setPosition($pos)
    {
        $this->_pos = $pos;
    }

    /**
     *
     */
    public function reset()
    {
        $this->_pos = 0;
    }

    /**
     * @return int
     */
    public function length()
    {
        return strlen($this->_buffer);
    }

    /**
     * @return string
     */
    public function data()
    {
        return substr($this->_buffer, $this->_pos);
    }

    /**
     * @return bool
     */
    public static function isLittleEndian()
    {
        if (ByteBuffer::$_is_little_endian === null) {
            ByteBuffer::$_is_little_endian = unpack('S', "\x01\x00")[1] === 1;
        }

        return ByteBuffer::$_is_little_endian;
    }

    /**
     * write little endian value to the buffer.
     *
     * @param $offset
     * @param $count byte length
     * @param $data actual values
     */
    public function writeLittleEndian($offset, $count, $data)
    {
        if (ByteBuffer::isLittleEndian()) {
            for ($i = 0; $i < $count; $i++) {
                $this->_buffer[$offset + $i] = chr($data >> $i * 8);
            }
        } else {
            for ($i = 0; $i < $count; $i++) {
                $this->_buffer[$offset + $count - 1 - $i] = chr($data >> $i * 8);
            }
        }
    }

    /**
     * read little endian value from the buffer
     *
     * @param $offset
     * @param $count acutal size
     * @return int
     */
    public function readLittleEndian($offset, $count, $force_bigendian = false)
    {
        $this->assertOffsetAndLength($offset, $count);
        $r = 0;

        if (ByteBuffer::isLittleEndian() && $force_bigendian == false) {
            for ($i = 0; $i < $count; $i++) {
                $r |= ord($this->_buffer[$offset + $i]) << $i * 8;
            }
        } else {
            for ($i = 0; $i < $count; $i++) {
                $r |= ord($this->_buffer[$offset + $count -1 - $i]) << $i * 8;
            }
        }

        return $r;
    }

    /**
     * @param $offset
     * @param $length
     */
    public function assertOffsetAndLength($offset, $length)
    {
        if ($offset < 0 ||
            $offset >= strlen($this->_buffer) ||
            $offset + $length > strlen($this->_buffer)) {
            throw new \OutOfRangeException(sprintf("offset: %d, length: %d, buffer; %d", $offset, $length, strlen($this->_buffer)));
        }
    }

    /**
     * @param $offset
     * @param $value
     * @return mixed
     */
    public function putSbyte($offset, $value)
    {
        self::validateValue(-128, 127, $value, "sbyte");

        $length = strlen($value);
        $this->assertOffsetAndLength($offset, $length);
        return $this->_buffer[$offset] = $value;
    }

    /**
     * @param $offset
     * @param $value
     * @return mixed
     */
    public function putByte($offset, $value)
    {
        self::validateValue(0, 255, $value, "byte");

        $length = strlen($value);
        $this->assertOffsetAndLength($offset, $length);
        return $this->_buffer[$offset] = $value;
    }

    /**
     * @param $offset
     * @param $value
     */
    public function put($offset, $value)
    {
        $length = strlen($value);
        $this->assertOffsetAndLength($offset, $length);
        for ($i = 0; $i < $length; $i++) {
            $this->_buffer[$offset + $i] = $value[$i];
        }
    }

    /**
     * @param $offset
     * @param $value
     */
    public function putShort($offset, $value)
    {
        self::validateValue(-32768, 32767, $value, "short");

        $this->assertOffsetAndLength($offset, 2);
        $this->writeLittleEndian($offset, 2, $value);
    }

    /**
     * @param $offset
     * @param $value
     */
    public function putUshort($offset, $value)
    {
        self::validateValue(0, 65535, $value, "short");

        $this->assertOffsetAndLength($offset, 2);
        $this->writeLittleEndian($offset, 2, $value);
    }

    /**
     * @param $offset
     * @param $value
     */
    public function putInt($offset, $value)
    {
        // 2147483647 = (1 << 31) -1 = Maximum signed 32-bit int
        // -2147483648 = -1 << 31 = Minimum signed 32-bit int
        self::validateValue(-2147483648, 2147483647, $value, "int");

        $this->assertOffsetAndLength($offset, 4);
        $this->writeLittleEndian($offset, 4, $value);
    }

    /**
     * @param $offset
     * @param $value
     */
    public function putUint($offset, $value)
    {
        // NOTE: We can't put big integer value. this is PHP limitation.
        // 4294967295 = (1 << 32) -1 = Maximum unsigned 32-bin int
        self::validateValue(0, 4294967295, $value, "uint",  " php has big numbers limitation. check your PHP_INT_MAX");

        $this->assertOffsetAndLength($offset, 4);
        $this->writeLittleEndian($offset, 4, $value);
    }

    /**
     * @param $offset
     * @param $value
     */
    public function putLong($offset, $value)
    {
        // NOTE: We can't put big integer value. this is PHP limitation.
        self::validateValue(~PHP_INT_MAX, PHP_INT_MAX, $value, "long",  " php has big numbers limitation. check your PHP_INT_MAX");

        $this->assertOffsetAndLength($offset, 8);
        $this->writeLittleEndian($offset, 8, $value);
    }

    /**
     * @param $offset
     * @param $value
     */
    public function putUlong($offset, $value)
    {
        // NOTE: We can't put big integer value. this is PHP limitation.
        self::validateValue(0, PHP_INT_MAX, $value, "long", " php has big numbers limitation. check your PHP_INT_MAX");

        $this->assertOffsetAndLength($offset, 8);
        $this->writeLittleEndian($offset, 8, $value);
    }

    /**
     * @param $offset
     * @param $value
     */
    public function putFloat($offset, $value)
    {
        $this->assertOffsetAndLength($offset, 4);

        $floathelper = pack("f", $value);
        $v = unpack("V", $floathelper);
        $this->writeLittleEndian($offset, 4, $v[1]);
    }

    /**
     * @param $offset
     * @param $value
     */
    public function putDouble($offset, $value)
    {
        $this->assertOffsetAndLength($offset, 8);

        $floathelper = pack("d", $value);
        $v = unpack("V*", $floathelper);

        $this->writeLittleEndian($offset, 4, $v[1]);
        $this->writeLittleEndian($offset + 4, 4, $v[2]);
    }

    /**
     * @param $index
     * @return mixed
     */
    public function getByte($index)
    {
        return ord($this->_buffer[$index]);
    }

    /**
     * @param $index
     * @return mixed
     */
    public function getSbyte($index)
    {
        $v = unpack("c", $this->_buffer[$index]);
        return $v[1];
    }

    /**
     * @param $buffer
     */
    public function getX(&$buffer)
    {
        for ($i = $this->_pos, $j = 0; $j < strlen($buffer); $i++, $j++) {
            $buffer[$j] = $this->_buffer[$i];
        }
    }

    /**
     * @param $index
     * @return mixed
     */
    public function get($index)
    {
        $this->assertOffsetAndLength($index, 1);
        return $this->_buffer[$index];
    }


    /**
     * @param $index
     * @return mixed
     */
    public function getBool($index)
    {
        return (bool)ord($this->_buffer[$index]);
    }

    /**
     * @param $index
     * @return int
     */
    public function getShort($index)
    {
        $result = $this->readLittleEndian($index, 2);

        $sign = $index + (ByteBuffer::isLittleEndian() ? 1 : 0);
        $issigned = isset($this->_buffer[$sign]) && ord($this->_buffer[$sign]) & 0x80;

        // 65536 = 1 << 16 = Maximum unsigned 16-bit int
        return $issigned ? $result - 65536 : $result;
    }

    /**
     * @param $index
     * @return int
     */
    public function getUShort($index)
    {
        return $this->readLittleEndian($index, 2);
    }

    /**
     * @param $index
     * @return int
     */
    public function getInt($index)
    {
        $result = $this->readLittleEndian($index, 4);

        $sign = $index + (ByteBuffer::isLittleEndian() ? 3 : 0);
        $issigned = isset($this->_buffer[$sign]) && ord($this->_buffer[$sign]) & 0x80;

        if (PHP_INT_SIZE > 4) {
            // 4294967296 = 1 << 32 = Maximum unsigned 32-bit int
            return $issigned ? $result - 4294967296 : $result;
        } else {
            // 32bit / Windows treated number as signed integer.
            return $result;
        }
    }

    /**
     * @param $index
     * @return int
     */
    public function getUint($index)
    {
        return $this->readLittleEndian($index, 4);
    }

    /**
     * @param $index
     * @return int
     */
    public function getLong($index)
    {
        return $this->readLittleEndian($index, 8);
    }

    /**
     * @param $index
     * @return int
     */
    public function getUlong($index)
    {
        return $this->readLittleEndian($index, 8);
    }

    /**
     * @param $index
     * @return mixed
     */
    public function getFloat($index)
    {
        $i = $this->readLittleEndian($index, 4);

        return self::convertHelper(self::__FLOAT, $i);
    }

    /**
     * @param $index
     * @return float
     */
    public function getDouble($index)
    {
        $i = $this->readLittleEndian($index, 4);
        $i2 = $this->readLittleEndian($index + 4, 4);

        return self::convertHelper(self::__DOUBLE, $i, $i2);
    }

    const __SHORT = 1;
    const __INT = 2;
    const __LONG = 3;
    const __FLOAT = 4;
    const __DOUBLE = 5;
    private static function convertHelper($type, $value, $value2 = null) {
        // readLittleEndian construct unsigned integer value from bytes. we have to encode this value to
        // correct bytes, and decode as expected types with `unpack` function.
        // then it returns correct type value.
        // see also: http://php.net/manual/en/function.pack.php

        switch ($type) {
            case self::__FLOAT:
                $inthelper = pack("V", $value);
                $v = unpack("f", $inthelper);
                return $v[1];
                break;
            case self::__DOUBLE:
                $inthelper = pack("VV", $value, $value2);
                $v = unpack("d", $inthelper);
                return $v[1];
                break;
            default:
                throw new \Exception(sprintf("unexpected type %d specified", $type));
        }
    }

    private static function validateValue($min, $max, $value, $type, $additional_notes = "") {
        if (
          !(
            ($type === "byte" && $min <= ord($value) && ord($value) <= $max) ||
            ($min <= $value && $value <= $max)
          )
        ) {
            throw new \InvalidArgumentException(sprintf("bad number %s for type %s.%s", $value, $type, $additional_notes));
        }
    }
}
