<?php
/**
 * Register the scripts, styles, and includes needed for pieces of the Kkart Admin experience.
 * NOTE: DO NOT edit this file in Kkart core, this is generated from kkart-admin.
 */

namespace Automattic\Kkart\Admin;

use \_WP_Dependency;
use Automattic\Kkart\Admin\Features\Onboarding;
use Automattic\Kkart\Admin\API\Reports\Orders\DataStore as OrdersDataStore;
use Automattic\Kkart\Admin\API\Plugins;
use Automattic\Kkart\Admin\Features\Navigation\Screen;
use KKART_Marketplace_Suggestions;

/**
 * Loader Class.
 */
class Loader {
	/**
	 * App entry point.
	 */
	const APP_ENTRY_POINT = 'kkart-admin';

	/**
	 * Class instance.
	 *
	 * @var Loader instance
	 */
	protected static $instance = null;

	/**
	 * An array of classes to load from the includes folder.
	 *
	 * @var array
	 */
	protected static $classes = array();

	/**
	 * WordPress capability required to use analytics features.
	 *
	 * @var string
	 */
	protected static $required_capability = null;

	/**
	 * Get class instance.
	 */
	public static function get_instance() {
		if ( ! self::$instance ) {
			self::$instance = new self();
		}
		return self::$instance;
	}

	/**
	 * Constructor.
	 * Hooks added here should be removed in `kkart_admin_initialize` via the feature plugin.
	 */
	public function __construct() {
		add_action( 'init', array( __CLASS__, 'define_tables' ) );
		// Load feature before Kkart update hooks.
		add_action( 'init', array( __CLASS__, 'load_features' ), 4 );
		add_filter( 'kkart_get_sections_advanced', array( __CLASS__, 'add_features_section' ) );
		add_filter( 'kkart_get_settings_advanced', array( __CLASS__, 'add_features_settings' ), 10, 2 );
		add_action( 'admin_enqueue_scripts', array( __CLASS__, 'register_scripts' ) );
		add_action( 'admin_enqueue_scripts', array( __CLASS__, 'inject_kkart_settings_dependencies' ), 14 );
		add_action( 'admin_enqueue_scripts', array( __CLASS__, 'load_scripts' ), 15 );
		// Old settings injection.
		add_filter( 'kkart_components_settings', array( __CLASS__, 'add_component_settings' ) );
		// New settings injection.
		add_filter( 'kkart_shared_settings', array( __CLASS__, 'add_component_settings' ) );
		add_filter( 'admin_body_class', array( __CLASS__, 'add_admin_body_classes' ) );
		add_action( 'admin_menu', array( __CLASS__, 'register_page_handler' ) );
		add_action( 'admin_menu', array( __CLASS__, 'register_store_details_page' ) );
		add_filter( 'admin_title', array( __CLASS__, 'update_admin_title' ) );
		add_action( 'rest_api_init', array( __CLASS__, 'register_user_data' ) );
		add_action( 'in_admin_header', array( __CLASS__, 'embed_page_header' ) );
		add_filter( 'kkart_settings_groups', array( __CLASS__, 'add_settings_group' ) );
		add_filter( 'kkart_settings-kkart_admin', array( __CLASS__, 'add_settings' ) );
		add_action( 'admin_head', array( __CLASS__, 'remove_notices' ) );
		add_action( 'admin_head', array( __CLASS__, 'smart_app_banner' ) );
		add_action( 'admin_notices', array( __CLASS__, 'inject_before_notices' ), -9999 );
		add_action( 'admin_notices', array( __CLASS__, 'inject_after_notices' ), PHP_INT_MAX );

		// Added this hook to delete the field kkart_onboarding_homepage_post_id when deleting the homepage.
		add_action( 'trashed_post', array( __CLASS__, 'delete_homepage' ) );

		// priority is 20 to run after https://github.com/kkart/kkart/blob/a55ae325306fc2179149ba9b97e66f32f84fdd9c/includes/admin/class-kkart-admin-menus.php#L165.
		add_action( 'admin_head', array( __CLASS__, 'remove_app_entry_page_menu_item' ), 20 );

		/*
		* Remove the emoji script as it always defaults to replacing emojis with Twemoji images.
		* Gutenberg has also disabled emojis. More on that here -> https://github.com/WordPress/gutenberg/pull/6151
		*/
		remove_action( 'admin_print_scripts', 'print_emoji_detection_script' );

		// Combine JSON translation files (from chunks) when language packs are updated.
		add_action( 'upgrader_process_complete', array( __CLASS__, 'combine_translation_chunk_files' ), 10, 2 );
	}

	/**
	 * Add custom tables to $wpdb object.
	 */
	public static function define_tables() {
		global $wpdb;

		// List of tables without prefixes.
		$tables = array(
			'kkart_category_lookup' => 'kkart_category_lookup',
		);

		foreach ( $tables as $name => $table ) {
			$wpdb->$name    = $wpdb->prefix . $table;
			$wpdb->tables[] = $table;
		}
	}

	/**
	 * Gets a build configured array of enabled Kkart Admin features/sections.
	 *
	 * @return array Enabled kkart Admin features/sections.
	 */
	public static function get_features() {
		return apply_filters( 'kkart_admin_features', array() );
	}

	/**
	 * Gets WordPress capability required to use analytics features.
	 *
	 * @return string
	 */
	public static function get_analytics_capability() {
		if ( null === static::$required_capability ) {
			/**
			 * Filters the required capability to use the analytics features.
			 *
			 * @param string $capability WordPress capability.
			 */
			static::$required_capability = apply_filters( 'kkart_analytics_menu_capability', 'view_kkart_reports' );
		}
		return static::$required_capability;
	}

	/**
	 * Helper function indicating whether the current user has the required analytics capability.
	 *
	 * @return bool
	 */
	public static function user_can_analytics() {
		return current_user_can( static::get_analytics_capability() );
	}

