<?php
/**
 * @package dompdf
 * @link    https://github.com/dompdf/dompdf
 * @license http://www.gnu.org/copyleft/lesser.html GNU Lesser General Public License
 *
 * Modified by wpovernight on 18-October-2024 using {@see https://github.com/BrianHenryIE/strauss}.
 */
namespace WPO\IPS\Vendor\Dompdf;

use WPO\IPS\Vendor\Dompdf\Renderer\AbstractRenderer;
use WPO\IPS\Vendor\Dompdf\Renderer\Block;
use WPO\IPS\Vendor\Dompdf\Renderer\Image;
use WPO\IPS\Vendor\Dompdf\Renderer\Inline;
use WPO\IPS\Vendor\Dompdf\Renderer\ListBullet;
use WPO\IPS\Vendor\Dompdf\Renderer\TableCell;
use WPO\IPS\Vendor\Dompdf\Renderer\TableRow;
use WPO\IPS\Vendor\Dompdf\Renderer\TableRowGroup;
use WPO\IPS\Vendor\Dompdf\Renderer\Text;

/**
 * Concrete renderer
 *
 * Instantiates several specific renderers in order to render any given frame.
 *
 * @package dompdf
 */
class Renderer extends AbstractRenderer
{

    /**
     * Array of renderers for specific frame types
     *
     * @var AbstractRenderer[]
     */
    protected $_renderers;

    /**
     * Cache of the callbacks array
     *
     * @var array
     */
    private $_callbacks;

    /**
     * Advance the canvas to the next page
     */
    function new_page()
    {
        $this->_canvas->new_page();
    }

    /**
     * Render frames recursively
     *
     * @param Frame $frame the frame to render
     */
    public function render(Frame $frame)
    {
        global $_dompdf_debug;

        $this->_check_callbacks("begin_frame", $frame);

        if ($_dompdf_debug) {
            echo $frame;
            flush();
        }

        $style = $frame->get_style();

        if (in_array($style->visibility, ["hidden", "collapse"], true)) {
            return;
        }

        $display = $style->display;
        $transformList = $style->transform;
        $hasTransform = $transformList !== [];

        // Starts the CSS transformation
        if ($hasTransform) {
            $this->_canvas->save();

            [$x, $y] = $frame->get_padding_box();
            [$originX, $originY] = $style->transform_origin;
            $w = (float) $style->length_in_pt($style->width);
            $h = (float) $style->length_in_pt($style->height);

            foreach ($transformList as $transform) {
                [$function, $values] = $transform;

                if ($function === "matrix") {
                    $function = "transform";
                } elseif ($function === "translate") {
                    $values[0] = $style->length_in_pt($values[0], $w);
                    $values[1] = $style->length_in_pt($values[1], $h);
                }

                $values[] = $x + $style->length_in_pt($originX, $w);
                $values[] = $y + $style->length_in_pt($originY, $h);

                call_user_func_array([$this->_canvas, $function], $values);
            }
        }

        switch ($display) {

            case "block":
            case "list-item":
            case "inline-block":
            case "table":
            case "inline-table":
                $this->_render_frame("block", $frame);
                break;

            case "inline":
                if ($frame->is_text_node()) {
                    $this->_render_frame("text", $frame);
                } else {
                    $this->_render_frame("inline", $frame);
                }
                break;

            case "table-cell":
                $this->_render_frame("table-cell", $frame);
                break;

            case "table-row":
                $this->_render_frame("table-row", $frame);
                break;

            case "table-row-group":
            case "table-header-group":
            case "table-footer-group":
                $this->_render_frame("table-row-group", $frame);
                break;

            case "-dompdf-list-bullet":
                $this->_render_frame("list-bullet", $frame);
                break;

            case "-dompdf-image":
                $this->_render_frame("image", $frame);
                break;

            case "none":
                $node = $frame->get_node();

                if ($node->nodeName === "script") {
                    if ($node->getAttribute("type") === "text/php" ||
                        $node->getAttribute("language") === "php"
                    ) {
                        // Evaluate embedded php scripts
                        $this->_render_frame("php", $frame);
                    } elseif ($node->getAttribute("type") === "text/javascript" ||
                        $node->getAttribute("language") === "javascript"
                    ) {
                        // Insert JavaScript
                        $this->_render_frame("javascript", $frame);
                    }
                }

                // Don't render children, so skip to next iter
                return;

            default:
                break;

        }

        // Starts the overflow: hidden box
        if ($style->overflow === "hidden") {
            $padding_box = $frame->get_padding_box();
            [$x, $y, $w, $h] = $padding_box;
            $style = $frame->get_style();

            if ($style->has_border_radius()) {
                $border_box = $frame->get_border_box();
                [$tl, $tr, $br, $bl] = $style->resolve_border_radius($border_box, $padding_box);
                $this->_canvas->clipping_roundrectangle($x, $y, $w, $h, $tl, $tr, $br, $bl);
            } else {
                $this->_canvas->clipping_rectangle($x, $y, $w, $h);
            }
        }

        $stack = [];

        foreach ($frame->get_children() as $child) {
            // < 0 : negative z-index
            // = 0 : no z-index, no stacking context
            // = 1 : stacking context without z-index
            // > 1 : z-index
            $child_style = $child->get_style();
            $child_z_index = $child_style->z_index;
            $z_index = 0;

            if ($child_z_index !== "auto") {
                $z_index = $child_z_index + 1;
            } elseif ($child_style->float !== "none" || $child->is_positioned()) {
                $z_index = 1;
            }

            $stack[$z_index][] = $child;
        }

        ksort($stack);

        foreach ($stack as $by_index) {
            foreach ($by_index as $child) {
                $this->render($child);
            }
        }

        // Ends the overflow: hidden box
        if ($style->overflow === "hidden") {
            $this->_canvas->clipping_end();
        }

        if ($hasTransform) {
            $this->_canvas->restore();
        }

        // Check for end frame callback
        $this->_check_callbacks("end_frame", $frame);
    }

