class GPBWire

class GPBWire {
    const TAG_TYPE_BITS = 3;
    const WIRETYPE_VARINT = 0;
    const WIRETYPE_FIXED64 = 1;
    const WIRETYPE_LENGTH_DELIMITED = 2;
    const WIRETYPE_START_GROUP = 3;
    const WIRETYPE_END_GROUP = 4;
    const WIRETYPE_FIXED32 = 5;
    const UNKNOWN = 0;
    const NORMAL_FORMAT = 1;
    const PACKED_FORMAT = 2;
    public static function getTagFieldNumber($tag) {
        // We have to mask because PHP has no arithmetic shift.
        return $tag >> self::TAG_TYPE_BITS & 0x1fffffff;
    }
    public static function getTagWireType($tag) {
        return $tag & 0x7;
    }
    public static function getWireType($type) {
        switch ($type) {
            case GPBType::FLOAT:
            case GPBType::FIXED32:
            case GPBType::SFIXED32:
                return self::WIRETYPE_FIXED32;
            case GPBType::DOUBLE:
            case GPBType::FIXED64:
            case GPBType::SFIXED64:
                return self::WIRETYPE_FIXED64;
            case GPBType::UINT32:
            case GPBType::UINT64:
            case GPBType::INT32:
            case GPBType::INT64:
            case GPBType::SINT32:
            case GPBType::SINT64:
            case GPBType::ENUM:
            case GPBType::BOOL:
                return self::WIRETYPE_VARINT;
            case GPBType::STRING:
            case GPBType::BYTES:
            case GPBType::MESSAGE:
                return self::WIRETYPE_LENGTH_DELIMITED;
            case GPBType::GROUP:
                user_error("Unsupported type.");
                return 0;
            default:
                user_error("Unsupported type.");
                return 0;
        }
    }
    // ZigZag Transform:  Encodes signed integers so that they can be effectively
    // used with varint encoding.
    //
    // varint operates on unsigned integers, encoding smaller numbers into fewer
    // bytes.  If you try to use it on a signed integer, it will treat this
    // number as a very large unsigned integer, which means that even small
    // signed numbers like -1 will take the maximum number of bytes (10) to
    // encode.  zigZagEncode() maps signed integers to unsigned in such a way
    // that those with a small absolute value will have smaller encoded values,
    // making them appropriate for encoding using varint.
    //
    // int32 ->     uint32
    // -------------------------
    //           0 ->          0
    //          -1 ->          1
    //           1 ->          2
    //          -2 ->          3
    //         ... ->        ...
    //  2147483647 -> 4294967294
    // -2147483648 -> 4294967295
    //
    //        >> encode >>
    //        << decode <<
    public static function zigZagEncode32($int32) {
        if (PHP_INT_SIZE == 8) {
            $trim_int32 = $int32 & 0xffffffff;
            return ($trim_int32 << 1 ^ $int32 << 32 >> 63) & 0xffffffff;
        }
        else {
            return $int32 << 1 ^ $int32 >> 31;
        }
    }
    public static function zigZagDecode32($uint32) {
        // Fill high 32 bits.
        if (PHP_INT_SIZE === 8) {
            $uint32 |= $uint32 & 0xffffffff;
        }
        $int32 = $uint32 >> 1 & 0x7fffffff ^ -($uint32 & 1);
        return $int32;
    }
    public static function zigZagEncode64($int64) {
        if (PHP_INT_SIZE == 4) {
            if (bccomp($int64, 0) >= 0) {
                return bcmul($int64, 2);
            }
            else {
                return bcsub(bcmul(bcsub(0, $int64), 2), 1);
            }
        }
        else {
            return (int) $int64 << 1 ^ (int) $int64 >> 63;
        }
    }
    public static function zigZagDecode64($uint64) {
        if (PHP_INT_SIZE == 4) {
            if (bcmod($uint64, 2) == 0) {
                return bcdiv($uint64, 2, 0);
            }
            else {
                return bcsub(0, bcdiv(bcadd($uint64, 1), 2, 0));
            }
        }
        else {
            return $uint64 >> 1 & 0x7fffffffffffffff ^ -($uint64 & 1);
        }
    }
    public static function readInt32(&$input, &$value) {
        return $input->readVarint32($value);
    }
    public static function readInt64(&$input, &$value) {
        $success = $input->readVarint64($value);
        if (PHP_INT_SIZE == 4 && bccomp($value, "9223372036854775807") > 0) {
            $value = bcsub($value, "18446744073709551616");
        }
        return $success;
    }
    public static function readUint32(&$input, &$value) {
        return self::readInt32($input, $value);
    }
    public static function readUint64(&$input, &$value) {
        return self::readInt64($input, $value);
    }
    public static function readSint32(&$input, &$value) {
        if (!$input->readVarint32($value)) {
            return false;
        }
        $value = GPBWire::zigZagDecode32($value);
        return true;
    }
    public static function readSint64(&$input, &$value) {
        if (!$input->readVarint64($value)) {
            return false;
        }
        $value = GPBWire::zigZagDecode64($value);
        return true;
    }
    public static function readFixed32(&$input, &$value) {
        return $input->readLittleEndian32($value);
    }
    public static function readFixed64(&$input, &$value) {
        return $input->readLittleEndian64($value);
    }
    public static function readSfixed32(&$input, &$value) {
        if (!self::readFixed32($input, $value)) {
            return false;
        }
        if (PHP_INT_SIZE === 8) {
            $value |= -($value >> 31) << 32;
        }
        return true;
    }
    public static function readSfixed64(&$input, &$value) {
        $success = $input->readLittleEndian64($value);
        if (PHP_INT_SIZE == 4 && bccomp($value, "9223372036854775807") > 0) {
            $value = bcsub($value, "18446744073709551616");
        }
        return $success;
    }
    public static function readFloat(&$input, &$value) {
        $data = null;
        if (!$input->readRaw(4, $data)) {
            return false;
        }
        $value = unpack('g', $data)[1];
        return true;
    }
    public static function readDouble(&$input, &$value) {
        $data = null;
        if (!$input->readRaw(8, $data)) {
            return false;
        }
        $value = unpack('e', $data)[1];
        return true;
    }
    public static function readBool(&$input, &$value) {
        if (!$input->readVarint64($value)) {
            return false;
        }
        if ($value == 0) {
            $value = false;
        }
        else {
            $value = true;
        }
        return true;
    }
    public static function readString(&$input, &$value) {
        $length = 0;
        return $input->readVarintSizeAsInt($length) && $input->readRaw($length, $value);
    }
    public static function readMessage(&$input, &$message) {
        $length = 0;
        if (!$input->readVarintSizeAsInt($length)) {
            return false;
        }
        $old_limit = 0;
        $recursion_limit = 0;
        $input->incrementRecursionDepthAndPushLimit($length, $old_limit, $recursion_limit);
        if ($recursion_limit < 0 || !$message->parseFromStream($input)) {
            return false;
        }
        return $input->decrementRecursionDepthAndPopLimit($old_limit);
    }
    public static function writeTag(&$output, $tag) {
        return $output->writeTag($tag);
    }
    public static function writeInt32(&$output, $value) {
        return $output->writeVarint32($value, false);
    }
    public static function writeInt64(&$output, $value) {
        return $output->writeVarint64($value);
    }
    public static function writeUint32(&$output, $value) {
        return $output->writeVarint32($value, true);
    }
    public static function writeUint64(&$output, $value) {
        return $output->writeVarint64($value);
    }
    public static function writeSint32(&$output, $value) {
        $value = GPBWire::zigZagEncode32($value);
        return $output->writeVarint32($value, true);
    }
    public static function writeSint64(&$output, $value) {
        $value = GPBWire::zigZagEncode64($value);
        return $output->writeVarint64($value);
    }
    public static function writeFixed32(&$output, $value) {
        return $output->writeLittleEndian32($value);
    }
    public static function writeFixed64(&$output, $value) {
        return $output->writeLittleEndian64($value);
    }
    public static function writeSfixed32(&$output, $value) {
        return $output->writeLittleEndian32($value);
    }
    public static function writeSfixed64(&$output, $value) {
        return $output->writeLittleEndian64($value);
    }
    public static function writeBool(&$output, $value) {
        if ($value) {
            return $output->writeVarint32(1, true);
        }
        else {
            return $output->writeVarint32(0, true);
        }
    }
    public static function writeFloat(&$output, $value) {
        $data = pack("g", $value);
        return $output->writeRaw($data, 4);
    }
    public static function writeDouble(&$output, $value) {
        $data = pack("e", $value);
        return $output->writeRaw($data, 8);
    }
    public static function writeString(&$output, $value) {
        return self::writeBytes($output, $value);
    }
    public static function writeBytes(&$output, $value) {
        $size = strlen($value);
        if (!$output->writeVarint32($size, true)) {
            return false;
        }
        return $output->writeRaw($value, $size);
    }
    public static function writeMessage(&$output, $value) {
        $size = $value->byteSize();
        if (!$output->writeVarint32($size, true)) {
            return false;
        }
        return $value->serializeToStream($output);
    }
    public static function makeTag($number, $type) {
        return $number << 3 | self::getWireType($type);
    }
    public static function tagSize($field) {
        $tag = self::makeTag($field->getNumber(), $field->getType());
        return self::varint32Size($tag);
    }
    public static function varint32Size($value, $sign_extended = false) {
        if ($value < 0) {
            if ($sign_extended) {
                return 10;
            }
            else {
                return 5;
            }
        }
        if ($value < 1 << 7) {
            return 1;
        }
        if ($value < 1 << 14) {
            return 2;
        }
        if ($value < 1 << 21) {
            return 3;
        }
        if ($value < 1 << 28) {
            return 4;
        }
        return 5;
    }
    public static function sint32Size($value) {
        $value = self::zigZagEncode32($value);
        return self::varint32Size($value);
    }
    public static function sint64Size($value) {
        $value = self::zigZagEncode64($value);
        return self::varint64Size($value);
    }
    public static function varint64Size($value) {
        if (PHP_INT_SIZE == 4) {
            if (bccomp($value, 0) < 0 || bccomp($value, "9223372036854775807") > 0) {
                return 10;
            }
            if (bccomp($value, 1 << 7) < 0) {
                return 1;
            }
            if (bccomp($value, 1 << 14) < 0) {
                return 2;
            }
            if (bccomp($value, 1 << 21) < 0) {
                return 3;
            }
            if (bccomp($value, 1 << 28) < 0) {
                return 4;
            }
            if (bccomp($value, '34359738368') < 0) {
                return 5;
            }
            if (bccomp($value, '4398046511104') < 0) {
                return 6;
            }
            if (bccomp($value, '562949953421312') < 0) {
                return 7;
            }
            if (bccomp($value, '72057594037927936') < 0) {
                return 8;
            }
            return 9;
        }
        else {
            if ($value < 0) {
                return 10;
            }
            if ($value < 1 << 7) {
                return 1;
            }
            if ($value < 1 << 14) {
                return 2;
            }
            if ($value < 1 << 21) {
                return 3;
            }
            if ($value < 1 << 28) {
                return 4;
            }
            if ($value < 1 << 35) {
                return 5;
            }
            if ($value < 1 << 42) {
                return 6;
            }
            if ($value < 1 << 49) {
                return 7;
            }
            if ($value < 1 << 56) {
                return 8;
            }
            return 9;
        }
    }
    public static function serializeFieldToStream($value, $field, $need_tag, &$output) {
        if ($need_tag) {
            if (!GPBWire::writeTag($output, self::makeTag($field->getNumber(), $field->getType()))) {
                return false;
            }
        }
        switch ($field->getType()) {
            case GPBType::DOUBLE:
                if (!GPBWire::writeDouble($output, $value)) {
                    return false;
                }
                break;
            case GPBType::FLOAT:
                if (!GPBWire::writeFloat($output, $value)) {
                    return false;
                }
                break;
            case GPBType::INT64:
                if (!GPBWire::writeInt64($output, $value)) {
                    return false;
                }
                break;
            case GPBType::UINT64:
                if (!GPBWire::writeUint64($output, $value)) {
                    return false;
                }
                break;
            case GPBType::INT32:
                if (!GPBWire::writeInt32($output, $value)) {
                    return false;
                }
                break;
            case GPBType::FIXED32:
                if (!GPBWire::writeFixed32($output, $value)) {
                    return false;
                }
                break;
            case GPBType::FIXED64:
                if (!GPBWire::writeFixed64($output, $value)) {
                    return false;
                }
                break;
            case GPBType::BOOL:
                if (!GPBWire::writeBool($output, $value)) {
                    return false;
                }
                break;
            case GPBType::STRING:
                if (!GPBWire::writeString($output, $value)) {
                    return false;
                }
                break;
            //    case GPBType::GROUP:
            //      echo "GROUP\xA";
            //      trigger_error("Not implemented.", E_ERROR);
            //      break;
            case GPBType::MESSAGE:
                if (!GPBWire::writeMessage($output, $value)) {
                    return false;
                }
                break;
            case GPBType::BYTES:
                if (!GPBWire::writeBytes($output, $value)) {
                    return false;
                }
                break;
            case GPBType::UINT32:
                if (PHP_INT_SIZE === 8 && $value < 0) {
                    $value += 4294967296;
                }
                if (!GPBWire::writeUint32($output, $value)) {
                    return false;
                }
                break;
            case GPBType::ENUM:
                if (!GPBWire::writeInt32($output, $value)) {
                    return false;
                }
                break;
            case GPBType::SFIXED32:
                if (!GPBWire::writeSfixed32($output, $value)) {
                    return false;
                }
                break;
            case GPBType::SFIXED64:
                if (!GPBWire::writeSfixed64($output, $value)) {
                    return false;
                }
                break;
            case GPBType::SINT32:
                if (!GPBWire::writeSint32($output, $value)) {
                    return false;
                }
                break;
            case GPBType::SINT64:
                if (!GPBWire::writeSint64($output, $value)) {
                    return false;
                }
                break;
            default:
                user_error("Unsupported type.");
                return false;
        }
        return true;
    }

}