	/**
	 * Returns if a specific kkart-admin feature is enabled.
	 *
	 * @param  string $feature Feature slug.
	 * @return bool Returns true if the feature is enabled.
	 */
	public static function is_feature_enabled( $feature ) {
		$features = self::get_features();
		return in_array( $feature, $features, true );
	}

	/**
	 * Determines if a minified JS file should be served.
	 *
	 * @param  boolean $script_debug Only serve unminified files if script debug is on.
	 * @return boolean If js asset should use minified version.
	 */
	public static function should_use_minified_js_file( $script_debug ) {
		// minified files are only shipped in non-core versions of kkart-admin, return false if minified files are not available.
		if ( ! self::is_feature_enabled( 'minified-js' ) ) {
			return false;
		}

		// Otherwise we will serve un-minified files if SCRIPT_DEBUG is on, or if anything truthy is passed in-lieu of SCRIPT_DEBUG.
		return ! $script_debug;
	}

	/**
	 * Gets the URL to an asset file.
	 *
	 * @param  string $file File name (without extension).
	 * @param  string $ext File extension.
	 * @return string URL to asset.
	 */
	public static function get_url( $file, $ext ) {
		$suffix = '';

		// Potentially enqueue minified JavaScript.
		if ( 'js' === $ext ) {
			$script_debug = defined( 'SCRIPT_DEBUG' ) && SCRIPT_DEBUG;
			$suffix       = self::should_use_minified_js_file( $script_debug ) ? '.min' : '';
		}

		return plugins_url( self::get_path( $ext ) . $file . $suffix . '.' . $ext, KKART_ADMIN_PLUGIN_FILE );
	}

	/**
	 * Gets the file modified time as a cache buster if we're in dev mode, or the plugin version otherwise.
	 *
	 * @param string $ext File extension.
	 * @return string The cache buster value to use for the given file.
	 */
	public static function get_file_version( $ext ) {
		if ( defined( 'SCRIPT_DEBUG' ) && SCRIPT_DEBUG ) {
			return filemtime( KKART_ADMIN_ABSPATH . self::get_path( $ext ) );
		}
		return KKART_ADMIN_VERSION_NUMBER;
	}

	/**
	 * Gets the path for the asset depending on file type.
	 *
	 * @param  string $ext File extension.
	 * @return string Folder path of asset.
	 */
	private static function get_path( $ext ) {
		return ( 'css' === $ext ) ? KKART_ADMIN_DIST_CSS_FOLDER : KKART_ADMIN_DIST_JS_FOLDER;
	}

	/**
	 * Class loader for enabled Kkart Admin features/sections.
	 */
	public static function load_features() {
		$features = self::get_features();
		foreach ( $features as $feature ) {
			$feature       = str_replace( '-', '', ucwords( strtolower( $feature ), '-' ) );
			$feature_class = 'Automattic\\Kkart\\Admin\\Features\\' . $feature;

			// Handle features contained in subdirectory.
			if ( ! class_exists( $feature_class ) && class_exists( $feature_class . '\\Init' ) ) {
				$feature_class = $feature_class . '\\Init';
			}

			if ( class_exists( $feature_class ) ) {
				new $feature_class();
			}
		}
	}

	/**
	 * Adds the Features section to the advanced tab of Kkart Settings
	 *
	 * @param array $sections Sections.
	 * @return array
	 */
	public static function add_features_section( $sections ) {
		$sections['features'] = __( 'Features', 'kkart' );
		return $sections;
	}

	/**
	 * Adds the Features settings.
	 *
	 * @param array  $settings Settings.
	 * @param string $current_section Current section slug.
	 * @return array
	 */
	public static function add_features_settings( $settings, $current_section ) {
		if ( 'features' !== $current_section ) {
			return $settings;
		}

		return apply_filters(
			'kkart_settings_features',
			array(
				array(
					'title' => __( 'Features', 'kkart' ),
					'type'  => 'title',
					'desc'  => __( 'Start using new features that are being progressively rolled out to improve the store management experience.', 'kkart' ),
					'id'    => 'features_options',
				),
				array(
					'title' => __( 'Navigation', 'kkart' ),
					'desc'  => __( 'Adds the new Kkart navigation experience to the dashboard', 'kkart' ),
					'id'    => 'kkart_navigation_enabled',
					'type'  => 'checkbox',
				),
				array(
					'type' => 'sectionend',
					'id'   => 'features_options',
				),
			)
		);
	}

	/**
	 * Connects existing Kkart pages.
	 *
	 * @todo The entry point for the embed needs moved to this class as well.
	 */
	public static function register_page_handler() {
		require_once KKART_ADMIN_ABSPATH . 'includes/connect-existing-pages.php';
	}

	/**
	 * Registers the store details (profiler) page.
	 */
	public static function register_store_details_page() {
		kkart_admin_register_page(
			array(
				'title'  => __( 'Setup Wizard', 'kkart' ),
				'parent' => '',
				'path'   => '/setup-wizard',
			)
		);
	}


	/**
	 * Remove the menu item for the app entry point page.
	 */
	public static function remove_app_entry_page_menu_item() {
		global $submenu;
		// User does not have capabilites to see the submenu.
		if ( ! current_user_can( 'manage_kkart' ) || empty( $submenu['kkart'] ) ) {
			return;
		}

		$kkart_admin_key = null;
		foreach ( $submenu['kkart'] as $submenu_key => $submenu_item ) {
			// Our app entry page menu item has no title.
			if ( is_null( $submenu_item[0] ) && self::APP_ENTRY_POINT === $submenu_item[2] ) {
				$kkart_admin_key = $submenu_key;
				break;
			}
		}

		if ( ! $kkart_admin_key ) {
			return;
		}

		unset( $submenu['kkart'][ $kkart_admin_key ] );
	}

