<?php

if (class_exists('ParagonIE_Sodium_Core_Util', false)) {

    return;

}

/**

 * Class ParagonIE_Sodium_Core_Util

 */

abstract class ParagonIE_Sodium_Core_Util

{

    /**

     * @param int $integer

     * @param int $size (16, 32, 64)

     * @return int

     */

    public static function abs($integer, $size = 0)

    {

        /** @var int $realSize */

        $realSize = (PHP_INT_SIZE << 3) - 1;

        if ($size) {

            --$size;

        } else {

            /** @var int $size */

            $size = $realSize;

        }

        $negative = -(($integer >> $size) & 1);

        return (int) (

            ($integer ^ $negative)

                +

            (($negative >> $realSize) & 1)

        );

    }

    /**

     * Convert a binary string into a hexadecimal string without cache-timing

     * leaks

     *

     * @internal You should not use this directly from another application

     *

     * @param string $binaryString (raw binary)

     * @return string

     * @throws TypeError

     */

    public static function bin2hex($binaryString)

    {

        /* Type checks: */

        if (!is_string($binaryString)) {

            throw new TypeError('Argument 1 must be a string, ' . gettype($binaryString) . ' given.');

        }

        $hex = '';

        $len = self::strlen($binaryString);

        for ($i = 0; $i < $len; ++$i) {

            /** @var array<int, int> $chunk */

            $chunk = unpack('C', $binaryString[$i]);

            /** @var int $c */

            $c = $chunk[1] & 0xf;

            /** @var int $b */

            $b = $chunk[1] >> 4;

            $hex .= pack(

                'CC',

                (87 + $b + ((($b - 10) >> 8) & ~38)),

                (87 + $c + ((($c - 10) >> 8) & ~38))

            );

        }

        return $hex;

    }

    /**

     * Convert a binary string into a hexadecimal string without cache-timing

     * leaks, returning uppercase letters (as per RFC 4648)

     *

     * @internal You should not use this directly from another application

     *

     * @param string $bin_string (raw binary)

     * @return string

     * @throws TypeError

     */

    public static function bin2hexUpper($bin_string)

    {

        $hex = '';

        $len = self::strlen($bin_string);

        for ($i = 0; $i < $len; ++$i) {

            /** @var array<int, int> $chunk */

            $chunk = unpack('C', $bin_string[$i]);

            /**

             * Lower 16 bits

             *

             * @var int $c

             */

            $c = $chunk[1] & 0xf;

            /**

             * Upper 16 bits

             * @var int $b

             */

            $b = $chunk[1] >> 4;

            /**

             * Use pack() and binary operators to turn the two integers

             * into hexadecimal characters. We don't use chr() here, because

             * it uses a lookup table internally and we want to avoid

             * cache-timing side-channels.

             */

            $hex .= pack(

                'CC',

                (55 + $b + ((($b - 10) >> 8) & ~6)),

                (55 + $c + ((($c - 10) >> 8) & ~6))

            );

        }

        return $hex;

    }

    /**

     * Cache-timing-safe variant of ord()

     *

     * @internal You should not use this directly from another application

     *

     * @param string $chr

     * @return int

     * @throws SodiumException

     * @throws TypeError

     */

    public static function chrToInt($chr)

    {

        /* Type checks: */

        if (!is_string($chr)) {

            throw new TypeError('Argument 1 must be a string, ' . gettype($chr) . ' given.');

        }

        if (self::strlen($chr) !== 1) {

            throw new SodiumException('chrToInt() expects a string that is exactly 1 character long');

        }

        /** @var array<int, int> $chunk */

        $chunk = unpack('C', $chr);

        return (int) ($chunk[1]);

    }

    /**

     * Compares two strings.

     *

     * @internal You should not use this directly from another application

     *

     * @param string $left

     * @param string $right

     * @param int $len

     * @return int

     * @throws SodiumException

     * @throws TypeError

     */

    public static function compare($left, $right, $len = null)

