<?php

/**

 * WP_Theme_JSON_Resolver class

 *

 * @package WordPress

 * @subpackage Theme

 * @since 5.8.0

 */

/**

 * Class that abstracts the processing of the different data sources

 * for site-level config and offers an API to work with them.

 *

 * @access private

 */

class WP_Theme_JSON_Resolver {

	/**

	 * Container for data coming from core.

	 *

	 * @since 5.8.0

	 * @var WP_Theme_JSON

	 */

	private static $core = null;

	/**

	 * Container for data coming from the theme.

	 *

	 * @since 5.8.0

	 * @var WP_Theme_JSON

	 */

	private static $theme = null;

	/**

	 * Whether or not the theme supports theme.json.

	 *

	 * @since 5.8.0

	 * @var bool

	 */

	private static $theme_has_support = null;

	/**

	 * Structure to hold i18n metadata.

	 *

	 * @since 5.8.0

	 * @var array

	 */

	private static $theme_json_i18n = null;

	/**

	 * Processes a file that adheres to the theme.json schema

	 * and returns an array with its contents, or a void array if none found.

	 *

	 * @since 5.8.0

	 *

	 * @param string $file_path Path to file. Empty if no file.

	 * @return array Contents that adhere to the theme.json schema.

	 */

	private static function read_json_file( $file_path ) {

		$config = array();

		if ( $file_path ) {

			$decoded_file = json_decode(

				file_get_contents( $file_path ),

				true

			);

			$json_decoding_error = json_last_error();

			if ( JSON_ERROR_NONE !== $json_decoding_error ) {

				trigger_error( "Error when decoding a theme.json schema at path $file_path " . json_last_error_msg() );

				return $config;

			}

			if ( is_array( $decoded_file ) ) {

				$config = $decoded_file;

			}

		}

		return $config;

	}

	/**

	 * Converts a tree as in i18n-theme.json into a linear array

	 * containing metadata to translate a theme.json file.

	 *

	 * For example, given this input:

	 *

	 *     {

	 *       "settings": {

	 *         "*": {

	 *           "typography": {

	 *             "fontSizes": [ { "name": "Font size name" } ],

	 *             "fontStyles": [ { "name": "Font size name" } ]

	 *           }

	 *         }

	 *       }

	 *     }

	 *

	 * will return this output:

	 *

	 *     [

	 *       0 => [

	 *         'path'    => [ 'settings', '*', 'typography', 'fontSizes' ],

	 *         'key'     => 'name',

	 *         'context' => 'Font size name'

	 *       ],

	 *       1 => [

	 *         'path'    => [ 'settings', '*', 'typography', 'fontStyles' ],

	 *         'key'     => 'name',

	 *         'context' => 'Font style name'

	 *       ]

	 *     ]

	 *

	 * @since 5.8.0

	 *

	 * @param array $i18n_partial A tree that follows the format of i18n-theme.json.

	 * @param array $current_path Optional. Keeps track of the path as we walk down the given tree.

	 *                            Default empty array.

	 * @return array A linear array containing the paths to translate.

	 */

	private static function extract_paths_to_translate( $i18n_partial, $current_path = array() ) {

		$result = array();

		foreach ( $i18n_partial as $property => $partial_child ) {

			if ( is_numeric( $property ) ) {

				foreach ( $partial_child as $key => $context ) {

					$result[] = array(

						'path'    => $current_path,

						'key'     => $key,

						'context' => $context,

					);

				}

				return $result;

			}

			$result = array_merge(

				$result,

				self::extract_paths_to_translate( $partial_child, array_merge( $current_path, array( $property ) ) )

			);

		}

		return $result;

	}

	/**

	 * Returns a data structure used in theme.json translation.

	 *

	 * @since 5.8.0

	 *

	 * @return array An array of theme.json fields that are translatable and the keys that are translatable.

	 */