	/**
	 * Registers all the neccessary scripts and styles to show the admin experience.
	 */
	public static function register_scripts() {
		if ( ! function_exists( 'wp_set_script_translations' ) ) {
			return;
		}

		$js_file_version  = self::get_file_version( 'js' );
		$css_file_version = self::get_file_version( 'css' );

		wp_register_script(
			'kkart-csv',
			self::get_url( 'csv-export/index', 'js' ),
			array( 'moment' ),
			$js_file_version,
			true
		);

		wp_register_script(
			'kkart-currency',
			self::get_url( 'currency/index', 'js' ),
			array( 'kkart-number' ),
			$js_file_version,
			true
		);

		wp_set_script_translations( 'kkart-currency', 'kkart' );

		wp_register_script(
			'kkart-customer-effort-score',
			self::get_url( 'customer-effort-score/index', 'js' ),
			array(),
			$js_file_version,
			true
		);

		wp_register_script(
			'kkart-navigation',
			self::get_url( 'navigation/index', 'js' ),
			array( 'wp-url', 'wp-hooks' ),
			$js_file_version,
			true
		);

		wp_register_script(
			'kkart-number',
			self::get_url( 'number/index', 'js' ),
			array(),
			$js_file_version,
			true
		);

		wp_register_script(
			'kkart-tracks',
			self::get_url( 'tracks/index', 'js' ),
			array(),
			$js_file_version,
			true
		);

		wp_register_script(
			'kkart-date',
			self::get_url( 'date/index', 'js' ),
			array( 'moment', 'wp-date', 'wp-i18n' ),
			$js_file_version,
			true
		);

		wp_register_script(
			'kkart-store-data',
			self::get_url( 'data/index', 'js' ),
			array(),
			$js_file_version,
			true
		);

		wp_set_script_translations( 'kkart-date', 'kkart' );

		wp_register_script(
			'kkart-components',
			self::get_url( 'components/index', 'js' ),
			array(
				'moment',
				'wp-api-fetch',
				'wp-data',
				'wp-data-controls',
				'wp-element',
				'wp-hooks',
				'wp-html-entities',
				'wp-i18n',
				'wp-keycodes',
				'kkart-csv',
				'kkart-currency',
				'kkart-customer-effort-score',
				'kkart-date',
				'kkart-navigation',
				'kkart-number',
				'kkart-store-data',
			),
			$js_file_version,
			true
		);

		wp_set_script_translations( 'kkart-components', 'kkart' );

		wp_register_style(
			'kkart-components',
			self::get_url( 'components/style', 'css' ),
			array(),
			$css_file_version
		);
		wp_style_add_data( 'kkart-components', 'rtl', 'replace' );

		wp_register_style(
			'kkart-components-ie',
			self::get_url( 'components/ie', 'css' ),
			array(),
			$css_file_version
		);
		wp_style_add_data( 'kkart-components-ie', 'rtl', 'replace' );

		wp_register_style(
			'kkart-customer-effort-score',
			self::get_url( 'customer-effort-score/style', 'css' ),
			array(),
			$css_file_version
		);
		wp_style_add_data( 'kkart-customer-effort-score', 'rtl', 'replace' );

		wp_register_script(
			KKART_ADMIN_APP,
			self::get_url( 'app/index', 'js' ),
			array(
				'wp-core-data',
				'kkart-components',
				'wp-date',
				'wp-plugins',
				'kkart-tracks',
				'kkart-navigation',
			),
			$js_file_version,
			true
		);
		wp_localize_script(
			KKART_ADMIN_APP,
			'wcAdminAssets',
			array(
				'path'    => plugins_url( self::get_path( 'js' ), KKART_ADMIN_PLUGIN_FILE ),
				'version' => $js_file_version,
			)
		);

		wp_set_script_translations( KKART_ADMIN_APP, 'kkart' );

		// The "app" RTL files are in a different format than the components.
		$rtl = is_rtl() ? '.rtl' : '';

		wp_register_style(
			KKART_ADMIN_APP,
			self::get_url( "app/style{$rtl}", 'css' ),
			array( 'kkart-components', 'kkart-customer-effort-score' ),
			$css_file_version
		);

		wp_register_style(
			'kkart-admin-ie',
			self::get_url( "ie/style{$rtl}", 'css' ),
			array( KKART_ADMIN_APP ),
			$css_file_version
		);

		wp_register_style(
			'kkart-material-icons',
			'https://fonts.googleapis.com/icon?family=Material+Icons+Outlined',
			array(),
			$css_file_version
		);
	}

	/**
	 * Generate a filename to cache translations from JS chunks.
	 *
	 * @param string $domain Text domain.
	 * @param string $locale Locale being retrieved.
	 * @return string Filename.
	 */
	public static function get_combined_translation_filename( $domain, $locale ) {
		$filename = implode( '-', array( $domain, $locale, KKART_ADMIN_APP ) ) . '.json';

		return $filename;
	}

	/**
	 * Find and combine translation chunk files.
	 *
	 * Only targets files that aren't represented by a registered script (e.g. not passed to wp_register_script()).
	 *
	 * @param string $lang_dir Path to language files.
	 * @param string $domain Text domain.
	 * @param string $locale Locale being retrieved.
	 * @return array Combined translation chunk data.
	 */
	public static function get_translation_chunk_data( $lang_dir, $domain, $locale ) {
		// So long as this function is called during the 'upgrader_process_complete' action,
		// the filesystem object should be hooked up.
		global $wp_filesystem;

		// Grab all JSON files in the current language pack.
		$json_i18n_filenames       = glob( $lang_dir . $domain . '-' . $locale . '-*.json' );
		$combined_translation_data = array();

		if ( false === $json_i18n_filenames ) {
			return $combined_translation_data;
		}

		foreach ( $json_i18n_filenames as $json_filename ) {
			if ( ! $wp_filesystem->is_readable( $json_filename ) ) {
				continue;
			}

			$file_contents = $wp_filesystem->get_contents( $json_filename );
			$chunk_data    = \json_decode( $file_contents, true );

			if ( empty( $chunk_data ) ) {
				continue;
			}

			if ( ! isset( $chunk_data['comment']['reference'] ) ) {
				continue;
			}

			$reference_file = $chunk_data['comment']['reference'];

			// Only combine "app" files (not scripts registered with WP).
			if (
				false === strpos( $reference_file, 'dist/chunks/' ) &&
				false === strpos( $reference_file, 'dist/app/index.js' )
			) {
				continue;
			}

			if ( empty( $combined_translation_data ) ) {
				// Use the first translation file as the base structure.
				$combined_translation_data = $chunk_data;
			} else {
				// Combine all messages from all chunk files.
				$combined_translation_data['locale_data']['messages'] = array_merge(
					$combined_translation_data['locale_data']['messages'],
					$chunk_data['locale_data']['messages']
				);
			}
		}

		// Remove inaccurate reference comment.
		unset( $combined_translation_data['comment'] );

		return $combined_translation_data;
	}