    /**
     * Check for callbacks that need to be performed when a given event
     * gets triggered on a frame
     *
     * @param string $event The type of event
     * @param Frame  $frame The frame that event is triggered on
     */
    protected function _check_callbacks(string $event, Frame $frame): void
    {
        if (!isset($this->_callbacks)) {
            $this->_callbacks = $this->_dompdf->getCallbacks();
        }

        if (isset($this->_callbacks[$event])) {
            $fs = $this->_callbacks[$event];
            $canvas = $this->_canvas;
            $fontMetrics = $this->_dompdf->getFontMetrics();

            foreach ($fs as $f) {
                $f($frame, $canvas, $fontMetrics);
            }
        }
    }

    /**
     * Render a single frame
     *
     * Creates Renderer objects on demand
     *
     * @param string $type type of renderer to use
     * @param Frame $frame the frame to render
     */
    protected function _render_frame($type, $frame)
    {

        if (!isset($this->_renderers[$type])) {

            switch ($type) {
                case "block":
                    $this->_renderers[$type] = new Block($this->_dompdf);
                    break;

                case "inline":
                    $this->_renderers[$type] = new Inline($this->_dompdf);
                    break;

                case "text":
                    $this->_renderers[$type] = new Text($this->_dompdf);
                    break;

                case "image":
                    $this->_renderers[$type] = new Image($this->_dompdf);
                    break;

                case "table-cell":
                    $this->_renderers[$type] = new TableCell($this->_dompdf);
                    break;

                case "table-row":
                    $this->_renderers[$type] = new TableRow($this->_dompdf);
                    break;

                case "table-row-group":
                    $this->_renderers[$type] = new TableRowGroup($this->_dompdf);
                    break;

                case "list-bullet":
                    $this->_renderers[$type] = new ListBullet($this->_dompdf);
                    break;

                case "php":
                    $this->_renderers[$type] = new PhpEvaluator($this->_canvas);
                    break;

                case "javascript":
                    $this->_renderers[$type] = new JavascriptEmbedder($this->_dompdf);
                    break;

            }
        }

        $this->_renderers[$type]->render($frame);
    }
}
