<?php

/**

 * Blocks API: WP_Block class

 *

 * @package WordPress

 * @since 5.5.0

 */

/**

 * Class representing a parsed instance of a block.

 *

 * @since 5.5.0

 * @property array $attributes

 */

#[AllowDynamicProperties]

class WP_Block {

	/**

	 * Original parsed array representation of block.

	 *

	 * @since 5.5.0

	 * @var array

	 */

	public $parsed_block;

	/**

	 * Name of block.

	 *

	 * @example "core/paragraph"

	 *

	 * @since 5.5.0

	 * @var string

	 */

	public $name;

	/**

	 * Block type associated with the instance.

	 *

	 * @since 5.5.0

	 * @var WP_Block_Type

	 */

	public $block_type;

	/**

	 * Block context values.

	 *

	 * @since 5.5.0

	 * @var array

	 */

	public $context = array();

	/**

	 * All available context of the current hierarchy.

	 *

	 * @since 5.5.0

	 * @var array

	 * @access protected

	 */

	/**

	 * Block type registry.

	 *

	 * @since 5.9.0

	 * @var WP_Block_Type_Registry

	 * @access protected

	 */

	protected $registry;

	/**

	 * List of inner blocks (of this same class)

	 *

	 * @since 5.5.0

	 * @var WP_Block_List

	 */

	public $inner_blocks = array();

	/**

	 * Resultant HTML from inside block comment delimiters after removing inner

	 * blocks.

	 *

	 * @example "...Just <!-- wp:test /--> testing..." -> "Just testing..."

	 *

	 * @since 5.5.0

	 * @var string

	 */

	public $inner_html = '';

	/**

	 * List of string fragments and null markers where inner blocks were found

	 *

	 * @example array(

	 *   'inner_html'    => 'BeforeInnerAfter',

	 *   'inner_blocks'  => array( block, block ),

	 *   'inner_content' => array( 'Before', null, 'Inner', null, 'After' ),

	 * )

	 *

	 * @since 5.5.0

	 * @var array

	 */

	public $inner_content = array();

	/**

	 * Constructor.

	 *

	 * Populates object properties from the provided block instance argument.

	 *

	 * The given array of context values will not necessarily be available on

	 * the instance itself, but is treated as the full set of values provided by

	 * the block's ancestry. This is assigned to the private `available_context`

	 * property. Only values which are configured to consumed by the block via

	 * its registered type will be assigned to the block's `context` property.

	 *

	 * @since 5.5.0

	 *

	 * @param array                  $block             {

	 *

	 *     @type string   $blockName    Name of block.

	 *     @type array    $attrs        Attributes from block comment delimiters.

	 *     @type array    $innerBlocks  List of inner blocks. An array of arrays that

	 *                                  have the same structure as this one.

	 *     @type string   $innerHTML    HTML from inside block comment delimiters.

	 *     @type array    $innerContent List of string fragments and null markers where inner blocks were found.

	 * }

	 * @param array                  $available_context Optional array of ancestry context values.

	 * @param WP_Block_Type_Registry $registry          Optional block type registry.

	 */