	/**
	 * Combine translation chunks when files are updated.
	 *
	 * This function combines JSON translation data auto-extracted by GlotPress
	 * from Webpack-generated JS chunks into a single file that can be used in
	 * subsequent requests. This is necessary since the JS chunks are not known
	 * to WordPress via wp_register_script() and wp_set_script_translations().
	 *
	 * @param Language_Pack_Upgrader $instance Upgrader instance.
	 * @param array                  $hook_extra Info about the upgraded language packs.
	 */
	public static function combine_translation_chunk_files( $instance, $hook_extra ) {
		// So long as this function is hooked to the 'upgrader_process_complete' action,
		// the filesystem object should be hooked up.
		global $wp_filesystem;

		if (
			! is_a( $instance, 'Language_Pack_Upgrader' ) ||
			! isset( $hook_extra['translations'] ) ||
			! is_array( $hook_extra['translations'] )
		) {
			return;
		}

		// Make sure we're handing the correct domain (could be kkart or kkart-admin).
		$plugin_domain = explode( '/', plugin_basename( __FILE__ ) )[0];
		$locales       = array();
		$language_dir  = WP_LANG_DIR . '/plugins/';

		// Gather the locales that were updated in this operation.
		foreach ( $hook_extra['translations'] as $translation ) {
			if (
				'plugin' === $translation['type'] &&
				$plugin_domain === $translation['slug']
			) {
				$locales[] = $translation['language'];
			}
		}

		// Build combined translation files for all updated locales.
		foreach ( $locales as $locale ) {
			$translations_from_chunks = self::get_translation_chunk_data( $language_dir, $plugin_domain, $locale );

			if ( empty( $translations_from_chunks ) ) {
				continue;
			}

			$cache_filename          = self::get_combined_translation_filename( $plugin_domain, $locale );
			$chunk_translations_json = wp_json_encode( $translations_from_chunks );

			// Cache combined translations strings to a file.
			$wp_filesystem->put_contents( $language_dir . $cache_filename, $chunk_translations_json );
		}
	}

	/**
	 * Load translation strings from language packs for dynamic imports.
	 *
	 * @param string $file File location for the script being translated.
	 * @param string $handle Script handle.
	 * @param string $domain Text domain.
	 *
	 * @return string New file location for the script being translated.
	 */
	public static function load_script_translation_file( $file, $handle, $domain ) {
		// Make sure the main app script is being loaded.
		if ( KKART_ADMIN_APP !== $handle ) {
			return $file;
		}

		// Make sure we're handing the correct domain (could be kkart or kkart-admin).
		$plugin_domain = explode( '/', plugin_basename( __FILE__ ) )[0];
		if ( $plugin_domain !== $domain ) {
			return $file;
		}

		$locale         = determine_locale();
		$cache_filename = self::get_combined_translation_filename( $domain, $locale );

		return WP_LANG_DIR . '/plugins/' . $cache_filename;
	}

	/**
	 * Loads the required scripts on the correct pages.
	 */
	public static function load_scripts() {
		if ( ! self::is_admin_or_embed_page() ) {
			return;
		}

		if ( ! static::user_can_analytics() ) {
			return;
		}

		// Grab translation strings from Webpack-generated chunks.
		add_filter( 'load_script_translation_file', array( __CLASS__, 'load_script_translation_file' ), 10, 3 );

		$features         = self::get_features();
		$enabled_features = array();
		foreach ( $features as $key ) {
			$enabled_features[ $key ] = self::is_feature_enabled( $key );
		}
		wp_add_inline_script( KKART_ADMIN_APP, 'window.wcAdminFeatures = ' . wp_json_encode( $enabled_features ), 'before' );

		wp_enqueue_script( KKART_ADMIN_APP );
		wp_enqueue_style( KKART_ADMIN_APP );
		wp_enqueue_style( 'kkart-material-icons' );

		// Use server-side detection to prevent unneccessary stylesheet loading in other browsers.
		$user_agent = isset( $_SERVER['HTTP_USER_AGENT'] ) ? $_SERVER['HTTP_USER_AGENT'] : ''; // phpcs:ignore sanitization ok.
		preg_match( '/MSIE (.*?);/', $user_agent, $matches );
		if ( count( $matches ) < 2 ) {
			preg_match( '/Trident\/\d{1,2}.\d{1,2}; rv:([0-9]*)/', $user_agent, $matches );
		}
		if ( count( $matches ) > 1 ) {
			wp_enqueue_style( 'kkart-components-ie' );
			wp_enqueue_style( 'kkart-admin-ie' );
		}

		// Preload our assets.
		self::output_header_preload_tags();
	}

	/**
	 * Render a preload link tag for a dependency, optionally
	 * checked against a provided allowlist.
	 *
	 * See: https://macarthur.me/posts/preloading-javascript-in-wordpress
	 *
	 * @param WP_Dependency $dependency The WP_Dependency being preloaded.
	 * @param string        $type Dependency type - 'script' or 'style'.
	 * @param array         $allowlist Optional. List of allowed dependency handles.
	 */
	public static function maybe_output_preload_link_tag( $dependency, $type, $allowlist = array() ) {
		if ( ! empty( $allowlist ) && ! in_array( $dependency->handle, $allowlist, true ) ) {
			return;
		}

		$source = $dependency->ver ? add_query_arg( 'ver', $dependency->ver, $dependency->src ) : $dependency->src;

		echo '<link rel="preload" href="', esc_url( $source ), '" as="', esc_attr( $type ), '" />', "\n";
	}

