Elep

<?php
/**
 * PhpMyAdmin\Plugins\Export\Helpers\Pdf class
 */

declare(strict_types=1);

namespace PhpMyAdmin\Plugins\Export\Helpers;

use PhpMyAdmin\ConfigStorage\Relation;
use PhpMyAdmin\DatabaseInterface;
use PhpMyAdmin\Dbal\ConnectionType;
use PhpMyAdmin\Dbal\ResultInterface;
use PhpMyAdmin\FieldMetadata;
use PhpMyAdmin\Pdf as PdfLib;
use PhpMyAdmin\Transformations;
use PhpMyAdmin\Triggers\Triggers;
use PhpMyAdmin\Util;
use TCPDF_STATIC;

use function __;
use function array_key_exists;
use function count;
use function ksort;

/**
 * Adapted from a LGPL script by Philip Clarke
 */
class Pdf extends PdfLib
{
    /** @var mixed[] */
    public array $tablewidths = [];

/** @var mixed[] */
    public array $headerset = [];

private int|float $dataY = 0;

private int $titleFontSize = 0;

private string $titleText = '';

private string $dbAlias = '';

private string $tableAlias = '';

private string $purpose = '';

/** @var mixed[] */
    private array $colTitles = [];

private ResultInterface $results;

/** @var mixed[] */
    private array $colAlign = [];

/** @var mixed[] */
    private array $displayColumn = [];

private string $currentDb = '';

private string $currentTable = '';

/** @var mixed[] */
    private array $aliases = [];

private Relation $relation;

private Transformations $transformations;

/**
     * Constructs PDF and configures standard parameters.
     *
     * @param string    $orientation page orientation
     * @param string    $unit        unit
     * @param string    $format      the format used for pages
     * @param bool      $unicode     true means that the input text is unicode
     * @param string    $encoding    charset encoding; default is UTF-8.
     * @param bool      $diskcache   DEPRECATED TCPDF FEATURE
     * @param false|int $pdfa        If not false, set the document to PDF/A mode and the good version (1 or 3)
     */
    public function __construct(
        string $orientation = 'P',
        string $unit = 'mm',
        string $format = 'A4',
        bool $unicode = true,
        string $encoding = 'UTF-8',
        bool $diskcache = false,
        false|int $pdfa = false,
    ) {
        parent::__construct($orientation, $unit, $format, $unicode, $encoding, $diskcache, $pdfa);

$this->relation = new Relation(DatabaseInterface::getInstance());
        $this->transformations = new Transformations();
    }

/**
     * Add page if needed.
     *
     * @param float|int $h       cell height. Default value: 0
     * @param mixed     $y       starting y position, leave empty for current
     *                           position
     * @param bool      $addpage if true add a page, otherwise only return
     *                           the true/false state
     */
    public function checkPageBreak(mixed $h = 0, mixed $y = '', mixed $addpage = true): bool
    {
        if (TCPDF_STATIC::empty_string($y)) {
            $y = $this->y;
        }

$currentPage = $this->page;
        // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
        if ($y + $h > $this->PageBreakTrigger && ! $this->InFooter && $this->AcceptPageBreak()) {
            if ($addpage) {
                //Automatic page break
                $x = $this->x;
                // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
                $this->AddPage($this->CurOrientation);
                $this->y = $this->dataY;
                $oldpage = $this->page - 1;

$thisPageOrm = $this->pagedim[$this->page]['orm'];
                $oldPageOrm = $this->pagedim[$oldpage]['orm'];
                $thisPageOlm = $this->pagedim[$this->page]['olm'];
                $oldPageOlm = $this->pagedim[$oldpage]['olm'];
                if ($this->rtl) {
                    if ($thisPageOrm != $oldPageOrm) {
                        $this->x = $x - ($thisPageOrm - $oldPageOrm);
                    } else {
                        $this->x = $x;
                    }
                } elseif ($thisPageOlm != $oldPageOlm) {
                    $this->x = $x + $thisPageOlm - $oldPageOlm;
                } else {
                    $this->x = $x;
                }
            }

return true;
        }

// account for columns mode
        return $currentPage != $this->page;
    }

/**
     * This method is used to render the page header.
     */
    // phpcs:ignore PSR1.Methods.CamelCapsMethodName.NotCamelCaps
    public function Header(): void
    {
        $GLOBALS['maxY'] ??= null;

// We don't want automatic page breaks while generating header
        // as this can lead to infinite recursion as auto generated page
        // will want header as well causing another page break
        // FIXME: Better approach might be to try to compact the content
        $this->setAutoPageBreak(false);
        // Check if header for this page already exists
        // phpcs:disable Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
        if (! isset($this->headerset[$this->page])) {
            $this->setY($this->tMargin - ($this->FontSizePt / $this->k) * 5);
            $cellFontSize = $this->FontSizePt;
            $this->setFont(
                PdfLib::PMA_PDF_FONT,
                '',
                ($this->titleFontSize !== 0 ? $this->titleFontSize : $this->FontSizePt),
            );
            $this->Cell(0, $this->FontSizePt, $this->titleText, 0, 1, 'C');
            $this->setFont(PdfLib::PMA_PDF_FONT, '', $cellFontSize);
            $this->setY($this->tMargin - ($this->FontSizePt / $this->k) * 2.5);
            $this->Cell(
                0,
                $this->FontSizePt,
                __('Database:') . ' ' . $this->dbAlias . ',  '
                . __('Table:') . ' ' . $this->tableAlias . ',  '
                . __('Purpose:') . ' ' . $this->purpose,
                0,
                1,
                'L',
            );
            $l = $this->lMargin;
            foreach ($this->colTitles as $col => $txt) {
                $this->setXY($l, $this->tMargin);
                $this->MultiCell($this->tablewidths[$col], $this->FontSizePt, $txt ?? 'NULL');
                $l += $this->tablewidths[$col];
                $GLOBALS['maxY'] = $GLOBALS['maxY'] < $this->GetY() ? $this->GetY() : $GLOBALS['maxY'];
            }

$this->setXY($this->lMargin, $this->tMargin);
            $this->setFillColor(200, 200, 200);
            $l = $this->lMargin;
            foreach ($this->colTitles as $col => $txt) {
                $this->setXY($l, $this->tMargin);
                $this->Cell($this->tablewidths[$col], $GLOBALS['maxY'] - $this->tMargin, '', 1, 0, 'L', true);
                $this->setXY($l, $this->tMargin);
                $this->MultiCell($this->tablewidths[$col], $this->FontSizePt, $txt ?? 'NULL', 0, 'C');
                $l += $this->tablewidths[$col];
            }

$this->setFillColor(255, 255, 255);
            // set headerset
            $this->headerset[$this->page] = 1;
        }

// phpcs:enable

$this->dataY = $GLOBALS['maxY'];
        $this->setAutoPageBreak(true);
    }

/**
     * Generate table
     *
     * @param int|float $lineheight Height of line
     */
    public function morepagestable(int|float $lineheight = 8): void
    {
        // some things to set and 'remember'
        $l = $this->lMargin;
        $startheight = $h = $this->dataY;
        $startpage = $currpage = $this->page;

// calculate the whole width
        $fullwidth = 0;
        foreach ($this->tablewidths as $width) {
            $fullwidth += $width;
        }

// Now let's start to write the table
        $row = 0;
        $tmpheight = [];
        $maxpage = $this->page;

while ($data = $this->results->fetchRow()) {
            $this->page = $currpage;
            // write the horizontal borders
            $this->Line($l, $h, $fullwidth + $l, $h);
            // write the content and remember the height of the highest col
            foreach ($data as $col => $txt) {
                $this->page = $currpage;
                $this->setXY($l, $h);
                if ($this->tablewidths[$col] > 0) {
                    $this->MultiCell($this->tablewidths[$col], $lineheight, $txt ?? 'NULL', 0, $this->colAlign[$col]);
                    $l += $this->tablewidths[$col];
                }

if (! isset($tmpheight[$row . '-' . $this->page])) {
                    $tmpheight[$row . '-' . $this->page] = 0;
                }

if ($tmpheight[$row . '-' . $this->page] < $this->GetY()) {
                    $tmpheight[$row . '-' . $this->page] = $this->GetY();
                }

if ($this->page > $maxpage) {
                    $maxpage = $this->page;
                }

unset($data[$col]);
            }

// get the height we were in the last used page
            $h = $tmpheight[$row . '-' . $maxpage];
            // set the "pointer" to the left margin
            $l = $this->lMargin;
            // set the $currpage to the last page
            $currpage = $maxpage;
            unset($data[$row]);
            $row++;
        }

// draw the borders
        // we start adding a horizontal line on the last page
        $this->page = $maxpage;
        $this->Line($l, $h, $fullwidth + $l, $h);
        // now we start at the top of the document and walk down
        for ($i = $startpage; $i <= $maxpage; $i++) {
            $this->page = $i;
            $l = $this->lMargin;
            $t = $i == $startpage ? $startheight : $this->tMargin;
            $lh = $i == $maxpage ? $h : $this->h - $this->bMargin;
            $this->Line($l, $t, $l, $lh);
            foreach ($this->tablewidths as $width) {
                $l += $width;
                $this->Line($l, $t, $l, $lh);
            }
        }

// set it to the last page, if not it'll cause some problems
        $this->page = $maxpage;
    }

/**
     * Defines the top margin.
     * The method can be called before creating the first page.
     *
     * @param float $margin the margin
     */
    public function setTopMargin(mixed $margin): void
    {
        $this->tMargin = $margin;
    }

/**
     * Prints triggers
     *
     * @param string $db    database name
     * @param string $table table name
     */
    public function getTriggers(string $db, string $table): void
    {
        $triggers = Triggers::getDetails(DatabaseInterface::getInstance(), $db, $table);
        if ($triggers === []) {
            return; //prevents printing blank trigger list for any table
        }

unset(
            $this->tablewidths,
            $this->colTitles,
            $this->displayColumn,
            $this->colAlign,
        );

/**
         * Making table heading
         * Keeping column width constant
         */
        $this->colTitles[0] = __('Name');
        $this->tablewidths[0] = 90;
        $this->colTitles[1] = __('Time');
        $this->tablewidths[1] = 80;
        $this->colTitles[2] = __('Event');
        $this->tablewidths[2] = 40;
        $this->colTitles[3] = __('Definition');
        $this->tablewidths[3] = 240;

for ($columnsCnt = 0; $columnsCnt < 4; $columnsCnt++) {
            $this->colAlign[$columnsCnt] = 'L';
            $this->displayColumn[$columnsCnt] = true;
        }

// Starting to fill table with required info

$this->setY($this->tMargin);
        $this->AddPage();
        $this->setFont(PdfLib::PMA_PDF_FONT, '', 9);

$l = $this->lMargin;
        $startheight = $h = $this->dataY;
        $startpage = $currpage = $this->page;

// calculate the whole width
        $fullwidth = 0;
        foreach ($this->tablewidths as $width) {
            $fullwidth += $width;
        }

$row = 0;
        $tmpheight = [];
        $maxpage = $this->page;
        $data = [];

foreach ($triggers as $trigger) {
            $data[] = $trigger->name->getName();
            $data[] = $trigger->timing->value;
            $data[] = $trigger->event->value;
            $data[] = $trigger->statement;
            $this->page = $currpage;
            // write the horizontal borders
            $this->Line($l, $h, $fullwidth + $l, $h);
            // write the content and remember the height of the highest col
            foreach ($data as $col => $txt) {
                $this->page = $currpage;
                $this->setXY($l, $h);
                if ($this->tablewidths[$col] > 0) {
                    $this->MultiCell(
                        $this->tablewidths[$col],
                        // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
                        $this->FontSizePt,
                        $txt ?? 'NULL',
                        0,
                        $this->colAlign[$col],
                    );
                    $l += $this->tablewidths[$col];
                }

if (! isset($tmpheight[$row . '-' . $this->page])) {
                    $tmpheight[$row . '-' . $this->page] = 0;
                }

if ($tmpheight[$row . '-' . $this->page] < $this->GetY()) {
                    $tmpheight[$row . '-' . $this->page] = $this->GetY();
                }

if ($this->page <= $maxpage) {
                    continue;
                }

$maxpage = $this->page;
            }

// set it to the last page, if not it'll cause some problems
        $this->page = $maxpage;
    }

/**
     * Print $table's CREATE definition
     *
     * @param string $db         the database name
     * @param string $table      the table name
     * @param bool   $doRelation whether to include relation comments
     * @param bool   $doComments whether to include the pmadb-style column
     *                            comments as comments in the structure;
     *                            this is deprecated but the parameter is
     *                            left here because /export calls
     *                            PMA_exportStructure() also for other
     *                            export types which use this parameter
     * @param bool   $doMime     whether to include mime comments
     */
    public function getTableDef(
        string $db,
        string $table,
        bool $doRelation,
        bool $doComments,
        bool $doMime,
    ): void {
        $relationParameters = $this->relation->getRelationParameters();

unset(
            $this->tablewidths,
            $this->colTitles,
            $this->displayColumn,
            $this->colAlign,
        );

$dbi = DatabaseInterface::getInstance();
        /**
         * Gets fields properties
         */
        $dbi->selectDb($db);

/**
         * All these three checks do_relation, do_comment and do_mime is
         * not required. As presently all are set true by default.
         * But when, methods to take user input will be developed,
         * it will be of use
         */
        // Check if we can use Relations
        if ($doRelation) {
            // Find which tables are related with the current one and write it in
            // an array
            $resRel = $this->relation->getForeigners($db, $table);
            $haveRel = $resRel !== [];
        } else {
            $haveRel = false;
        }

//column count and table heading

$this->colTitles[0] = __('Column');
        $this->tablewidths[0] = 90;
        $this->colTitles[1] = __('Type');
        $this->tablewidths[1] = 80;
        $this->colTitles[2] = __('Null');
        $this->tablewidths[2] = 40;
        $this->colTitles[3] = __('Default');
        $this->tablewidths[3] = 120;

for ($columnsCnt = 0; $columnsCnt < 4; $columnsCnt++) {
            $this->colAlign[$columnsCnt] = 'L';
            $this->displayColumn[$columnsCnt] = true;
        }

if ($doRelation && $haveRel) {
            $this->colTitles[$columnsCnt] = __('Links to');
            $this->displayColumn[$columnsCnt] = true;
            $this->colAlign[$columnsCnt] = 'L';
            $this->tablewidths[$columnsCnt] = 120;
        }

if ($doComments) {
            $columnsCnt++;
            $this->colTitles[$columnsCnt] = __('Comments');
            $this->displayColumn[$columnsCnt] = true;
            $this->colAlign[$columnsCnt] = 'L';
            $this->tablewidths[$columnsCnt] = 120;
        }

if ($doMime && $relationParameters->browserTransformationFeature !== null) {
            $columnsCnt++;
            $this->colTitles[$columnsCnt] = __('Media type');
            $this->displayColumn[$columnsCnt] = true;
            $this->colAlign[$columnsCnt] = 'L';
            $this->tablewidths[$columnsCnt] = 120;
        }

// Starting to fill table with required info

$this->setY($this->tMargin);
        $this->AddPage();
        $this->setFont(PdfLib::PMA_PDF_FONT, '', 9);

// Now let's start to write the table structure

if ($doComments) {
            $comments = $this->relation->getComments($db, $table);
        }

if ($doMime && $relationParameters->browserTransformationFeature !== null) {
            $mimeMap = $this->transformations->getMime($db, $table, true);
        }

$columns = $dbi->getColumns($db, $table);

// some things to set and 'remember'
        $l = $this->lMargin;
        $startheight = $h = $this->dataY;
        $startpage = $currpage = $this->page;
        // calculate the whole width
        $fullwidth = 0;
        foreach ($this->tablewidths as $width) {
            $fullwidth += $width;
        }

$row = 0;
        $tmpheight = [];
        $maxpage = $this->page;
        $data = [];

// fun begin
        foreach ($columns as $column) {
            $extractedColumnSpec = Util::extractColumnSpec($column->type);

$type = $extractedColumnSpec['print_type'];
            if (empty($type)) {
                $type = ' ';
            }

$data[] = $column->field;
            $data[] = $type;
            $data[] = $column->isNull ? 'Yes' : 'No';
            $data[] = $column->default ?? ($column->isNull ? 'NULL' : '');

$fieldName = $column->field;

if ($doRelation && $haveRel) {
                $data[] = isset($resRel[$fieldName])
                    ? $resRel[$fieldName]['foreign_table']
                    . ' (' . $resRel[$fieldName]['foreign_field']
                    . ')'
                    : '';
            }

if ($doComments) {
                $data[] = $comments[$fieldName] ?? '';
            }

if ($doMime) {
                $data[] = isset($mimeMap[$fieldName])
                    ? $mimeMap[$fieldName]['mimetype']
                    : '';
            }

$this->page = $currpage;
            // write the horizontal borders
            $this->Line($l, $h, $fullwidth + $l, $h);
            // write the content and remember the height of the highest col
            foreach ($data as $col => $txt) {
                $this->page = $currpage;
                $this->setXY($l, $h);
                if ($this->tablewidths[$col] > 0) {
                    $this->MultiCell(
                        $this->tablewidths[$col],
                        // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
                        $this->FontSizePt,
                        $txt ?? 'NULL',
                        0,
                        $this->colAlign[$col],
                    );
                    $l += $this->tablewidths[$col];
                }

if (! isset($tmpheight[$row . '-' . $this->page])) {
                    $tmpheight[$row . '-' . $this->page] = 0;
                }

if ($tmpheight[$row . '-' . $this->page] < $this->GetY()) {
                    $tmpheight[$row . '-' . $this->page] = $this->GetY();
                }

if ($this->page <= $maxpage) {
                    continue;
                }

$maxpage = $this->page;
            }

// set it to the last page, if not it'll cause some problems
        $this->page = $maxpage;
    }

/**
     * MySQL report
     *
     * @param string $query Query to execute
     */
    public function mysqlReport(string $query): void
    {
        unset(
            $this->tablewidths,
            $this->colTitles,
            $this->displayColumn,
            $this->colAlign,
        );

$dbi = DatabaseInterface::getInstance();
        /**
         * Pass 1 for column widths
         */
        $this->results = $dbi->query($query, ConnectionType::User, DatabaseInterface::QUERY_UNBUFFERED);
        $numFields = $this->results->numFields();
        $fields = $dbi->getFieldsMeta($this->results);

// sColWidth = starting col width (an average size width)
        $availableWidth = $this->w - $this->lMargin - $this->rMargin;
        $sColWidth = $availableWidth / $numFields;
        $totalTitleWidth = 0;

// loop through results header and set initial
        // col widths/ titles/ alignment
        // if a col title is less than the starting col width,
        // reduce that column size
        $colFits = [];
        $titleWidth = [];
        for ($i = 0; $i < $numFields; $i++) {
            $colAs = $fields[$i]->name;
            $db = $this->currentDb;
            $table = $this->currentTable;
            if (! empty($this->aliases[$db]['tables'][$table]['columns'][$colAs])) {
                $colAs = $this->aliases[$db]['tables'][$table]['columns'][$colAs];
            }

$stringWidth = $this->GetStringWidth($colAs);
            $stringWidth += 6;
            // save the real title's width
            $titleWidth[$i] = $stringWidth;
            $totalTitleWidth += $stringWidth;

// set any column titles less than the start width to
            // the column title width
            if ($stringWidth < $sColWidth) {
                $colFits[$i] = $stringWidth;
            }

$this->colTitles[$i] = $colAs;
            $this->displayColumn[$i] = true;

$this->colAlign[$i] = 'L';

if ($fields[$i]->isType(FieldMetadata::TYPE_INT)) {
                $this->colAlign[$i] = 'R';
            }

if (! $fields[$i]->isType(FieldMetadata::TYPE_BLOB)) {
                continue;
            }

/**
             * @todo do not deactivate completely the display
             * but show the field's name and [BLOB]
             */
            if ($fields[$i]->isBinary()) {
                $this->displayColumn[$i] = false;
                unset($this->colTitles[$i]);
            }

$this->colAlign[$i] = 'L';
        }

// title width verification
        if ($totalTitleWidth > $availableWidth) {
            $adjustingMode = true;
        } else {
            $adjustingMode = false;
            // we have enough space for all the titles at their
            // original width so use the true title's width
            foreach ($titleWidth as $key => $val) {
                $colFits[$key] = $val;
            }
        }

// loop through the data; any column whose contents
        // is greater than the column size is resized
        /** @todo force here a LIMIT to avoid reading all rows */
        while ($row = $this->results->fetchRow()) {
            foreach ($colFits as $key => $val) {
                $stringWidth = $this->GetStringWidth($row[$key] ?? 'NULL');
                $stringWidth += 6;
                if ($adjustingMode && $stringWidth > $sColWidth) {
                    // any column whose data's width is bigger than
                    // the start width is now discarded
                    unset($colFits[$key]);
                } elseif ($stringWidth > $val && $stringWidth < $sColWidth * 3) {
                    // if data's width is bigger than the current column width,
                    // enlarge the column (but avoid enlarging it if the
                    // data's width is very big)
                    $colFits[$key] = $stringWidth;
                }
            }
        }

$totAlreadyFitted = 0;
        foreach ($colFits as $key => $val) {
            // set fitted columns to smallest size
            $this->tablewidths[$key] = $val;
            // to work out how much (if any) space has been freed up
            $totAlreadyFitted += $val;
        }

if ($adjustingMode) {
            $surplus = (count($colFits) * $sColWidth) - $totAlreadyFitted;
            $surplusToAdd = $surplus / ($numFields - count($colFits));
        } else {
            $surplusToAdd = 0;
        }

for ($i = 0; $i < $numFields; $i++) {
            if (! array_key_exists($i, $colFits)) {
                $this->tablewidths[$i] = $sColWidth + $surplusToAdd;
            }

if ($this->displayColumn[$i] != false) {
                continue;
            }

$this->tablewidths[$i] = 0;
        }

ksort($this->tablewidths);

// Pass 2

$this->results = $dbi->query($query, ConnectionType::User, DatabaseInterface::QUERY_UNBUFFERED);
        $this->setY($this->tMargin);
        $this->AddPage();
        $this->setFont(PdfLib::PMA_PDF_FONT, '', 9);
        // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
        $this->morepagestable($this->FontSizePt);
    }

public function setTitleFontSize(int $titleFontSize): void
    {
        $this->titleFontSize = $titleFontSize;
    }

public function setTitleText(string $titleText): void
    {
        $this->titleText = $titleText;
    }

public function setCurrentDb(string|null $currentDb): void
    {
        $this->currentDb = $currentDb ?? '';
    }

public function setCurrentTable(string|null $currentTable): void
    {
        $this->currentTable = $currentTable ?? '';
    }

public function setDbAlias(string|null $dbAlias): void
    {
        $this->dbAlias = $dbAlias ?? '';
    }

public function setTableAlias(string|null $tableAlias): void
    {
        $this->tableAlias = $tableAlias ?? '';
    }

/** @param mixed[] $aliases */
    public function setAliases(array $aliases): void
    {
        $this->aliases = $aliases;
    }

public function setPurpose(string $purpose): void
    {
        $this->purpose = $purpose;
    }
}