	public static function get_fields_to_translate() {

		if ( null === self::$theme_json_i18n ) {

			$file_structure        = self::read_json_file( __DIR__ . '/theme-i18n.json' );

			self::$theme_json_i18n = self::extract_paths_to_translate( $file_structure );

		}

		return self::$theme_json_i18n;

	}

	/**

	 * Translates a chunk of the loaded theme.json structure.

	 *

	 * @since 5.8.0

	 *

	 * @param array  $array_to_translate The chunk of theme.json to translate.

	 * @param string $key                The key of the field that contains the string to translate.

	 * @param string $context            The context to apply in the translation call.

	 * @param string $domain             Text domain. Unique identifier for retrieving translated strings.

	 * @return array Returns the modified $theme_json chunk.

	 */

	private static function translate_theme_json_chunk( array $array_to_translate, $key, $context, $domain ) {

		foreach ( $array_to_translate as $item_key => $item_to_translate ) {

			if ( empty( $item_to_translate[ $key ] ) ) {

				continue;

			}

			// phpcs:ignore WordPress.WP.I18n.LowLevelTranslationFunction,WordPress.WP.I18n.NonSingularStringLiteralText,WordPress.WP.I18n.NonSingularStringLiteralContext,WordPress.WP.I18n.NonSingularStringLiteralDomain

			$array_to_translate[ $item_key ][ $key ] = translate_with_gettext_context( $array_to_translate[ $item_key ][ $key ], $context, $domain );

		}

		return $array_to_translate;

	}

	/**

	 * Given a theme.json structure modifies it in place to update certain values

	 * by its translated strings according to the language set by the user.

	 *

	 * @since 5.8.0

	 *

	 * @param array  $theme_json The theme.json to translate.

	 * @param string $domain     Optional. Text domain. Unique identifier for retrieving translated strings.

	 *                           Default 'default'.

	 * @return array Returns the modified $theme_json_structure.

	 */

	private static function translate( $theme_json, $domain = 'default' ) {

		$fields = self::get_fields_to_translate();

		foreach ( $fields as $field ) {

			$path    = $field['path'];

			$key     = $field['key'];

			$context = $field['context'];

			/*

			 * We need to process the paths that include '*' separately.

			 * One example of such a path would be:

			 * [ 'settings', 'blocks', '*', 'color', 'palette' ]

			 */

			$nodes_to_iterate = array_keys( $path, '*', true );

			if ( ! empty( $nodes_to_iterate ) ) {

				/*

				 * At the moment, we only need to support one '*' in the path, so take it directly.

				 * - base will be [ 'settings', 'blocks' ]

				 * - data will be [ 'color', 'palette' ]

				 */

				$base_path = array_slice( $path, 0, $nodes_to_iterate[0] );

				$data_path = array_slice( $path, $nodes_to_iterate[0] + 1 );

				$base_tree = _wp_array_get( $theme_json, $base_path, array() );

				foreach ( $base_tree as $node_name => $node_data ) {

					$array_to_translate = _wp_array_get( $node_data, $data_path, null );

					if ( is_null( $array_to_translate ) ) {

						continue;

					}

					// Whole path will be [ 'settings', 'blocks', 'core/paragraph', 'color', 'palette' ].

					$whole_path       = array_merge( $base_path, array( $node_name ), $data_path );

					$translated_array = self::translate_theme_json_chunk( $array_to_translate, $key, $context, $domain );

					_wp_array_set( $theme_json, $whole_path, $translated_array );

				}

			} else {

				$array_to_translate = _wp_array_get( $theme_json, $path, null );

				if ( is_null( $array_to_translate ) ) {

					continue;

				}

				$translated_array = self::translate_theme_json_chunk( $array_to_translate, $key, $context, $domain );

				_wp_array_set( $theme_json, $path, $translated_array );

			}

		}

		return $theme_json;

	}

	/**

	 * Return core's origin config.

	 *

	 * @since 5.8.0

	 *

	 * @return WP_Theme_JSON Entity that holds core data.

	 */