	/**
	 * Output a preload link tag for dependencies (and their sub dependencies)
	 * with an optional allowlist.
	 *
	 * See: https://macarthur.me/posts/preloading-javascript-in-wordpress
	 *
	 * @param string $type Dependency type - 'script' or 'style'.
	 * @param array  $allowlist Optional. List of allowed dependency handles.
	 */
	public static function output_header_preload_tags_for_type( $type, $allowlist = array() ) {
		if ( 'script' === $type ) {
			$dependencies_of_type = wp_scripts();
		} elseif ( 'style' === $type ) {
			$dependencies_of_type = wp_styles();
		} else {
			return;
		}

		foreach ( $dependencies_of_type->queue as $dependency_handle ) {
			$dependency = $dependencies_of_type->query( $dependency_handle, 'registered' );

			if ( false === $dependency ) {
				continue;
			}

			// Preload the subdependencies first.
			foreach ( $dependency->deps as $sub_dependency_handle ) {
				$sub_dependency = $dependencies_of_type->query( $sub_dependency_handle, 'registered' );

				if ( $sub_dependency ) {
					self::maybe_output_preload_link_tag( $sub_dependency, $type, $allowlist );
				}
			}

			self::maybe_output_preload_link_tag( $dependency, $type, $allowlist );
		}
	}

	/**
	 * Output preload link tags for all enqueued stylesheets and scripts.
	 *
	 * See: https://macarthur.me/posts/preloading-javascript-in-wordpress
	 */
	public static function output_header_preload_tags() {
		$kkart_admin_scripts = array(
			KKART_ADMIN_APP,
			'kkart-components',
		);

		$kkart_admin_styles = array(
			KKART_ADMIN_APP,
			'kkart-components',
			'kkart-components-ie',
			'kkart-admin-ie',
			'kkart-material-icons',
		);

		// Preload styles.
		self::output_header_preload_tags_for_type( 'style', $kkart_admin_styles );

		// Preload scripts.
		self::output_header_preload_tags_for_type( 'script', $kkart_admin_scripts );
	}

	/**
	 * Returns true if we are on a JS powered admin page or
	 * a "classic" (non JS app) powered admin page (an embedded page).
	 */
	public static function is_admin_or_embed_page() {
		return self::is_admin_page() || self::is_embed_page();
	}

	/**
	 * Returns true if we are on a JS powered admin page.
	 */
	public static function is_admin_page() {
		return kkart_admin_is_registered_page();
	}

	/**
	 *  Returns true if we are on a "classic" (non JS app) powered admin page.
	 *
	 * TODO: See usage in `admin.php`. This needs refactored and implemented properly in core.
	 */
	public static function is_embed_page() {
		return kkart_admin_is_connected_page() || ( ! self::is_admin_page() && Screen::is_kkart_page() );
	}

	/**
	 * Returns breadcrumbs for the current page.
	 */
	private static function get_embed_breadcrumbs() {
		return kkart_admin_get_breadcrumbs();
	}

	/**
	 * Outputs breadcrumbs via PHP for the initial load of an embedded page.
	 *
	 * @param array $section Section to create breadcrumb from.
	 */
	private static function output_heading( $section ) {
		if ( ! static::user_can_analytics() ) {
			return;
		}

		echo esc_html( $section );
	}

	/**
	 * Set up a div for the header embed to render into.
	 * The initial contents here are meant as a place loader for when the PHP page initialy loads.
	 */
	public static function embed_page_header() {
		if ( ! self::is_admin_page() && ! self::is_embed_page() ) {
			return;
		}

		if ( ! static::user_can_analytics() ) {
			return;
		}

		if ( ! self::is_embed_page() ) {
			return;
		}

		$sections = self::get_embed_breadcrumbs();
		$sections = is_array( $sections ) ? $sections : array( $sections );
		?>
		<div id="kkart-embedded-root" class="is-embed-loading">
			<div class="kkart-layout">
				<div class="kkart-layout__header is-embed-loading">
					<h1 class="kkart-layout__header-heading">
						<?php self::output_heading( end( $sections ) ); ?>
					</h1>
				</div>
			</div>
		</div>
		<?php
	}

	/**
	 * Adds body classes to the main wp-admin wrapper, allowing us to better target elements in specific scenarios.
	 *
	 * @param string $admin_body_class Body class to add.
	 */
	public static function add_admin_body_classes( $admin_body_class = '' ) {
		if ( ! self::is_admin_or_embed_page() ) {
			return $admin_body_class;
		}

		$classes   = explode( ' ', trim( $admin_body_class ) );
		$classes[] = 'kkart-page';
		if ( self::is_embed_page() ) {
			$classes[] = 'kkart-embed-page';
		}

		/**
		 * Some routes or features like onboarding hide the wp-admin navigation and masterbar.
		 * Setting `kkart_admin_is_loading` to true allows us to premeptively hide these
		 * elements while the JS app loads.
		 * This class needs to be removed by those feature components (like <ProfileWizard />).
		 *
		 * @param bool $is_loading If Kkart Admin is loading a fullscreen view.
		 */
		$is_loading = apply_filters( 'kkart_admin_is_loading', false );

		if ( self::is_admin_page() && $is_loading ) {
			$classes[] = 'kkart-admin-is-loading';
		}

		$features = self::get_features();
		foreach ( $features as $feature_key ) {
			$classes[] = sanitize_html_class( 'kkart-feature-enabled-' . $feature_key );
		}

		$admin_body_class = implode( ' ', array_unique( $classes ) );
		return " $admin_body_class ";
	}