    {

        $leftLen = self::strlen($left);

        $rightLen = self::strlen($right);

        if ($len === null) {

            $len = max($leftLen, $rightLen);

            $left = str_pad($left, $len, "\x00", STR_PAD_RIGHT);

            $right = str_pad($right, $len, "\x00", STR_PAD_RIGHT);

        }

        $gt = 0;

        $eq = 1;

        $i = $len;

        while ($i !== 0) {

            --$i;

            $gt |= ((self::chrToInt($right[$i]) - self::chrToInt($left[$i])) >> 8) & $eq;

            $eq &= ((self::chrToInt($right[$i]) ^ self::chrToInt($left[$i])) - 1) >> 8;

        }

        return ($gt + $gt + $eq) - 1;

    }

    /**

     * If a variable does not match a given type, throw a TypeError.

     *

     * @param mixed $mixedVar

     * @param string $type

     * @param int $argumentIndex

     * @throws TypeError

     * @throws SodiumException

     * @return void

     */

    public static function declareScalarType(&$mixedVar = null, $type = 'void', $argumentIndex = 0)

    {

        if (func_num_args() === 0) {

            /* Tautology, by default */

            return;

        }

        if (func_num_args() === 1) {

            throw new TypeError('Declared void, but passed a variable');

        }

        $realType = strtolower(gettype($mixedVar));

        $type = strtolower($type);

        switch ($type) {

            case 'null':

                if ($mixedVar !== null) {

                    throw new TypeError('Argument ' . $argumentIndex . ' must be null, ' . $realType . ' given.');

                }

                break;

            case 'integer':

            case 'int':

                $allow = array('int', 'integer');

                if (!in_array($type, $allow)) {

                    throw new TypeError('Argument ' . $argumentIndex . ' must be an integer, ' . $realType . ' given.');

                }

                $mixedVar = (int) $mixedVar;

                break;

            case 'boolean':

            case 'bool':

                $allow = array('bool', 'boolean');

                if (!in_array($type, $allow)) {

                    throw new TypeError('Argument ' . $argumentIndex . ' must be a boolean, ' . $realType . ' given.');

                }

                $mixedVar = (bool) $mixedVar;

                break;

            case 'string':

                if (!is_string($mixedVar)) {

                    throw new TypeError('Argument ' . $argumentIndex . ' must be a string, ' . $realType . ' given.');

                }

                $mixedVar = (string) $mixedVar;

                break;

            case 'decimal':

            case 'double':

            case 'float':

                $allow = array('decimal', 'double', 'float');

                if (!in_array($type, $allow)) {

                    throw new TypeError('Argument ' . $argumentIndex . ' must be a float, ' . $realType . ' given.');

                }

                $mixedVar = (float) $mixedVar;

                break;

            case 'object':

                if (!is_object($mixedVar)) {

                    throw new TypeError('Argument ' . $argumentIndex . ' must be an object, ' . $realType . ' given.');

                }

                break;

            case 'array':

                if (!is_array($mixedVar)) {

                    if (is_object($mixedVar)) {

                        if ($mixedVar instanceof ArrayAccess) {

                            return;

                        }

                    }

                    throw new TypeError('Argument ' . $argumentIndex . ' must be an array, ' . $realType . ' given.');

                }

                break;

            default:

                throw new SodiumException('Unknown type (' . $realType .') does not match expect type (' . $type . ')');

        }

    }

    /**

     * Evaluate whether or not two strings are equal (in constant-time)

     *

     * @param string $left

     * @param string $right

     * @return bool

     * @throws SodiumException

     * @throws TypeError

     */

    public static function hashEquals($left, $right)

    {

        /* Type checks: */

        if (!is_string($left)) {

            throw new TypeError('Argument 1 must be a string, ' . gettype($left) . ' given.');

        }

        if (!is_string($right)) {

            throw new TypeError('Argument 2 must be a string, ' . gettype($right) . ' given.');

        }

        if (is_callable('hash_equals')) {

            return hash_equals($left, $right);

        }

        $d = 0;

        /** @var int $len */

        $len = self::strlen($left);

        if ($len !== self::strlen($right)) {

            return false;

        }

        for ($i = 0; $i < $len; ++$i) {

            $d |= self::chrToInt($left[$i]) ^ self::chrToInt($right[$i]);

        }

        if ($d !== 0) {

            return false;

        }

        return $left === $right;

    }