	public static function get_core_data() {

		if ( null !== self::$core ) {

			return self::$core;

		}

		$config     = self::read_json_file( __DIR__ . '/theme.json' );

		$config     = self::translate( $config );

		self::$core = new WP_Theme_JSON( $config, 'core' );

		return self::$core;

	}

	/**

	 * Returns the theme's data.

	 *

	 * Data from theme.json can be augmented via the $theme_support_data variable.

	 * This is useful, for example, to backfill the gaps in theme.json that a theme

	 * has declared via add_theme_supports.

	 *

	 * Note that if the same data is present in theme.json and in $theme_support_data,

	 * the theme.json's is not overwritten.

	 *

	 * @since 5.8.0

	 *

	 * @param array $theme_support_data Optional. Theme support data in theme.json format.

	 *                                  Default empty array.

	 * @return WP_Theme_JSON Entity that holds theme data.

	 */

	public static function get_theme_data( $theme_support_data = array() ) {

		if ( null === self::$theme ) {

			$theme_json_data = self::read_json_file( self::get_file_path_from_theme( 'theme.json' ) );

			$theme_json_data = self::translate( $theme_json_data, wp_get_theme()->get( 'TextDomain' ) );

			self::$theme     = new WP_Theme_JSON( $theme_json_data );

		}

		if ( empty( $theme_support_data ) ) {

			return self::$theme;

		}

		/*

		 * We want the presets and settings declared in theme.json

		 * to override the ones declared via add_theme_support.

		 */

		$with_theme_supports = new WP_Theme_JSON( $theme_support_data );

		$with_theme_supports->merge( self::$theme );

		return $with_theme_supports;

	}

	/**

	 * There are different sources of data for a site: core and theme.

	 *

	 * While the getters {@link get_core_data}, {@link get_theme_data} return the raw data

	 * from the respective origins, this method merges them all together.

	 *

	 * If the same piece of data is declared in different origins (core and theme),

	 * the last origin overrides the previous. For example, if core disables custom colors

	 * but a theme enables them, the theme config wins.

	 *

	 * @since 5.8.0

	 *

	 * @param array $settings Optional. Existing block editor settings. Default empty array.

	 * @return WP_Theme_JSON

	 */

	public static function get_merged_data( $settings = array() ) {

		$theme_support_data = WP_Theme_JSON::get_from_editor_settings( $settings );

		$result = new WP_Theme_JSON();

		$result->merge( self::get_core_data() );

		$result->merge( self::get_theme_data( $theme_support_data ) );

		return $result;

	}

	/**

	 * Whether the current theme has a theme.json file.

	 *

	 * @since 5.8.0

	 *

	 * @return bool

	 */

	public static function theme_has_support() {

		if ( ! isset( self::$theme_has_support ) ) {

			self::$theme_has_support = (bool) self::get_file_path_from_theme( 'theme.json' );

		}

		return self::$theme_has_support;

	}

	/**

	 * Builds the path to the given file and checks that it is readable.

	 *

	 * If it isn't, returns an empty string, otherwise returns the whole file path.

	 *

	 * @since 5.8.0

	 *

	 * @param string $file_name Name of the file.

	 * @return string The whole file path or empty if the file doesn't exist.

	 */

	private static function get_file_path_from_theme( $file_name ) {

		/*

		 * This used to be a locate_template call. However, that method proved problematic

		 * due to its use of constants (STYLESHEETPATH) that threw errors in some scenarios.

		 *

		 * When the theme.json merge algorithm properly supports child themes,

		 * this should also fall back to the template path, as locate_template did.

		 */

		$located   = '';

		$candidate = get_stylesheet_directory() . '/' . $file_name;

		if ( is_readable( $candidate ) ) {

			$located = $candidate;

		}

		return $located;

	}

	/**

	 * Cleans the cached data so it can be recalculated.

	 *

	 * @since 5.8.0

	 */

	public static function clean_cached_data() {

		self::$core              = null;

		self::$theme             = null;

		self::$theme_has_support = null;

		self::$theme_json_i18n   = null;

	}

}