	/**
	 * Adds an iOS "Smart App Banner" for display on iOS Safari.
	 * See https://developer.apple.com/library/archive/documentation/AppleApplications/Reference/SafariWebContent/PromotingAppswithAppBanners/PromotingAppswithAppBanners.html
	 */
	public static function smart_app_banner() {
		if ( self::is_admin_or_embed_page() ) {
			echo "
				<meta name='apple-itunes-app' content='app-id=1389130815'>
			";
		}
	}


	/**
	 * Removes notices that should not be displayed on KKART Admin pages.
	 */
	public static function remove_notices() {
		if ( ! self::is_admin_or_embed_page() ) {
			return;
		}

		// Hello Dolly.
		if ( function_exists( 'hello_dolly' ) ) {
			remove_action( 'admin_notices', 'hello_dolly' );
		}
	}

	/**
	 * Runs before admin notices action and hides them.
	 */
	public static function inject_before_notices() {
		if ( ! self::is_admin_or_embed_page() ) {
			return;
		}

		// Wrap the notices in a hidden div to prevent flickering before
		// they are moved elsewhere in the page by WordPress Core.
		echo '<div class="kkart-layout__notice-list-hide" id="wp__notice-list">';

		if ( self::is_admin_page() ) {
			// Capture all notices and hide them. WordPress Core looks for
			// `.wp-header-end` and appends notices after it if found.
			// https://github.com/WordPress/WordPress/blob/f6a37e7d39e2534d05b9e542045174498edfe536/wp-admin/js/common.js#L737 .
			echo '<div class="wp-header-end" id="kkart-layout__notice-catcher"></div>';
		}
	}

	/**
	 * Runs after admin notices and closes div.
	 */
	public static function inject_after_notices() {
		if ( ! self::is_admin_or_embed_page() ) {
			return;
		}

		// Close the hidden div used to prevent notices from flickering before
		// they are inserted elsewhere in the page.
		echo '</div>';
	}

	/**
	 * Edits Admin title based on section of kkart-admin.
	 *
	 * @param string $admin_title Modifies admin title.
	 * @todo Can we do some URL rewriting so we can figure out which page they are on server side?
	 */
	public static function update_admin_title( $admin_title ) {
		if (
			! did_action( 'current_screen' ) ||
			! self::is_admin_page()
		) {
			return $admin_title;
		}

		$sections = self::get_embed_breadcrumbs();
		$pieces   = array();

		foreach ( $sections as $section ) {
			$pieces[] = is_array( $section ) ? $section[1] : $section;
		}

		$pieces = array_reverse( $pieces );
		$title  = implode( ' &lsaquo; ', $pieces );

		/* translators: %1$s: updated title, %2$s: blog info name */
		return sprintf( __( '%1$s &lsaquo; %2$s', 'kkart' ), $title, get_bloginfo( 'name' ) );
	}

	/**
	 * Set up a div for the app to render into.
	 */
	public static function page_wrapper() {
		?>
		<div class="wrap">
			<div id="root"></div>
		</div>
		<?php
	}

	/**
	 * Hooks extra neccessary data into the component settings array already set in Kkart core.
	 *
	 * @param array $settings Array of component settings.
	 * @return array Array of component settings.
	 */
	public static function add_component_settings( $settings ) {
		if ( ! is_admin() ) {
			return $settings;
		}

		if ( ! function_exists( 'kkart_blocks_container' ) ) {
			global $wp_locale;
			// inject data not available via older versions of kkart_blocks/woo.
			$settings['orderStatuses'] = self::get_order_statuses( kkart_get_order_statuses() );
			$settings['stockStatuses'] = self::get_order_statuses( kkart_get_product_stock_status_options() );
			$settings['currency']      = self::get_currency_settings();
			$settings['locale']        = [
				'siteLocale'    => isset( $settings['siteLocale'] )
					? $settings['siteLocale']
					: get_locale(),
				'userLocale'    => isset( $settings['l10n']['userLocale'] )
					? $settings['l10n']['userLocale']
					: get_user_locale(),
				'weekdaysShort' => isset( $settings['l10n']['weekdaysShort'] )
					? $settings['l10n']['weekdaysShort']
					: array_values( $wp_locale->weekday_abbrev ),
			];
		}

		$preload_data_endpoints = apply_filters( 'kkart_component_settings_preload_endpoints', array( '/kkart/v3' ) );
		if ( class_exists( 'Jetpack' ) ) {
			$preload_data_endpoints['jetpackStatus'] = '/jetpack/v4/connection';
		}
		if ( ! empty( $preload_data_endpoints ) ) {
			$preload_data = array_reduce(
				array_values( $preload_data_endpoints ),
				'rest_preload_api_request'
			);
		}

		$preload_options = apply_filters( 'kkart_admin_preload_options', array() );
		if ( ! empty( $preload_options ) ) {
			foreach ( $preload_options as $option ) {
				$settings['preloadOptions'][ $option ] = get_option( $option );
			}
		}

		$preload_settings = apply_filters( 'kkart_admin_preload_settings', array() );
		if ( ! empty( $preload_settings ) ) {
			$setting_options = new \KKART_REST_Setting_Options_V2_Controller();
			foreach ( $preload_settings as $group ) {
				$group_settings   = $setting_options->get_group_settings( $group );
				$preload_settings = [];
				foreach ( $group_settings as $option ) {
					$preload_settings[ $option['id'] ] = $option['value'];
				}
				$settings['preloadSettings'][ $group ] = $preload_settings;
			}
		}

		$user_controller   = new \WP_REST_Users_Controller();
		$user_response     = $user_controller->get_current_item( new \WP_REST_Request() );
		$current_user_data = is_wp_error( $user_response ) ? (object) array() : $user_response->get_data();

		$settings['currentUserData']      = $current_user_data;
		$settings['reviewsEnabled']       = get_option( 'kkart_enable_reviews' );
		$settings['manageStock']          = get_option( 'kkart_manage_stock' );
		$settings['commentModeration']    = get_option( 'comment_moderation' );
		$settings['notifyLowStockAmount'] = get_option( 'kkart_notify_low_stock_amount' );
		// @todo On merge, once plugin images are added to core Kkart, `wcAdminAssetUrl` can be retired,
		// and `wcAssetUrl` can be used in its place throughout the codebase.
		$settings['wcAdminAssetUrl'] = plugins_url( 'images/', dirname( __DIR__ ) . '/kkart-admin.php' );
		$settings['wcVersion']       = KKART_VERSION;
		$settings['siteUrl']         = site_url();
		$settings['dateFormat']      = get_option( 'date_format' );
		$settings['plugins']         = array(
			'installedPlugins' => PluginsHelper::get_installed_plugin_slugs(),
			'activePlugins'    => Plugins::get_active_plugins(),
		);
		// Plugins that depend on changing the translation work on the server but not the client -
		// Kkart Branding is an example of this - so pass through the translation of
		// 'Kkart' to wcSettings.
		$settings['kkartTranslation'] = __( 'Kkart', 'kkart' );
		// We may have synced orders with a now-unregistered status.
		// E.g An extension that added statuses is now inactive or removed.
		$settings['unregisteredOrderStatuses'] = self::get_unregistered_order_statuses();
		// The separator used for attributes found in Variation titles.
		$settings['variationTitleAttributesSeparator'] = apply_filters( 'kkart_product_variation_title_attributes_separator', ' - ', new \KKART_Product() );

		if ( ! empty( $preload_data_endpoints ) ) {
			$settings['dataEndpoints'] = isset( $settings['dataEndpoints'] )
				? $settings['dataEndpoints']
				: [];
			foreach ( $preload_data_endpoints as $key => $endpoint ) {
				// Handle error case: rest_do_request() doesn't guarantee success.
				if ( empty( $preload_data[ $endpoint ] ) ) {
					$settings['dataEndpoints'][ $key ] = array();
				} else {
					$settings['dataEndpoints'][ $key ] = $preload_data[ $endpoint ]['body'];
				}
			}
		}
		$settings = self::get_custom_settings( $settings );
		if ( self::is_embed_page() ) {
			$settings['embedBreadcrumbs'] = self::get_embed_breadcrumbs();
		}

		$settings['allowMarketplaceSuggestions'] = KKART_Marketplace_Suggestions::allow_suggestions();
		$settings['connectNonce']                = wp_create_nonce( 'connect' );

		return $settings;
	}

