update_post_meta($post->ID, '_blz_affiliation_formats_signature' . $suffix, $signature);
    }

    /**
     * Delete the formats from the post meta
     * @param \WP_Post $post
     */
    protected function deleteMetaRenderResponse(\WP_Post $post): void
    {
        delete_post_meta($post->ID, '_blz_affiliation_formats');
        delete_post_meta($post->ID, '_blz_affiliation_formats_signature');
        delete_post_meta($post->ID, '_blz_affiliation_formats_hook');
        delete_post_meta($post->ID, '_blz_affiliation_formats_signature_hook');
    }

    protected function getMetaRenderResponse(\WP_Post $post, bool $isChild = false): RenderResponse
    {
        $suffix = $isChild ? '_hook' : '';
        $renderResponseBody = unserialize(get_post_meta($post->ID, '_blz_affiliation_formats' . $suffix, true));

        if (empty($renderResponseBody)) return new RenderResponse();

        return new RenderResponse(json_encode($renderResponseBody));
    }

    protected function getMetaSignature(\WP_Post $post, bool $isChild = false): string
    {
        $suffix = $isChild ? '_hook' : '';
        return get_post_meta($post->ID, '_blz_affiliation_formats_signature' . $suffix, true) ?? '';
    }
}
 

 
    public function injectAffiliationStyles(): void
    {
        $this->injectStyles( $this->renderResponse );
    }
 
 
    protected function getRenderResponse(): RenderResponse 
    {
        $post = $this->handleZoneRendering($this->post);
        $post = $this->handleOldShortcode($post);
 
        // Compute current signature and compare with stored to decide cache usage
        $currentSignature = (new Parameters($post))->getSignature();
        $storedSignature  = $this->getMetaSignature($post);
 
        $this->getApiCallForDebug($post, $currentSignature);
 
        if ($currentSignature === $storedSignature) {
            $renderResponse = $this->getMetaRenderResponse($post);
            if (!$renderResponse->isEmpty()) {
                return $renderResponse;
            }
        } else {
            $this->deleteMetaRenderResponse($post);
        }
 
        $renderResponse = $this->getRemoteRenderResponse($post);
 
        if ($renderResponse->isEmpty()) {
            Logger::write('FrontendServiceProvider: Remote render response is empty, returning original content', 'ERROR');                                
        }
        
        return $renderResponse;
    }
 
 
    protected function getRemoteRenderResponse($post): RenderResponse
    {
 

    {
        $this->disclaimer = Disclaimer::getInstance();
        add_action('wp', [$this, 'register']);
    }
 
 
    public function register(): void
    {
        /// verifica se siamo nel fronted di una single post di uno dei post types configurati
        if (!is_singular( Environment::get('BLAZE_AFFILIATION_POST_TYPES') )) return;
 
        $post = get_post();
 
        if (!$post) return;
 
        $this->post = $post;
 
        // if( !$this->hasFormats( $this->post ) ) return;
 
        $this->renderResponse = $this->getRenderResponse();
 
        add_filter( 'the_content', [ $this, 'injectAffiliationInContent' ], 4, 1 );                
        add_action( 'wp_head',     [ $this, 'injectAffiliationStyles'    ], 20 );
        // Enqueue debug inspector for techteam only
        $this->enqueueDebugInspector($this->renderResponse);
    }
 
    public function injectAffiliationInContent( string $content ): string
    {
        $content = $this->inject($content, $this->renderResponse);
 
        if ($this->disclaimer->getStatus()) {
            $content = $this->disclaimer->printDisclaimer($content);
        }
 
        return $content;
    }
 
 
    public function injectAffiliationStyles(): void

 
        $this->iterations[ $nesting_level ] = $this->priorities;
 
        $num_args = count( $args );
 
        do {
            $this->current_priority[ $nesting_level ] = current( $this->iterations[ $nesting_level ] );
 
            $priority = $this->current_priority[ $nesting_level ];
 
            foreach ( $this->callbacks[ $priority ] as $the_ ) {
                if ( ! $this->doing_action ) {
                    $args[0] = $value;
                }
 
                // Avoid the array_slice() if possible.
                if ( 0 === $the_['accepted_args'] ) {
                    $value = call_user_func( $the_['function'] );
                } elseif ( $the_['accepted_args'] >= $num_args ) {
                    $value = call_user_func_array( $the_['function'], $args );
                } else {
                    $value = call_user_func_array( $the_['function'], array_slice( $args, 0, $the_['accepted_args'] ) );
                }
            }
        } while ( false !== next( $this->iterations[ $nesting_level ] ) );
 
        unset( $this->iterations[ $nesting_level ] );
        unset( $this->current_priority[ $nesting_level ] );
 
        --$this->nesting_level;
 
        return $value;
    }
 
    /**
     * Calls the callback functions that have been added to an action hook.
     *
     * @since 4.7.0
     *
     * @param array $args Parameters to pass to the callback functions.

        } while ( false !== next( $this->iterations[ $nesting_level ] ) );
 
        unset( $this->iterations[ $nesting_level ] );
        unset( $this->current_priority[ $nesting_level ] );
 
        --$this->nesting_level;
 
        return $value;
    }
 
    /**
     * Calls the callback functions that have been added to an action hook.
     *
     * @since 4.7.0
     *
     * @param array $args Parameters to pass to the callback functions.
     */
    public function do_action( $args ) {
        $this->doing_action = true;
        $this->apply_filters( '', $args );
 
        // If there are recursive calls to the current action, we haven't finished it until we get to the last one.
        if ( ! $this->nesting_level ) {
            $this->doing_action = false;
        }
    }
 
    /**
     * Processes the functions hooked into the 'all' hook.
     *
     * @since 4.7.0
     *
     * @param array $args Arguments to pass to the hook callbacks. Passed by reference.
     */
    public function do_all_hook( &$args ) {
        $nesting_level                      = $this->nesting_level++;
        $this->iterations[ $nesting_level ] = $this->priorities;
 
        do {
            $priority = current( $this->iterations[ $nesting_level ] );

    // Do 'all' actions first.
    if ( isset( $wp_filter['all'] ) ) {
        $wp_current_filter[] = $hook_name;
        $all_args            = func_get_args(); // phpcs:ignore PHPCompatibility.FunctionUse.ArgumentFunctionsReportCurrentValue.NeedsInspection
        _wp_call_all_hook( $all_args );
    }
 
    if ( ! isset( $wp_filter[ $hook_name ] ) ) {
        if ( isset( $wp_filter['all'] ) ) {
            array_pop( $wp_current_filter );
        }
 
        return;
    }
 
    if ( ! isset( $wp_filter['all'] ) ) {
        $wp_current_filter[] = $hook_name;
    }
 
    $wp_filter[ $hook_name ]->do_action( $args );
 
    array_pop( $wp_current_filter );
}
 
/**
 * Checks if any action has been registered for a hook.
 *
 * When using the `$callback` argument, this function may return a non-boolean value
 * that evaluates to false (e.g. 0), so use the `===` operator for testing the return value.
 *
 * @since 2.5.0
 *
 * @see has_filter() This function is an alias of has_filter().
 *
 * @param string                      $hook_name The name of the action hook.
 * @param callable|string|array|false $callback  Optional. The callback to check for.
 *                                               This function can be called unconditionally to speculatively check
 *                                               a callback that may or may not exist. Default false.
 * @return bool|int If `$callback` is omitted, returns boolean for whether the hook has
 *                  anything registered. When checking a specific function, the priority

        $this->init();
 
        $parsed = $this->parse_request( $query_args );
 
        if ( $parsed ) {
            $this->query_posts();
            $this->handle_404();
            $this->register_globals();
        }
 
        $this->send_headers();
 
        /**
         * Fires once the WordPress environment has been set up.
         *
         * @since 2.1.0
         *
         * @param WP $wp Current WordPress environment instance (passed by reference).
         */
        do_action_ref_array( 'wp', array( &$this ) );
    }
}
 

    }
 
    return wp_remote_retrieve_body( $response );
}
 
