<?php

/**

 * Class ParagonIE_Sodium_Core32_Int64

 *

 * Encapsulates a 64-bit integer.

 *

 * These are immutable. It always returns a new instance.

 */

class ParagonIE_Sodium_Core32_Int64

{

    /**

     * @var array<int, int> - four 16-bit integers

     */

    public $limbs = array(0, 0, 0, 0);

    /**

     * @var int

     */

    public $overflow = 0;

    /**

     * @var bool

     */

    public $unsignedInt = false;

    /**

     * ParagonIE_Sodium_Core32_Int64 constructor.

     * @param array $array

     * @param bool $unsignedInt

     */

    public function __construct($array = array(0, 0, 0, 0), $unsignedInt = false)

    {

        $this->limbs = array(

            (int) $array[0],

            (int) $array[1],

            (int) $array[2],

            (int) $array[3]

        );

        $this->overflow = 0;

        $this->unsignedInt = $unsignedInt;

    }

    /**

     * Adds two int64 objects

     *

     * @param ParagonIE_Sodium_Core32_Int64 $addend

     * @return ParagonIE_Sodium_Core32_Int64

     */

    public function addInt64(ParagonIE_Sodium_Core32_Int64 $addend)

    {

        $i0 = $this->limbs[0];

        $i1 = $this->limbs[1];

        $i2 = $this->limbs[2];

        $i3 = $this->limbs[3];

        $j0 = $addend->limbs[0];

        $j1 = $addend->limbs[1];

        $j2 = $addend->limbs[2];

        $j3 = $addend->limbs[3];

        $r3 = $i3 + ($j3 & 0xffff);

        $carry = $r3 >> 16;

        $r2 = $i2 + ($j2 & 0xffff) + $carry;

        $carry = $r2 >> 16;

        $r1 = $i1 + ($j1 & 0xffff) + $carry;

        $carry = $r1 >> 16;

        $r0 = $i0 + ($j0 & 0xffff) + $carry;

        $carry = $r0 >> 16;

        $r0 &= 0xffff;

        $r1 &= 0xffff;

        $r2 &= 0xffff;

        $r3 &= 0xffff;

        $return = new ParagonIE_Sodium_Core32_Int64(

            array($r0, $r1, $r2, $r3)

        );

        $return->overflow = $carry;

        $return->unsignedInt = $this->unsignedInt;

        return $return;

    }

    /**

     * Adds a normal integer to an int64 object

     *

     * @param int $int

     * @return ParagonIE_Sodium_Core32_Int64

     * @throws SodiumException

     * @throws TypeError

     */

    public function addInt($int)

    {

        ParagonIE_Sodium_Core32_Util::declareScalarType($int, 'int', 1);

        /** @var int $int */

        $int = (int) $int;

        $i0 = $this->limbs[0];

        $i1 = $this->limbs[1];

        $i2 = $this->limbs[2];

        $i3 = $this->limbs[3];

        $r3 = $i3 + ($int & 0xffff);

        $carry = $r3 >> 16;

        $r2 = $i2 + (($int >> 16) & 0xffff) + $carry;

        $carry = $r2 >> 16;

        $r1 = $i1 + $carry;

        $carry = $r1 >> 16;

        $r0 = $i0 + $carry;

        $carry = $r0 >> 16;

        $r0 &= 0xffff;

        $r1 &= 0xffff;

        $r2 &= 0xffff;

        $r3 &= 0xffff;

        $return = new ParagonIE_Sodium_Core32_Int64(

            array($r0, $r1, $r2, $r3)

        );

        $return->overflow = $carry;

        $return->unsignedInt = $this->unsignedInt;

        return $return;

    }

    /**

     * @param int $b

     * @return int

     */

    public function compareInt($b = 0)

