<?php

declare(strict_types=1);

namespace GlobusStudio\QRCode\Encoder;

use GlobusStudio\QRCode\Data\AbstractQRData;

use GlobusStudio\QRCode\Data\AlphanumericData;

use GlobusStudio\QRCode\Data\ByteData;

use GlobusStudio\QRCode\Data\KanjiData;

use GlobusStudio\QRCode\Data\NumericData;

use GlobusStudio\QRCode\Data\QRDataInterface;

use GlobusStudio\QRCode\ErrorCorrection\ErrorCorrectionLevel;

use GlobusStudio\QRCode\ErrorCorrection\Polynomial;

use GlobusStudio\QRCode\ErrorCorrection\RSBlock;

use GlobusStudio\QRCode\Math\GaloisField;

use GlobusStudio\QRCode\Util\ModeDetector;

use GlobusStudio\QRCode\Util\Version;

final class Encoder

{

private const PAD0 = 0xEC;

private const PAD1 = 0x11;

private const G15 = (1 << 10) | (1 << 8) | (1 << 5) | (1 << 4) | (1 << 2) | (1 << 1) | (1 << 0);

private const G18 = (1 << 12) | (1 << 11) | (1 << 10) | (1 << 9) | (1 << 8) | (1 << 5) | (1 << 2) | (1 << 0);

private const G15_MASK = (1 << 14) | (1 << 12) | (1 << 10) | (1 << 4) | (1 << 1);

/**

* @return bool[][]

*/

public static function encode(string $data, int $errorCorrectionLevel = ErrorCorrectionLevel::M, ?int $version = null, ?int $maskPattern = null): array

{

ErrorCorrectionLevel::validate($errorCorrectionLevel);

if ($maskPattern !== null && ($maskPattern < 0 || $maskPattern > 7)) {

throw new \InvalidArgumentException("Invalid mask pattern: $maskPattern (must be 0-7)");

}

$mode = ModeDetector::detect($data);

$qrData = self::createDataObject($data, $mode);

if ($version === null) {

$version = Version::getMinimumVersion(

$qrData->getLength(),

$mode,

$errorCorrectionLevel

);

}

$moduleCount = $version * 4 + 17;

$modules = self::createNullMatrix($moduleCount);

self::setupPositionProbePattern($modules, $moduleCount, 0, 0);

self::setupPositionProbePattern($modules, $moduleCount, $moduleCount - 7, 0);

self::setupPositionProbePattern($modules, $moduleCount, 0, $moduleCount - 7);

self::setupPositionAdjustPattern($modules, $moduleCount, $version);

self::setupTimingPattern($modules, $moduleCount);

$bestPattern = $maskPattern ?? self::findBestMaskPattern($modules, $moduleCount, $version, $errorCorrectionLevel, [$qrData]);

self::setupTypeInfo($modules, $moduleCount, false, $bestPattern, $errorCorrectionLevel);

if ($version >= 7) {

self::setupTypeNumber($modules, $moduleCount, false, $version);

}

$encodedData = self::createEncodedData($version, $errorCorrectionLevel, [$qrData]);

self::mapData($modules, $moduleCount, $encodedData, $bestPattern);

return self::toBoolMatrix($modules, $moduleCount);

}

private static function createDataObject(string $data, int $mode): QRDataInterface

{

switch ($mode) {

case AbstractQRData::MODE_NUMBER:

return new NumericData($data);

case AbstractQRData::MODE_ALPHA_NUM:

return new AlphanumericData($data);

case AbstractQRData::MODE_KANJI:

return new KanjiData($data);

default:

return new ByteData($data);

}

}

/**

* @return array<int, array<int, bool|null>>

*/

private static function createNullMatrix(int $size): array

{

$matrix = [];

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

$matrix[$i] = array_fill(0, $size, null);

}

return $matrix;

}

/**

* @param array<int, array<int, bool|null>> $modules

*/

private static function setupPositionProbePattern(array &$modules, int $moduleCount, int $row, int $col): void

{

for ($r = -1; $r <= 7; $r++) {

for ($c = -1; $c <= 7; $c++) {

if ($row + $r <= -1 || $moduleCount <= $row + $r

|| $col + $c <= -1 || $moduleCount <= $col + $c) {

continue;

}

$modules[$row + $r][$col + $c] =

(0 <= $r && $r <= 6 && ($c === 0 || $c === 6))

|| (0 <= $c && $c <= 6 && ($r === 0 || $r === 6))

|| (2 <= $r && $r <= 4 && 2 <= $c && $c <= 4);

}

}

}

/**

* @param array<int, array<int, bool|null>> $modules

*/

private static function setupPositionAdjustPattern(array &$modules, int $moduleCount, int $version): void