	/**
	 * Format order statuses by removing a leading 'kkart-' if present.
	 *
	 * @param array $statuses Order statuses.
	 * @return array formatted statuses.
	 */
	public static function get_order_statuses( $statuses ) {
		$formatted_statuses = array();
		foreach ( $statuses as $key => $value ) {
			$formatted_key                        = preg_replace( '/^kkart-/', '', $key );
			$formatted_statuses[ $formatted_key ] = $value;
		}
		return $formatted_statuses;
	}

	/**
	 * Get all order statuses present in analytics tables that aren't registered.
	 *
	 * @return array Unregistered order statuses.
	 */
	public static function get_unregistered_order_statuses() {
		$registered_statuses   = kkart_get_order_statuses();
		$all_synced_statuses   = OrdersDataStore::get_all_statuses();
		$unregistered_statuses = array_diff( $all_synced_statuses, array_keys( $registered_statuses ) );
		$formatted_status_keys = self::get_order_statuses( array_fill_keys( $unregistered_statuses, '' ) );
		$formatted_statuses    = array_keys( $formatted_status_keys );

		return array_combine( $formatted_statuses, $formatted_statuses );
	}

	/**
	 * Register the admin settings for use in the KKART REST API
	 *
	 * @param array $groups Array of setting groups.
	 * @return array
	 */
	public static function add_settings_group( $groups ) {
		$groups[] = array(
			'id'          => 'kkart_admin',
			'label'       => __( 'Kkart Admin', 'kkart' ),
			'description' => __( 'Settings for Kkart admin reporting.', 'kkart' ),
		);
		return $groups;
	}

	/**
	 * Add KKART Admin specific settings
	 *
	 * @param array $settings Array of settings in kkart admin group.
	 * @return array
	 */
	public static function add_settings( $settings ) {
		$unregistered_statuses = self::get_unregistered_order_statuses();
		$registered_statuses   = self::get_order_statuses( kkart_get_order_statuses() );
		$all_statuses          = array_merge( $unregistered_statuses, $registered_statuses );

		$settings[] = array(
			'id'          => 'kkart_excluded_report_order_statuses',
			'option_key'  => 'kkart_excluded_report_order_statuses',
			'label'       => __( 'Excluded report order statuses', 'kkart' ),
			'description' => __( 'Statuses that should not be included when calculating report totals.', 'kkart' ),
			'default'     => array( 'pending', 'cancelled', 'failed' ),
			'type'        => 'multiselect',
			'options'     => $all_statuses,
		);
		$settings[] = array(
			'id'          => 'kkart_actionable_order_statuses',
			'option_key'  => 'kkart_actionable_order_statuses',
			'label'       => __( 'Actionable order statuses', 'kkart' ),
			'description' => __( 'Statuses that require extra action on behalf of the store admin.', 'kkart' ),
			'default'     => array( 'processing', 'on-hold' ),
			'type'        => 'multiselect',
			'options'     => $all_statuses,
		);
		$settings[] = array(
			'id'          => 'kkart_default_date_range',
			'option_key'  => 'kkart_default_date_range',
			'label'       => __( 'Default Date Range', 'kkart' ),
			'description' => __( 'Default Date Range', 'kkart' ),
			'default'     => 'period=month&compare=previous_year',
			'type'        => 'text',
		);
		return $settings;
	}