/**
 * Sets up the WordPress query.
 *
 * @since 2.0.0
 *
 * @global WP       $wp           Current WordPress environment instance.
 * @global WP_Query $wp_query     WordPress Query object.
 * @global WP_Query $wp_the_query Copy of the WordPress Query object.
 *
 * @param string|array $query_vars Default WP_Query arguments.
 */
function wp( $query_vars = '' ) {
    global $wp, $wp_query, $wp_the_query;
 
    $wp->main( $query_vars );
 
    if ( ! isset( $wp_the_query ) ) {
        $wp_the_query = $wp_query;
    }
}
 
/**
 * Retrieves the description for the HTTP status.
 *
 * @since 2.3.0
 * @since 3.9.0 Added status codes 418, 428, 429, 431, and 511.
 * @since 4.5.0 Added status codes 308, 421, and 451.
 * @since 5.1.0 Added status code 103.
 * @since 6.6.0 Added status code 425.
 *
 * @global array $wp_header_to_desc
 *
 * @param int $code HTTP status code.
 * @return string Status description if found, an empty string otherwise.
 */

<?php
/**
 * Loads the WordPress environment and template.
 *
 * @package WordPress
 */
 
if ( ! isset( $wp_did_header ) ) {
 
    $wp_did_header = true;
 
    // Load the WordPress library.
    require_once __DIR__ . '/wp-load.php';
 
    // Set up the WordPress query.
    wp();
 
    // Load the theme template.
    require_once ABSPATH . WPINC . '/template-loader.php';
 
}
 

<?php
/**
 * WordPress View Bootstrapper
 */
define('WP_USE_THEMES', true);
require __DIR__ . '/wp/wp-blog-header.php';