{

$pos = Version::getPatternPosition($version);

$posCount = count($pos);

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

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

$row = $pos[$i];

$col = $pos[$j];

if ($modules[$row][$col] !== null) {

continue;

}

for ($r = -2; $r <= 2; $r++) {

for ($c = -2; $c <= 2; $c++) {

$modules[$row + $r][$col + $c] =

$r === -2 || $r === 2 || $c === -2 || $c === 2 || ($r === 0 && $c === 0);

}

}

}

}

}

/**

* @param array<int, array<int, bool|null>> $modules

*/

private static function setupTimingPattern(array &$modules, int $moduleCount): void

{

for ($i = 8; $i < $moduleCount - 8; $i++) {

if ($modules[$i][6] !== null) {

continue;

}

$modules[$i][6] = ($i % 2 === 0);

$modules[6][$i] = ($i % 2 === 0);

}

}

/**

* @param array<int, array<int, bool|null>> $modules

*/

private static function setupTypeInfo(array &$modules, int $moduleCount, bool $test, int $maskPattern, int $errorCorrectionLevel): void

{

$data = ($errorCorrectionLevel << 3) | $maskPattern;

$bits = self::getBCHTypeInfo($data);

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

$mod = (!$test && (($bits >> $i) & 1) === 1);

if ($i < 6) {

$modules[$i][8] = $mod;

} elseif ($i < 8) {

$modules[$i + 1][8] = $mod;

} else {

$modules[$moduleCount - 15 + $i][8] = $mod;

}

if ($i < 8) {

$modules[8][$moduleCount - $i - 1] = $mod;

} elseif ($i < 9) {

$modules[8][15 - $i - 1 + 1] = $mod;

} else {

$modules[8][15 - $i - 1] = $mod;

}

}

$modules[$moduleCount - 8][8] = !$test;

}

/**

* @param array<int, array<int, bool|null>> $modules

*/

private static function setupTypeNumber(array &$modules, int $moduleCount, bool $test, int $version): void

{

$bits = self::getBCHTypeNumber($version);

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

$mod = (!$test && (($bits >> $i) & 1) === 1);

$modules[(int) ($i / 3)][$i % 3 + $moduleCount - 8 - 3] = $mod;

$modules[$i % 3 + $moduleCount - 8 - 3][(int) ($i / 3)] = $mod;

}

}

/**

* @param array<int, array<int, bool|null>> $modules

* @param QRDataInterface[] $dataList

*/

private static function findBestMaskPattern(array &$modules, int $moduleCount, int $version, int $errorCorrectionLevel, array $dataList): int

{

$minLostPoint = PHP_INT_MAX;

$bestPattern = 0;

for ($pattern = 0; $pattern < 8; $pattern++) {

$testModules = $modules;

self::setupTypeInfo($testModules, $moduleCount, true, $pattern, $errorCorrectionLevel);

if ($version >= 7) {

self::setupTypeNumber($testModules, $moduleCount, true, $version);

}

$data = self::createEncodedData($version, $errorCorrectionLevel, $dataList);

self::mapData($testModules, $moduleCount, $data, $pattern);

/** @var array<int, array<int, bool>> $boolMatrix */

$boolMatrix = self::toBoolMatrix($testModules, $moduleCount);

$lostPoint = MaskPattern::getLostPoint($boolMatrix, $moduleCount);

if ($lostPoint < $minLostPoint) {

$minLostPoint = $lostPoint;

$bestPattern = $pattern;

}

}

return $bestPattern;

}

/**

* @param QRDataInterface[] $dataList

* @return int[]

*/

private static function createEncodedData(int $version, int $errorCorrectionLevel, array $dataList): array

{

$rsBlocks = RSBlock::getBlocks($version, $errorCorrectionLevel);

$buffer = new BitBuffer();

foreach ($dataList as $data) {

$buffer->put($data->getMode(), 4);

$buffer->put($data->getLength(), $data->getLengthInBits($version));

$data->write($buffer);

}

$totalDataCount = 0;

foreach ($rsBlocks as $block) {

$totalDataCount += $block->getDataCount();

}

if ($buffer->getLengthInBits() > $totalDataCount * 8) {

throw new \OverflowException(

"Code length overflow: {$buffer->getLengthInBits()} > " . ($totalDataCount * 8)

);

}

if ($buffer->getLengthInBits() + 4 <= $totalDataCount * 8) {

$buffer->put(0, 4);

}

while ($buffer->getLengthInBits() % 8 !== 0) {

$buffer->putBit(false);

}

while ($buffer->getLengthInBits() < $totalDataCount * 8) {

$buffer->put(self::PAD0, 8);

if ($buffer->getLengthInBits() >= $totalDataCount * 8) {

break;

}

$buffer->put(self::PAD1, 8);

}

return self::createBytes($buffer, $rsBlocks);

}

/**

* @param RSBlock[] $rsBlocks

* @return int[]

*/

