<?php
/**
 * SCSSPHP
 *
 * @copyright 2012-2018 Leaf Corcoran
 *
 * @license http://opensource.org/licenses/MIT MIT
 *
 * @link http://leafo.github.io/scssphp
 */

namespace Leafo\ScssPhp\SourceMap;

/**
 * Base64 VLQ Encoder
 *
 * {@internal Derivative of oyejorge/less.php's lib/SourceMap/Base64VLQ.php, relicensed with permission. }}
 *
 * @author Josh Schmidt <oyejorge@gmail.com>
 * @author Nicolas FRANÇOIS <nicolas.francois@frog-labs.com>
 */
class Base64VLQEncoder
{
    /**
     * Shift
     *
     * @var integer
     */
    private $shift = 5;

    /**
     * Mask
     *
     * @var integer
     */
    private $mask = 0x1F; // == (1 << shift) == 0b00011111

    /**
     * Continuation bit
     *
     * @var integer
     */
    private $continuationBit = 0x20; // == (mask - 1 ) == 0b00100000

    /**
     * Char to integer map
     *
     * @var array
     */
    private $charToIntMap = [
        'A' => 0,  'B' => 1,  'C' => 2,  'D' => 3,  'E' => 4,  'F' => 5,  'G' => 6,  'H' => 7,
        'I' => 8,  'J' => 9,  'K' => 10, 'L' => 11, 'M' => 12, 'N' => 13, 'O' => 14, 'P' => 15,
        'Q' => 16, 'R' => 17, 'S' => 18, 'T' => 19, 'U' => 20, 'V' => 21, 'W' => 22, 'X' => 23,
        'Y' => 24, 'Z' => 25, 'a' => 26, 'b' => 27, 'c' => 28, 'd' => 29, 'e' => 30, 'f' => 31,
        'g' => 32, 'h' => 33, 'i' => 34, 'j' => 35, 'k' => 36, 'l' => 37, 'm' => 38, 'n' => 39,
        'o' => 40, 'p' => 41, 'q' => 42, 'r' => 43, 's' => 44, 't' => 45, 'u' => 46, 'v' => 47,
        'w' => 48, 'x' => 49, 'y' => 50, 'z' => 51,   0 => 52,   1 => 53,   2 => 54,   3 => 55,
          4 => 56,   5 => 57,   6 => 58,   7 => 59,   8 => 60,   9 => 61, '+' => 62, '/' => 63,
    ];

    /**
     * Integer to char map
     *
     * @var array
     */
    private $intToCharMap = [
         0 => 'A',  1 => 'B',  2 => 'C',  3 => 'D',  4 => 'E',  5 => 'F',  6 => 'G',  7 => 'H',
         8 => 'I',  9 => 'J', 10 => 'K', 11 => 'L', 12 => 'M', 13 => 'N', 14 => 'O', 15 => 'P',
        16 => 'Q', 17 => 'R', 18 => 'S', 19 => 'T', 20 => 'U', 21 => 'V', 22 => 'W', 23 => 'X',
        24 => 'Y', 25 => 'Z', 26 => 'a', 27 => 'b', 28 => 'c', 29 => 'd', 30 => 'e', 31 => 'f',
        32 => 'g', 33 => 'h', 34 => 'i', 35 => 'j', 36 => 'k', 37 => 'l', 38 => 'm', 39 => 'n',
        40 => 'o', 41 => 'p', 42 => 'q', 43 => 'r', 44 => 's', 45 => 't', 46 => 'u', 47 => 'v',
        48 => 'w', 49 => 'x', 50 => 'y', 51 => 'z', 52 => '0', 53 => '1', 54 => '2', 55 => '3',
        56 => '4', 57 => '5', 58 => '6', 59 => '7', 60 => '8', 61 => '9', 62 => '+', 63 => '/',
    ];

    /**
     * Constructor
     */
    public function __construct()
    {
        // I leave it here for future reference
        // foreach (str_split('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/') as $i => $char)
        // {
        //     $this->charToIntMap[$char] = $i;
        //     $this->intToCharMap[$i] = $char;
        // }
    }

    /**
     * Convert from a two-complement value to a value where the sign bit is
     * is placed in the least significant bit. For example, as decimals:
     *   1 becomes 2 (10 binary), -1 becomes 3 (11 binary)
     *   2 becomes 4 (100 binary), -2 becomes 5 (101 binary)
     * We generate the value for 32 bit machines, hence -2147483648 becomes 1, not 4294967297,
     * even on a 64 bit machine.
     *
     * @param string $aValue
     */
    public function toVLQSigned($aValue)
    {
        return 0xffffffff & ($aValue < 0 ? ((-$aValue) << 1) + 1 : ($aValue << 1) + 0);
    }

    /**
     * Convert to a two-complement value from a value where the sign bit is
     * is placed in the least significant bit. For example, as decimals:
     *   2 (10 binary) becomes 1, 3 (11 binary) becomes -1
     *   4 (100 binary) becomes 2, 5 (101 binary) becomes -2
     * We assume that the value was generated with a 32 bit machine in mind.
     * Hence
     *   1 becomes -2147483648
     * even on a 64 bit machine.
     *
     * @param integer $aValue
     */
    public function fromVLQSigned($aValue)
    {
        return $aValue & 1 ? $this->zeroFill(~$aValue + 2, 1) | (-1 - 0x7fffffff) : $this->zeroFill($aValue, 1);
    }

    /**
     * Return the base 64 VLQ encoded value.
     *
     * @param string $aValue The value to encode
     *
     * @return string The encoded value
     */
    public function encode($aValue)
    {
        $encoded = '';
        $vlq = $this->toVLQSigned($aValue);

        do {
            $digit = $vlq & $this->mask;
            $vlq = $this->zeroFill($vlq, $this->shift);

            if ($vlq > 0) {
                $digit |= $this->continuationBit;
            }

            $encoded .= $this->base64Encode($digit);
        } while ($vlq > 0);

        return $encoded;
    }

    /**
     * Return the value decoded from base 64 VLQ.
     *
     * @param string $encoded The encoded value to decode
     *
     * @return integer The decoded value
     */
    public function decode($encoded)
    {
        $vlq = 0;
        $i = 0;

        do {
            $digit = $this->base64Decode($encoded[$i]);
            $vlq |= ($digit & $this->mask) << ($i * $this->shift);
            $i++;
        } while ($digit & $this->continuationBit);

        return $this->fromVLQSigned($vlq);
    }

    /**
     * Right shift with zero fill.
     *
     * @param integer $a number to shift
     * @param integer $b number of bits to shift
     *
     * @return integer
     */
    public function zeroFill($a, $b)
    {
        return ($a >= 0) ? ($a >> $b) : ($a >> $b) & (PHP_INT_MAX >> ($b - 1));
    }

    /**
     * Encode single 6-bit digit as base64.
     *
     * @param integer $number
     *
     * @return string
     *
     * @throws \Exception If the number is invalid
     */
    public function base64Encode($number)
    {
        if ($number < 0 || $number > 63) {
            throw new \Exception(sprintf('Invalid number "%s" given. Must be between 0 and 63.', $number));
        }

        return $this->intToCharMap[$number];
    }

    /**
     * Decode single 6-bit digit from base64
     *
     * @param string $char
     *
     * @return integer
     *
     * @throws \Exception If the number is invalid
     */
    public function base64Decode($char)
    {
        if (! array_key_exists($char, $this->charToIntMap)) {
            throw new \Exception(sprintf('Invalid base 64 digit "%s" given.', $char));
        }

        return $this->charToIntMap[$char];
    }
}
