class RulesDebugLog

class RulesDebugLog implements LoggerInterface {
    use LoggerTrait;
    use StringTranslationTrait;
    
    /**
     * Local storage of log entries.
     *
     * @var array
     */
    protected $logs = [];
    
    /**
     * The session service.
     *
     * @var \Symfony\Component\HttpFoundation\Session\SessionInterface
     */
    protected $session;
    
    /**
     * Constructs a RulesDebugLog object.
     *
     * @param \Symfony\Component\HttpFoundation\Session\SessionInterface $session
     *   The session service.
     */
    public function __construct(SessionInterface $session) {
        $this->session = $session;
    }
    
    /**
     * {@inheritdoc}
     */
    public function log($level, $message, array $context = []) : void {
        // Remove any backtraces since they may contain an unserializable variable.
        unset($context['backtrace']);
        $localCopy = $this->session
            ->get('rules_debug_log', []);
        // Append the new log to the $localCopy array.
        // In D7:
        // @code
        //   logs[] = [$msg, $args, $priority, microtime(TRUE), $scope, $path];
        // @endcode
        $localCopy[] = [
            'message' => $message,
            'context' => $context,
            
            /** @var \Psr\Log\LogLevel $level */
'level' => $level,
            'timestamp' => $context['timestamp'],
            'scope' => $context['scope'],
            'path' => $context['path'],
        ];
        // Write the $localCopy array back into the session;
        // it now includes the new log.
        $this->session
            ->set('rules_debug_log', $localCopy);
    }
    
    /**
     * Returns a structured array of log entries.
     *
     * @return array
     *   Array of stored log entries, keyed by an integer log line number. Each
     *   element of the array contains the following keys:
     *   - message: The log message, optionally with FormattedMarkup placeholders.
     *   - context: An array of message placeholder replacements.
     *   - level: \Psr\Log\LogLevel level.
     *   - timestamp: Microtime timestamp in float format.
     *   - scope: TRUE if there are nested logs for this entry, FALSE if this is
     *     the last of the nested entries.
     *   - path: Path to edit this component.
     */
    public function getLogs() : array {
        return (array) $this->session
            ->get('rules_debug_log');
    }
    
    /**
     * Clears the logs entries from the storage.
     */
    public function clearLogs() : void {
        $this->session
            ->remove('rules_debug_log');
    }
    
    /**
     * Renders the whole log.
     *
     * @return \Drupal\Component\Render\MarkupInterface
     *   An string already rendered to HTML.
     */
    public function render() {
        $build = $this->build();
        return \Drupal::service('renderer')->renderPlain($build);
    }
    
    /**
     * Assembles the entire log into a render array.
     *
     * @return array
     *   A Drupal render array.
     */
    public function build() : array {
        $this->logs = $this->getLogs();
        if (count($this->logs) == 0) {
            // Nothing to render.
            return [];
        }
        // Container for all log entries.
        $build = [
            '#type' => 'details',
            // @codingStandardsIgnoreStart
'#title' => $this->t('Rules evaluation log') . '<span class="rules-debug-open-all">-Open all-</span>',
            // @codingStandardsIgnoreEnd
'#attributes' => [
                'class' => [
                    'rules-debug-log',
                ],
            ],
        ];
        $line = 0;
        while (isset($this->logs[$line])) {
            // Each event is in its own 'details' wrapper so the details of
            // evaluation may be opened or closed.
            $build[$line] = [
                '#type' => 'details',
                // @codingStandardsIgnoreStart
                // Need to filter out context keys that aren't recognized as
                // placeholders for t(), because Drupal core no longer supports these.
'#title' => $this->t($this->logs[$line]['message'], $this->filterContext($this->logs[$line]['context'])),
            ];
            // $line is modified inside renderHelper().
            $thisline = $line;
            $build[$thisline][] = $this->renderHelper($line);
            $line++;
        }
        return $build;
    }
    
    /**
     * Renders the log of one event invocation.
     *
     * Called recursively, consuming all the log lines for this event.
     *
     * @param int $line
     *   The line number of the log, starting at 0.
     *
     * @return array
     *   A render array.
     */
    protected function renderHelper(int &$line = 0) : array {
        $build = [];
        $startTime = $this->logs[$line]['timestamp'];
        while ($line < count($this->logs)) {
            if ($build && !empty($this->logs[$line]['scope'])) {
                // This next entry stems from another evaluated set so we create a
                // new container for its log messages then fill that container with
                // a recursive call to renderHelper().
                $link = NULL;
                if (isset($this->logs[$line]['path'])) {
                    $link = Link::fromTextAndUrl($this->t('edit'), Url::fromUserInput('/' . $this->logs[$line]['path']))
                        ->toString();
                }
                $build[$line] = [
                    '#type' => 'details',
                    // @codingStandardsIgnoreStart
                    // Need to filter out context keys that aren't recognized as
                    // placeholders for t(), because Drupal core no longer supports these.
'#title' => $this->t($this->logs[$line]['message'], $this->filterContext($this->logs[$line]['context'])) . ' [' . $link . ']',
                ];
                $thisline = $line;
                $build[$thisline][] = $this->renderHelper($line);
            }
            else {
                // This next entry is a leaf of the evaluated set so we just have to
                // add the details of the log entry.
                $link = NULL;
                if (isset($this->logs[$line]['path']) && !isset($this->logs[$line]['scope'])) {
                    $link = [
                        'title' => $this->t('edit'),
                        'url' => Url::fromUserInput('/' . $this->logs[$line]['path']),
                    ];
                }
                $build[$line] = [
                    '#theme' => 'rules_debug_log_element',
                    '#starttime' => $startTime,
                    '#timestamp' => $this->logs[$line]['timestamp'],
                    '#level' => $this->logs[$line]['level'],
                    // @codingStandardsIgnoreStart
                    // Need to filter out context keys that aren't recognized as
                    // placeholders for t(), because Drupal core no longer supports these.
'#text' => $this->t($this->logs[$line]['message'], $this->filterContext($this->logs[$line]['context'])),
                    // @codingStandardsIgnoreEnd
'#link' => $link,
                ];
                if (isset($this->logs[$line]['scope']) && !$this->logs[$line]['scope']) {
                    // This was the last log entry of this set.
                    return [
                        '#theme' => 'item_list',
                        '#items' => $build,
                    ];
                }
            }
            $line++;
        }
        return [
            '#theme' => 'item_list',
            '#items' => $build,
        ];
    }
    
    /**
     * Removes invalid placeholders from the given array.
     *
     * As of Drupal 10, arrays that contain placeholder replacement strings for
     * use by the core Drupal t() function may not contain any keys that aren't
     * valid placeholders for the string being translated. That means we have to
     * remove keys from these arrays before passing them to the t() function.
     *
     * @param array $context
     *   An array containing placeholder replacements for use by t(), keyed by
     *   the placeholder.
     *
     * @return array
     *   The context array, with invalid placeholders removed.
     *
     * @see \Drupal\Component\Render\FormattableMarkup::placeholderFormat()
     */
    protected function filterContext(array $context = []) : array {
        // This implementation assumes that all valid placeholders start with a
        // punctuation character. In reality Drupal currently supports only '@',
        // '%', and ':', but testing for just those three is considerably slower
        // than using the built-in PHP ctype_punct() function. This will work to
        // remove all invalid placeholders added by the Rules module, but another
        // invalid placeholder added by a user might fall through and still cause
        // an error (as it should, to indicate the user has made an error).
        return array_filter($context, function ($key) {
            return ctype_punct($key[0]);
        }, ARRAY_FILTER_USE_KEY);
    }

}