	/**
	 * Gets custom settings used for KKART Admin.
	 *
	 * @param array $settings Array of settings to merge into.
	 * @return array
	 */
	public static function get_custom_settings( $settings ) {
		$kkart_rest_settings_options_controller = new \KKART_REST_Setting_Options_Controller();
		$kkart_admin_group_settings             = $kkart_rest_settings_options_controller->get_group_settings( 'kkart_admin' );
		$settings['wcAdminSettings']         = array();

		foreach ( $kkart_admin_group_settings as $setting ) {
			if ( ! empty( $setting['id'] ) ) {
				$settings['wcAdminSettings'][ $setting['id'] ] = $setting['value'];
			}
		}
		return $settings;
	}

	/**
	 * Return an object defining the currecy options for the site's current currency
	 *
	 * @return  array  Settings for the current currency {
	 *     Array of settings.
	 *
	 *     @type string $code       Currency code.
	 *     @type string $precision  Number of decimals.
	 *     @type string $symbol     Symbol for currency.
	 * }
	 */
	public static function get_currency_settings() {
		$code = get_kkart_currency();

		return apply_filters(
			'kkart_currency_settings',
			array(
				'code'              => $code,
				'precision'         => kkart_get_price_decimals(),
				'symbol'            => html_entity_decode( get_kkart_currency_symbol( $code ) ),
				'symbolPosition'    => get_option( 'kkart_currency_pos' ),
				'decimalSeparator'  => kkart_get_price_decimal_separator(),
				'thousandSeparator' => kkart_get_price_thousand_separator(),
				'priceFormat'       => html_entity_decode( get_kkart_price_format() ),
			)
		);
	}

	/**
	 * Registers Kkart specific user data to the WordPress user API.
	 */
	public static function register_user_data() {
		register_rest_field(
			'user',
			'kkart_meta',
			array(
				'get_callback'    => array( __CLASS__, 'get_user_data_values' ),
				'update_callback' => array( __CLASS__, 'update_user_data_values' ),
				'schema'          => null,
			)
		);
	}

	/**
	 * For all the registered user data fields (  Loader::get_user_data_fields ), fetch the data
	 * for returning via the REST API.
	 *
	 * @param WP_User $user Current user.
	 */
	public static function get_user_data_values( $user ) {
		$values = array();
		foreach ( self::get_user_data_fields() as $field ) {
			$values[ $field ] = self::get_user_data_field( $user['id'], $field );
		}
		return $values;
	}

	/**
	 * For all the registered user data fields ( Loader::get_user_data_fields ), update the data
	 * for the REST API.
	 *
	 * @param array   $values   The new values for the meta.
	 * @param WP_User $user     The current user.
	 * @param string  $field_id The field id for the user meta.
	 */
	public static function update_user_data_values( $values, $user, $field_id ) {
		if ( empty( $values ) || ! is_array( $values ) || 'kkart_meta' !== $field_id ) {
			return;
		}
		$fields  = self::get_user_data_fields();
		$updates = array();
		foreach ( $values as $field => $value ) {
			if ( in_array( $field, $fields, true ) ) {
				$updates[ $field ] = $value;
				self::update_user_data_field( $user->ID, $field, $value );
			}
		}
		return $updates;
	}

	/**
	 * We store some Kkart specific user meta attached to users endpoint,
	 * so that we can track certain preferences or values such as the inbox activity panel last open time.
	 * Additional fields can be added in the function below, and then used via kkart-admin's currentUser data.
	 *
	 * @return array Fields to expose over the WP user endpoint.
	 */
	public static function get_user_data_fields() {
		return apply_filters( 'kkart_admin_get_user_data_fields', array() );
	}

	/**
	 * Helper to update user data fields.
	 *
	 * @param int    $user_id  User ID.
	 * @param string $field Field name.
	 * @param mixed  $value  Field value.
	 */
	public static function update_user_data_field( $user_id, $field, $value ) {
		update_user_meta( $user_id, 'kkart_admin_' . $field, $value );
	}

	/**
	 * Helper to retrive user data fields.
	 *
	 * Migrates old key prefixes as well.
	 *
	 * @param int    $user_id  User ID.
	 * @param string $field Field name.
	 * @return mixed The user field value.
	 */
	public static function get_user_data_field( $user_id, $field ) {
		$meta_value = get_user_meta( $user_id, 'kkart_admin_' . $field, true );

		// Migrate old meta values (prefix changed from `kkart_admin_` to `kkart_admin_`).
		if ( '' === $meta_value ) {
			$old_meta_value = get_user_meta( $user_id, 'kkart_admin_' . $field, true );

			if ( '' !== $old_meta_value ) {
				self::update_user_data_field( $user_id, $field, $old_meta_value );
				delete_user_meta( $user_id, 'kkart_admin_' . $field );

				$meta_value = $old_meta_value;
			}
		}

		return $meta_value;
	}

	/**
	 * Injects wp-shared-settings as a dependency if it's present.
	 */
	public static function inject_kkart_settings_dependencies() {
		if ( wp_script_is( 'kkart-settings', 'registered' ) ) {
			$handles_for_injection = [
				'kkart-csv',
				'kkart-currency',
				'kkart-customer-effort-score',
				'kkart-navigation',
				'kkart-number',
				'kkart-date',
				'kkart-components',
				'kkart-tracks',
			];
			foreach ( $handles_for_injection as $handle ) {
				$script = wp_scripts()->query( $handle, 'registered' );
				if ( $script instanceof _WP_Dependency ) {
					$script->deps[] = 'kkart-settings';
				}
			}
		}
	}

	/**
	 * Delete kkart_onboarding_homepage_post_id field when the homepage is deleted
	 *
	 * @param int $post_id The deleted post id.
	 */
	public static function delete_homepage( $post_id ) {
		if ( 'page' !== get_post_type( $post_id ) ) {
			return;
		}
		$homepage_id = intval( get_option( 'kkart_onboarding_homepage_post_id', false ) );
		if ( $homepage_id === $post_id ) {
			delete_option( 'kkart_onboarding_homepage_post_id' );
		}
	}
}