	public function __construct( $block, $available_context = array(), $registry = null ) {

		$this->parsed_block = $block;

		$this->name         = $block['blockName'];

		if ( is_null( $registry ) ) {

			$registry = WP_Block_Type_Registry::get_instance();

		}

		$this->registry = $registry;

		$this->block_type = $registry->get_registered( $this->name );

		$this->available_context = $available_context;

		if ( ! empty( $this->block_type->uses_context ) ) {

			foreach ( $this->block_type->uses_context as $context_name ) {

				if ( array_key_exists( $context_name, $this->available_context ) ) {

					$this->context[ $context_name ] = $this->available_context[ $context_name ];

				}

			}

		}

			$child_context = $this->available_context;

			if ( ! empty( $this->block_type->provides_context ) ) {

				foreach ( $this->block_type->provides_context as $context_name => $attribute_name ) {

					if ( array_key_exists( $attribute_name, $this->attributes ) ) {

						$child_context[ $context_name ] = $this->attributes[ $attribute_name ];

					}

				}

			}

		}

		}

		}

	}

	/**

	 * Returns a value from an inaccessible property.

	 *

	 * This is used to lazily initialize the `attributes` property of a block,

	 * such that it is only prepared with default attributes at the time that

	 * the property is accessed. For all other inaccessible properties, a `null`

	 * value is returned.

	 *

	 * @since 5.5.0

	 *

	 * @param string $name Property name.

	 * @return array|null Prepared attributes, or null.

	 */

	public function __get( $name ) {

		if ( 'attributes' === $name ) {

			$this->attributes = isset( $this->parsed_block['attrs'] ) ?

				$this->parsed_block['attrs'] :

				array();

			if ( ! is_null( $this->block_type ) ) {

				$this->attributes = $this->block_type->prepare_attributes_for_render( $this->attributes );

			}

			return $this->attributes;

		}

		return null;

	}

	/**

	 * Processes the block bindings and updates the block attributes with the values from the sources.

	 *

	 * A block might contain bindings in its attributes. Bindings are mappings

	 * between an attribute of the block and a source. A "source" is a function

	 * registered with `register_block_bindings_source()` that defines how to

	 * retrieve a value from outside the block, e.g. from post meta.

	 *

	 * This function will process those bindings and update the block's attributes

	 * with the values coming from the bindings.

	 *

	 * ### Example

	 *

	 * The "bindings" property for an Image block might look like this:

	 *

	 * ```json

	 * {

	 *   "metadata": {

	 *     "bindings": {

	 *       "title": {

	 *         "source": "core/post-meta",

	 *         "args": { "key": "text_custom_field" }

	 *       },

	 *       "url": {

	 *         "source": "core/post-meta",

	 *         "args": { "key": "url_custom_field" }

	 *       }

	 *     }

	 *   }

	 * }

	 * ```

	 *

	 * The above example will replace the `title` and `url` attributes of the Image

	 * block with the values of the `text_custom_field` and `url_custom_field` post meta.

	 *

	 * @since 6.5.0

	 * @since 6.6.0 Handle the `__default` attribute for pattern overrides.

	 *

	 * @return array The computed block attributes for the provided block bindings.

	 */

	private function process_block_bindings() {

		$parsed_block               = $this->parsed_block;

		$computed_attributes        = array();

		$supported_block_attributes = array(

			'core/paragraph' => array( 'content' ),

			'core/heading'   => array( 'content' ),

			'core/image'     => array( 'id', 'url', 'title', 'alt' ),

			'core/button'    => array( 'url', 'text', 'linkTarget', 'rel' ),

		);

		// If the block doesn't have the bindings property, isn't one of the supported

		// block types, or the bindings property is not an array, return the block content.

		if (

			! isset( $supported_block_attributes[ $this->name ] ) ||

			empty( $parsed_block['attrs']['metadata']['bindings'] ) ||

			! is_array( $parsed_block['attrs']['metadata']['bindings'] )

		) {

			return $computed_attributes;

		}

		$bindings = $parsed_block['attrs']['metadata']['bindings'];

		/*

		 * If the default binding is set for pattern overrides, replace it

		 * with a pattern override binding for all supported attributes.

		 */

		if (

			isset( $bindings['__default']['source'] ) &&

			'core/pattern-overrides' === $bindings['__default']['source']

		) {

			$updated_bindings = array();

			/*

			 * Build a binding array of all supported attributes.

			 * Note that this also omits the `__default` attribute from the

			 * resulting array.

			 */

			foreach ( $supported_block_attributes[ $parsed_block['blockName'] ] as $attribute_name ) {

				// Retain any non-pattern override bindings that might be present.

				$updated_bindings[ $attribute_name ] = isset( $bindings[ $attribute_name ] )

					? $bindings[ $attribute_name ]

					: array( 'source' => 'core/pattern-overrides' );

			}

			$bindings = $updated_bindings;

		}

		foreach ( $bindings as $attribute_name => $block_binding ) {

			// If the attribute is not in the supported list, process next attribute.

			if ( ! in_array( $attribute_name, $supported_block_attributes[ $this->name ], true ) ) {

				continue;

			}

			// If no source is provided, or that source is not registered, process next attribute.

			if ( ! isset( $block_binding['source'] ) || ! is_string( $block_binding['source'] ) ) {

				continue;

			}

			$block_binding_source = get_block_bindings_source( $block_binding['source'] );

			if ( null === $block_binding_source ) {

				continue;

			}

			$source_args  = ! empty( $block_binding['args'] ) && is_array( $block_binding['args'] ) ? $block_binding['args'] : array();

			$source_value = $block_binding_source->get_value( $source_args, $this, $attribute_name );

			// If the value is not null, process the HTML based on the block and the attribute.

			if ( ! is_null( $source_value ) ) {

				$computed_attributes[ $attribute_name ] = $source_value;

			}

		}

		return $computed_attributes;

	}

	/**

	 * Depending on the block attribute name, replace its value in the HTML based on the value provided.

	 *

	 * @since 6.5.0

	 *

	 * @param string $block_content  Block content.

	 * @param string $attribute_name The attribute name to replace.

	 * @param mixed  $source_value   The value used to replace in the HTML.

	 * @return string The modified block content.

	 */

	private function replace_html( string $block_content, string $attribute_name, $source_value ) {

		$block_type = $this->block_type;

		if ( ! isset( $block_type->attributes[ $attribute_name ]['source'] ) ) {

			return $block_content;

		}

		// Depending on the attribute source, the processing will be different.

		switch ( $block_type->attributes[ $attribute_name ]['source'] ) {

			case 'html':

			case 'rich-text':

				$block_reader = new WP_HTML_Tag_Processor( $block_content );

				// TODO: Support for CSS selectors whenever they are ready in the HTML API.

				// In the meantime, support comma-separated selectors by exploding them into an array.

				$selectors = explode( ',', $block_type->attributes[ $attribute_name ]['selector'] );

				// Add a bookmark to the first tag to be able to iterate over the selectors.

				$block_reader->next_tag();

				$block_reader->set_bookmark( 'iterate-selectors' );

				// TODO: This shouldn't be needed when the `set_inner_html` function is ready.

				// Store the parent tag and its attributes to be able to restore them later in the button.

				// The button block has a wrapper while the paragraph and heading blocks don't.

				if ( 'core/button' === $this->name ) {

					$button_wrapper                 = $block_reader->get_tag();

					$button_wrapper_attribute_names = $block_reader->get_attribute_names_with_prefix( '' );

					$button_wrapper_attrs           = array();

					foreach ( $button_wrapper_attribute_names as $name ) {

						$button_wrapper_attrs[ $name ] = $block_reader->get_attribute( $name );

					}

				}

				foreach ( $selectors as $selector ) {

					// If the parent tag, or any of its children, matches the selector, replace the HTML.

						array(

							'tag_name' => $selector,

						)

					) ) {

						$block_reader->release_bookmark( 'iterate-selectors' );

						// TODO: Use `set_inner_html` method whenever it's ready in the HTML API.

						// Until then, it is hardcoded for the paragraph, heading, and button blocks.

						// Store the tag and its attributes to be able to restore them later.

						$selector_attribute_names = $block_reader->get_attribute_names_with_prefix( '' );

						$selector_attrs           = array();

						foreach ( $selector_attribute_names as $name ) {

							$selector_attrs[ $name ] = $block_reader->get_attribute( $name );