    {

        $gt = 0;

        $eq = 1;

        $i = 4;

        $j = 0;

        while ($i > 0) {

            --$i;

            /** @var int $x1 */

            $x1 = $this->limbs[$i];

            /** @var int $x2 */

            $x2 = ($b >> ($j << 4)) & 0xffff;

            /** int */

            $gt |= (($x2 - $x1) >> 8) & $eq;

            /** int */

            $eq &= (($x2 ^ $x1) - 1) >> 8;

        }

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

    }

    /**

     * @param int $b

     * @return bool

     */

    public function isGreaterThan($b = 0)

    {

        return $this->compareInt($b) > 0;

    }

    /**

     * @param int $b

     * @return bool

     */

    public function isLessThanInt($b = 0)

    {

        return $this->compareInt($b) < 0;

    }

    /**

     * @param int $hi

     * @param int $lo

     * @return ParagonIE_Sodium_Core32_Int64

     */

    public function mask64($hi = 0, $lo = 0)

    {

        /** @var int $a */

        $a = ($hi >> 16) & 0xffff;

        /** @var int $b */

        $b = ($hi) & 0xffff;

        /** @var int $c */

        $c = ($lo >> 16) & 0xffff;

        /** @var int $d */

        $d = ($lo & 0xffff);

        return new ParagonIE_Sodium_Core32_Int64(

            array(

                $this->limbs[0] & $a,

                $this->limbs[1] & $b,

                $this->limbs[2] & $c,

                $this->limbs[3] & $d

            ),

            $this->unsignedInt

        );

    }

    /**

     * @param int $int

     * @param int $size

     * @return ParagonIE_Sodium_Core32_Int64

     * @throws SodiumException

     * @throws TypeError

     * @psalm-suppress MixedAssignment

     */

    public function mulInt($int = 0, $size = 0)

    {

        if (ParagonIE_Sodium_Compat::$fastMult) {

            return $this->mulIntFast($int);

        }

        ParagonIE_Sodium_Core32_Util::declareScalarType($int, 'int', 1);

        ParagonIE_Sodium_Core32_Util::declareScalarType($size, 'int', 2);

        /** @var int $int */

        $int = (int) $int;

        /** @var int $size */

        $size = (int) $size;

        if (!$size) {

            $size = 63;

        }

        $a = clone $this;

        $return = new ParagonIE_Sodium_Core32_Int64();

        $return->unsignedInt = $this->unsignedInt;

        // Initialize:

        $ret0 = 0;

        $ret1 = 0;

        $ret2 = 0;

        $ret3 = 0;

        $a0 = $a->limbs[0];

        $a1 = $a->limbs[1];

        $a2 = $a->limbs[2];

        $a3 = $a->limbs[3];

        /** @var int $size */

        /** @var int $i */

        for ($i = $size; $i >= 0; --$i) {

            $mask = -($int & 1);

            $x0 = $a0 & $mask;

            $x1 = $a1 & $mask;

            $x2 = $a2 & $mask;

            $x3 = $a3 & $mask;

            $ret3 += $x3;

            $c = $ret3 >> 16;

            $ret2 += $x2 + $c;

            $c = $ret2 >> 16;

            $ret1 += $x1 + $c;

            $c = $ret1 >> 16;

            $ret0 += $x0 + $c;

            $ret0 &= 0xffff;

            $ret1 &= 0xffff;

            $ret2 &= 0xffff;

            $ret3 &= 0xffff;

            $a3 = $a3 << 1;

            $x3 = $a3 >> 16;

            $a2 = ($a2 << 1) | $x3;

            $x2 = $a2 >> 16;

            $a1 = ($a1 << 1) | $x2;

            $x1 = $a1 >> 16;

            $a0 = ($a0 << 1) | $x1;

            $a0 &= 0xffff;

            $a1 &= 0xffff;

            $a2 &= 0xffff;

            $a3 &= 0xffff;

            $int >>= 1;

        }

        $return->limbs[0] = $ret0;

        $return->limbs[1] = $ret1;

        $return->limbs[2] = $ret2;

        $return->limbs[3] = $ret3;

        return $return;

    }