    /**

     * Convert a hexadecimal string into a binary string without cache-timing

     * leaks

     *

     * @internal You should not use this directly from another application

     *

     * @param string $hexString

     * @param bool $strictPadding

     * @return string (raw binary)

     * @throws RangeException

     * @throws TypeError

     */

    public static function hex2bin($hexString, $strictPadding = false)

    {

        /* Type checks: */

        if (!is_string($hexString)) {

            throw new TypeError('Argument 1 must be a string, ' . gettype($hexString) . ' given.');

        }

        /** @var int $hex_pos */

        $hex_pos = 0;

        /** @var string $bin */

        $bin = '';

        /** @var int $c_acc */

        $c_acc = 0;

        /** @var int $hex_len */

        $hex_len = self::strlen($hexString);

        /** @var int $state */

        $state = 0;

        if (($hex_len & 1) !== 0) {

            if ($strictPadding) {

                throw new RangeException(

                    'Expected an even number of hexadecimal characters'

                );

            } else {

                $hexString = '0' . $hexString;

                ++$hex_len;

            }

        }

        $chunk = unpack('C*', $hexString);

        while ($hex_pos < $hex_len) {

            ++$hex_pos;

            /** @var int $c */

            $c = $chunk[$hex_pos];

            /** @var int $c_num */

            $c_num = $c ^ 48;

            /** @var int $c_num0 */

            $c_num0 = ($c_num - 10) >> 8;

            /** @var int $c_alpha */

            $c_alpha = ($c & ~32) - 55;

            /** @var int $c_alpha0 */

            $c_alpha0 = (($c_alpha - 10) ^ ($c_alpha - 16)) >> 8;

            if (($c_num0 | $c_alpha0) === 0) {

                throw new RangeException(

                    'hex2bin() only expects hexadecimal characters'

                );

            }

            /** @var int $c_val */

            $c_val = ($c_num0 & $c_num) | ($c_alpha & $c_alpha0);

            if ($state === 0) {

                $c_acc = $c_val * 16;

            } else {

                $bin .= pack('C', $c_acc | $c_val);

            }

            $state ^= 1;

        }

        return $bin;

    }

    /**

     * Turn an array of integers into a string

     *

     * @internal You should not use this directly from another application

     *

     * @param array<int, int> $ints

     * @return string

     */

    public static function intArrayToString(array $ints)

    {

        /** @var array<int, int> $args */

        $args = $ints;

        foreach ($args as $i => $v) {

            $args[$i] = (int) ($v & 0xff);

        }

        array_unshift($args, str_repeat('C', count($ints)));

        return (string) (call_user_func_array('pack', $args));

    }

    /**

     * Cache-timing-safe variant of ord()

     *

     * @internal You should not use this directly from another application

     *

     * @param int $int

     * @return string

     * @throws TypeError

     */

    public static function intToChr($int)

    {

        return pack('C', $int);

    }

    /**

     * Load a 3 character substring into an integer

     *

     * @internal You should not use this directly from another application

     *

     * @param string $string

     * @return int

     * @throws RangeException

     * @throws TypeError

     */

    public static function load_3($string)

    {

        /* Type checks: */

        if (!is_string($string)) {

            throw new TypeError('Argument 1 must be a string, ' . gettype($string) . ' given.');

        }

        /* Input validation: */

        if (self::strlen($string) < 3) {

            throw new RangeException(

                'String must be 3 bytes or more; ' . self::strlen($string) . ' given.'

            );

        }

        /** @var array<int, int> $unpacked */

        $unpacked = unpack('V', $string . "\0");

        return (int) ($unpacked[1] & 0xffffff);

    }

    /**

     * Load a 4 character substring into an integer

     *