<?php

// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.  All rights reserved.
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd
namespace Matomo\Dependencies\GoogleAnalyticsImporter\Google\Protobuf\Internal;

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;
    }
}