    /**

     * @param ParagonIE_Sodium_Core32_Int64 $A

     * @param ParagonIE_Sodium_Core32_Int64 $B

     * @return array<int, ParagonIE_Sodium_Core32_Int64>

     * @throws SodiumException

     * @throws TypeError

     * @psalm-suppress MixedInferredReturnType

     */

    public static function ctSelect(

        ParagonIE_Sodium_Core32_Int64 $A,

        ParagonIE_Sodium_Core32_Int64 $B

    ) {

        $a = clone $A;

        $b = clone $B;

        /** @var int $aNeg */

        $aNeg = ($a->limbs[0] >> 15) & 1;

        /** @var int $bNeg */

        $bNeg = ($b->limbs[0] >> 15) & 1;

        /** @var int $m */

        $m = (-($aNeg & $bNeg)) | 1;

        /** @var int $swap */

        $swap = $bNeg & ~$aNeg;

        /** @var int $d */

        $d = -$swap;

        /*

        if ($bNeg && !$aNeg) {

            $a = clone $int;

            $b = clone $this;

        } elseif($bNeg && $aNeg) {

            $a = $this->mulInt(-1);

            $b = $int->mulInt(-1);

        }

         */

        $x = $a->xorInt64($b)->mask64($d, $d);

        return array(

            $a->xorInt64($x)->mulInt($m),

            $b->xorInt64($x)->mulInt($m)

        );

    }

    /**

     * @param array<int, int> $a

     * @param array<int, int> $b

     * @param int $baseLog2

     * @return array<int, int>

     */

    public function multiplyLong(array $a, array $b, $baseLog2 = 16)

    {

        $a_l = count($a);

        $b_l = count($b);

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

        $r = array_fill(0, $a_l + $b_l + 1, 0);

        $base = 1 << $baseLog2;

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

            $a_i = $a[$i];

            for ($j = 0; $j < $a_l; ++$j) {

                $b_j = $b[$j];

                $product = (($a_i * $b_j) + $r[$i + $j]);

                $carry = (((int) $product >> $baseLog2) & 0xffff);

                $r[$i + $j] = ((int) $product - (int) ($carry * $base)) & 0xffff;

                $r[$i + $j + 1] += $carry;

            }

        }

        return array_slice($r, 0, 5);

    }

    /**

     * @param int $int

     * @return ParagonIE_Sodium_Core32_Int64

     */

    public function mulIntFast($int)

    {

        // Handle negative numbers

        $aNeg = ($this->limbs[0] >> 15) & 1;

        $bNeg = ($int >> 31) & 1;

        $a = array_reverse($this->limbs);

        $b = array(

            $int & 0xffff,

            ($int >> 16) & 0xffff,

            -$bNeg & 0xffff,

            -$bNeg & 0xffff

        );

        if ($aNeg) {

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

                $a[$i] = ($a[$i] ^ 0xffff) & 0xffff;

            }

            ++$a[0];

        }

        if ($bNeg) {

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

                $b[$i] = ($b[$i] ^ 0xffff) & 0xffff;

            }

            ++$b[0];

        }

        // Multiply

        $res = $this->multiplyLong($a, $b);

        // Re-apply negation to results

        if ($aNeg !== $bNeg) {

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

                $res[$i] = (0xffff ^ $res[$i]) & 0xffff;

            }

            // Handle integer overflow

            $c = 1;

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

                $res[$i] += $c;

                $c = $res[$i] >> 16;

                $res[$i] &= 0xffff;

            }

        }

        // Return our values

        $return = new ParagonIE_Sodium_Core32_Int64();

        $return->limbs = array(

            $res[3] & 0xffff,

            $res[2] & 0xffff,

            $res[1] & 0xffff,

            $res[0] & 0xffff

        );

        if (count($res) > 4) {

            $return->overflow = $res[4] & 0xffff;

        }

        $return->unsignedInt = $this->unsignedInt;

        return $return;

    }

    /**

     * @param ParagonIE_Sodium_Core32_Int64 $right

     * @return ParagonIE_Sodium_Core32_Int64

     */