private static function createBytes(BitBuffer $buffer, array $rsBlocks): array

{

$offset = 0;

$maxDcCount = 0;

$maxEcCount = 0;

$rsBlockCount = count($rsBlocks);

/** @var array<int, int[]> $dcdata */

$dcdata = [];

/** @var array<int, int[]> $ecdata */

$ecdata = [];

for ($r = 0; $r < $rsBlockCount; $r++) {

$dcCount = $rsBlocks[$r]->getDataCount();

$ecCount = $rsBlocks[$r]->getTotalCount() - $dcCount;

$maxDcCount = max($maxDcCount, $dcCount);

$maxEcCount = max($maxEcCount, $ecCount);

/** @var int[] $dcRow */

$dcRow = array_fill(0, $dcCount, 0);

$bdata = $buffer->getBuffer();

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

$dcRow[$i] = 0xFF & $bdata[$i + $offset];

}

$dcdata[$r] = $dcRow;

$offset += $dcCount;

$rsPoly = self::getErrorCorrectPolynomial($ecCount);

$rawPoly = new Polynomial($dcdata[$r], $rsPoly->getLength() - 1);

$modPoly = $rawPoly->mod($rsPoly);

$ecDataCount = $rsPoly->getLength() - 1;

/** @var int[] $ecRow */

$ecRow = array_fill(0, $ecDataCount, 0);

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

$modIndex = $i + $modPoly->getLength() - $ecDataCount;

$ecRow[$i] = ($modIndex >= 0) ? $modPoly->get($modIndex) : 0;

}

$ecdata[$r] = $ecRow;

}

$totalCodeCount = 0;

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

$totalCodeCount += $rsBlocks[$i]->getTotalCount();

}

/** @var int[] $data */

$data = array_fill(0, $totalCodeCount, 0);

$index = 0;

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

for ($r = 0; $r < $rsBlockCount; $r++) {

if ($i < count($dcdata[$r])) {

$data[$index++] = $dcdata[$r][$i];

}

}

}

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

for ($r = 0; $r < $rsBlockCount; $r++) {

if ($i < count($ecdata[$r])) {

$data[$index++] = $ecdata[$r][$i];

}

}

}

return $data;

}

private static function getErrorCorrectPolynomial(int $errorCorrectLength): Polynomial

{

$a = new Polynomial([1]);

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

$a = $a->multiply(new Polynomial([1, GaloisField::exp($i)]));

}

return $a;

}

/**

* @param array<int, array<int, bool|null>> $modules

* @param int[] $data

*/

private static function mapData(array &$modules, int $moduleCount, array $data, int $maskPattern): void

{

$inc = -1;

$row = $moduleCount - 1;

$bitIndex = 7;

$byteIndex = 0;

$dataCount = count($data);

for ($col = $moduleCount - 1; $col > 0; $col -= 2) {

if ($col === 6) {

$col--;

}

while (true) {

for ($c = 0; $c < 2; $c++) {

if ($modules[$row][$col - $c] === null) {

$dark = false;

if ($byteIndex < $dataCount) {

$dark = (($data[$byteIndex] >> $bitIndex) & 1) === 1;

}

if (MaskPattern::getMask($maskPattern, $row, $col - $c)) {

$dark = !$dark;

}

$modules[$row][$col - $c] = $dark;

$bitIndex--;

if ($bitIndex === -1) {

$byteIndex++;

$bitIndex = 7;

}

}

}

$row += $inc;

if ($row < 0 || $moduleCount <= $row) {

$row -= $inc;

$inc = -$inc;

break;

}

}

}

}

/**

* @param array<int, array<int, bool|null>> $modules

* @return bool[][]

*/

private static function toBoolMatrix(array $modules, int $moduleCount): array

{

$result = [];

for ($r = 0; $r < $moduleCount; $r++) {

$result[$r] = [];

for ($c = 0; $c < $moduleCount; $c++) {

$result[$r][$c] = $modules[$r][$c] === true;

}

}

return $result;

}

private static function getBCHTypeInfo(int $data): int

{

$d = $data << 10;

while (self::getBCHDigit($d) - self::getBCHDigit(self::G15) >= 0) {

$d ^= (self::G15 << (self::getBCHDigit($d) - self::getBCHDigit(self::G15)));

}

return (($data << 10) | $d) ^ self::G15_MASK;

}

private static function getBCHTypeNumber(int $data): int

{

$d = $data << 12;

while (self::getBCHDigit($d) - self::getBCHDigit(self::G18) >= 0) {

$d ^= (self::G18 << (self::getBCHDigit($d) - self::getBCHDigit(self::G18)));

}

return ($data << 12) | $d;

}

private static function getBCHDigit(int $data): int

{

$digit = 0;

while ($data !== 0) {

$digit++;

$data >>= 1;

}

return $digit;

}

}