me( $plugin_file ) . '/';
		}

		/**
		 * Get the build the plugin is running on.
		 *
		 * @return int
		 */
		public static function get_plugin_build() {
			$self = self::get_instance();

			return $self->plugin_build;
		}

		/**
		 * Get the build the database is running.
		 *
		 * @param bool $use_cache
		 *
		 * @return int
		 */
		public static function get_saved_plugin_build( $use_cache = true ) {
			if ( $use_cache ) {
				return ITSEC_Modules::get_setting( 'global', 'build' );
			}

			$storage = get_site_option( 'itsec-storage' );

			if ( ! $storage ) {
				return 0;
			}

			if ( ! isset( $storage['global']['build'] ) ) {
				return 0;
			}

			return (int) $storage['global']['build'];
		}

		public static function get_plugin_dir() {
			$self = self::get_instance();

			return $self->plugin_dir;
		}

		public static function get_core_dir() {
			return self::get_plugin_dir() . 'core/';
		}

		public static function get_plugin_name() {
			$self = self::get_instance();

			return $self->plugin_name;
		}

		/**
		 * Is this an Solid Security Pro installation.
		 *
		 * This value is not cached.
		 *
		 * @return bool
		 */
		public static function is_pro() {
			return is_dir( self::get_plugin_dir() . 'pro' );
		}

		/**
		 * Gets the installation type.
		 *
		 * @return string
		 */
		public static function get_install_type() {
			if ( defined( 'ITSEC_FORCE_INSTALL_TYPE' ) && ITSEC_FORCE_INSTALL_TYPE === 'free' ) {
				return 'free';
			}

			if ( self::is_pro() ) {
				return 'pro';
			}

			return 'free';
		}

		/**
		 * Is this an actively licensed Pro installation.
		 *
		 * @return bool
		 */
		public static function is_licensed() {
			if ( ! self::is_pro() ) {
				return false;
			}

			if ( ! isset( $GLOBALS['ithemes_updater_path'] ) ) {
				return false;
			}

			include_once( $GLOBALS['ithemes_updater_path'] . '/keys.php' );
			include_once( $GLOBALS['ithemes_updater_path'] . '/packages.php' );

			if ( ! class_exists( 'Ithemes_Updater_Packages' ) ) {
				return false;
			}

			$package_details = Ithemes_Updater_Packages::get_full_details();
			$file            = plugin_basename( self::get_plugin_file() );

			if ( empty( $package_details['packages'][ $file ]['status'] ) ) {
				return false;
			}

			if ( empty( $package_details['packages'][ $file ]['user'] ) ) {
				return false;
			}

			return 'active' === $package_details['packages'][ $file ]['status'];
		}

		/**
		 * Checks if this Pro install has access to Patchstack.
		 *
		 * @return bool
		 */
		public static function has_patchstack(): bool {
			if ( ! self::is_licensed() || 'free' === self::get_install_type() ) {
				return false;
			}

			if ( ! function_exists( 'ithemes_updater_site_has_patchstack' ) ) {
				return false;
			}

			return ithemes_updater_site_has_patchstack();
		}

		/**
		 * Gets the URL Solid Security was licensed for.
		 *
		 * @return string
		 */
		public static function get_licensed_url() {
			if ( ! self::is_licensed() || ! function_exists( 'ithemes_updater_get_licensed_site_url' ) ) {
				return '';
			}

			if ( ! ithemes_updater_is_licensed_site_url_confirmed() ) {
				return '';
			}

			$hostname = ithemes_updater_get_licensed_site_url();

			if ( ! $hostname ) {
				return '';
			}

			return $hostname;
		}

		/**
		 * Gets the username that is licensed.
		 *
		 * @return string
		 */
		public static function get_licensed_user() {
			if ( ! self::is_licensed() ) {
				return '';
			}

			if ( ! function_exists( 'ithemes_updater_get_licensed_username' ) ) {
				return '';
			}

			return ithemes_updater_get_licensed_username( 'ithemes-security-pro' );
		}

		/**
		 * Checks if the licensed user is a Liquid Web customer.
		 *
		 * @return bool
		 */
		public static function licensed_user_is_lw_customer() {
			return self::get_licensed_user() === 'liquidweb';
		}

		/**
		 * Get the current local timestamp.
		 *
		 * This value will be the same throughout the entire request.
		 *
		 * @return int
		 */
		public static function get_current_time() {
			$self = self::get_instance();

			return $self->current_time;
		}

		/**
		 * Get the current UTC timestamp.
		 *
		 * This value will be the same throughout the entire request.
		 *
		 * @return int|\DateTimeInterface
		 */
		public static function get_current_time_gmt( bool $as_object = false ) {
			$self = self::get_instance();

			return $as_object ? new \DateTimeImmutable( '@' . $self->current_time_gmt ) : $self->current_time_gmt;
		}

		/**
		 * Get the UTC offset in seconds.
		 *
		 * @return int
		 */
		public static function get_time_offset() {
			$self = self::get_instance();

			return $self->current_time - $self->current_time_gmt;
		}

		public static function get_settings_page_url() {
			$url = network_admin_url( 'admin.php?page=itsec' );

			return $url;
		}

		public static function get_logs_page_url( $filters = false, $deprecated = false ) {
			$url = network_admin_url( 'admin.php?page=itsec-logs' );

			if ( is_string( $filters ) ) {
				_deprecated_argument( __METHOD__, '6.7.0', __( 'Passing a module as a single parameter is no longer supported. Pass a filters array instead.', 'better-wp-security' ) );

				$filters           = array();
				$filters['module'] = $filters;
			}

			if ( $deprecated ) {
				_deprecated_argument( __METHOD__, '6.7.0', __( 'Passing the log type as the second parameter is no longer supported. Pass a filters array instead.', 'better-wp-security' ) );
				$filters['type'] = $deprecated;
			}

			if ( $filters ) {
				$formatted = array();

				foreach ( $filters as $filter => $value ) {
					$formatted[] = rawurlencode( "{$filter}|{$value}" );
				}

				$url = add_query_arg( array( 'filters' => $formatted ), $url );
			}

			return $url;
		}

		public static function get_backup_creation_page_url() {
			$url = self::get_settings_module_url( 'backup' );

			return apply_filters( 'itsec-filter-backup-creation-page-url', $url );
		}

		public static function get_settings_module_route( $module ) {
			$path   = '/settings/configure/';
			$config = ITSEC_Modules::get_config( $module );

			if ( ! $config ) {
				return $path;
			}

			if ( $config->get_id() === 'global' ) {
				return '/settings/global';
			}

			if ( in_array( $config->get_type(), [ 'custom', 'tool', 'recommended' ], true ) ) {
				return $path;
			}

			if ( $config->get_type() === 'advanced' ) {
				return "/settings/advanced#{$config->get_id()}";
			}

			$settings = ITSEC_Modules::get_settings_obj( $module );

			if ( $config->get_status() === 'always-active' && ! $settings->show_ui() ) {
				return $path;
			}

			return "/settings/configure/{$config->get_type()}#{$config->get_id()}";
		}

		public static function get_settings_module_url( $module ) {
			$path = self::get_settings_module_route( $module );

			return self::get_admin_page_url( 'settings', $path );
		}

		public static function get_url_for_settings_route( $path ) {
			return self::get_admin_page_url( 'settings', $path );
		}

		public static function get_link_for_settings_route( $path ) {
			$url = self::get_url_for_settings_route( $path );

			return sprintf( '<a href="%s" data-itsec-path="%s">', esc_attr( $url ), esc_attr( $path ) );
		}

		/**
		 * Gets the URL for a Tool.
		 *
		 * @deprecated 8.0.0
		 *
		 * @param string $tool
		 *
		 * @return string
		 */
		public static function get_tools_route( string $tool ): string {
			_deprecated_function( __METHOD__, '7.0.0' );

			return '';
		}

		public static function get_url_for_tools_route( string $tool ): string {
			return self::get_url_for_settings_route( '/settings/tools' ) . '#' . $tool;
		}

		/**
		 * Gets the URL for an admin page.
		 *
		 * @param string $page
		 * @param string $path
		 *
		 * @return string
		 */
		public static function get_admin_page_url( string $page, string $path = '/' ) {
			if ( $page === 'settings' || $page === '' ) {
				$page = 'itsec';
			} else {
				$page = 'itsec-' . $page;
			}

			$parts = explode( '#', $path );
			$path = $parts[0];
			$hash = '';
			if ( count( $parts ) > 1 ) {
				$hash = '#' . $parts[1];
			}

			return network_admin_url( sprintf( 'admin.php?page=%s&path=%s%s', $page, urlencode( $path ), $hash ) );
		}

		/**
		 * Gets the URL for the Security Check page.
		 *
		 * @return string
		 * @deprecated 7.0.0
		 *
		 */
		public static function get_security_check_page_url() {
			_deprecated_function( __METHOD__, '7.0.0' );

			return self::get_settings_page_url();
		}

		/**
		 * Specify whether there is a user modifying settings or if an API is modifying settings.
		 *
		 * @param bool $interactive
		 */
		public static function set_interactive( $interactive = true ) {
			$self              = self::get_instance();
			$self->interactive = (bool) $interactive;
		}

		/**
		 * Is a user modifying settings or the API modifying settings (such as from Sync requests).
		 *
		 * @return bool
		 */
		public static function is_interactive() {
			$self = self::get_instance();

			return $self->interactive;
		}

		/**
		 * Runs a callback with the given interactivity settings.
		 *
		 * @param bool     $interactive Whether to process the callback in interactive mode.
		 * @param callable $callback    The callback to execute.
		 *
		 * @return mixed The return value from callback.
		 */
		public static function with_interactivity( bool $interactive, callable $callback ) {
			$current = self::is_interactive();
			self::set_interactive( $interactive );
			$r = $callback();
			self::set_interactive( $current );

			return $r;
		}

		/**
		 * Determine whether the current request is an Infinite WP API call.
		 *
		 * @return bool
		 */
		public static function is_iwp_call() {
			return false;
		}

		/**
		 * Get the configured WordPress upload directory of the main site.
		 *
		 * This value is cached for both the lifetime of the request and possibly indefinitely when WordPress is
		 * using an object cache.
		 *
		 * @return array
		 * @see wp_upload_dir
		 *
		 */
		public static function get_wp_upload_dir() {
			$self = self::get_instance();

			if ( isset( $self->wp_upload_dir ) ) {
				return $self->wp_upload_dir;
			}

			$wp_upload_dir = get_site_transient( 'itsec_wp_upload_dir' );

			if ( ! is_array( $wp_upload_dir ) || ! isset( $wp_upload_dir['basedir'] ) || ! is_dir( $wp_upload_dir['basedir'] ) ) {
				if ( is_multisite() ) {
					switch_to_blog( 1 );
					$wp_upload_dir = wp_upload_dir();
					restore_current_blog();
				} else {
					$wp_upload_dir = wp_upload_dir();
				}

				set_site_transient( 'itsec_wp_upload_dir', $wp_upload_dir, DAY_IN_SECONDS );
			}

			$self->wp_upload_dir = $wp_upload_dir;

			return $self->wp_upload_dir;
		}

		/**
		 * Set a new upload directory and ensure the previously cached value is cleared.
		 *
		 * @param string $old_dir
		 * @param string $new_dir
		 */
		public static function update_wp_upload_dir( $old_dir, $new_dir ) {
			$self = self::get_instance();

			// Prime caches.
			self::get_wp_upload_dir();

			$self->wp_upload_dir = str_replace( $old_dir, $new_dir, $self->wp_upload_dir );

			// Ensure that the transient will be regenerated on the next page load.
			delete_site_transient( 'itsec_wp_upload_dir' );
		}

		/**
		 * Retrieve and/or create a directory for ITSEC to store data.
		 *
		 * @param string $dir    Optionally specify an additional sub-directory.
		 * @param bool   $public Whether to get the public version of the directory.
		 *
		 * @return string
		 */
		public static function get_storage_dir( $dir = '', $public = false ) {
			$wp_upload_dir = self::get_wp_upload_dir();

			$storage_dir = $wp_upload_dir['basedir'];

			if ( $public ) {
				$storage_dir .= '/ithemes-security-public/';
			} else {
				$storage_dir .= '/ithemes-security/';
			}

			$dir = $storage_dir . $dir;
			$dir = rtrim( $dir, '/' );

			ITSEC_Lib_Directory::create( $dir );

			return $dir;
		}

		/**
		 * Get the URL to the directory that ITSEC stores data in.
		 *
		 * @param string $dir
		 * @param bool   $public Whether to get the public version of the directory.
		 *
		 * @return string
		 */
		public static function get_storage_url( $dir = '', $public = false ) {

			self::get_storage_dir( $dir );

			$upload_dir = self::get_wp_upload_dir();
			$base       = untrailingslashit( $upload_dir['baseurl'] );

			$url = $base;

			if ( $public ) {
				$url .= '/ithemes-security-public/';
			} else {
				$url .= '/ithemes-security/';
			}

			return $url . $dir;
		}

		public static function doing_data_upgrade() {
			$self = self::get_instance();

			return $self->doing_data_upgrade;
		}

		public static function is_ajax_request() {
			if ( function_exists( 'wp_doing_ajax' ) ) {
				return wp_doing_ajax();
			}

			return defined( 'DOING_AJAX' ) && DOING_AJAX;
		}

		public static function is_xmlrpc_request() {
			return defined( 'XMLRPC_REQUEST' ) && XMLRPC_REQUEST;
		}

		/**
		 * Is this a WordPress REST API request.
		 *
		 * This function is suitable to be used immediately, not just after REST_REQUEST has been defined.
		 *
		 * @return bool
		 */
		public static function is_rest_api_request() {
			if ( isset( $GLOBALS['__itsec_core_is_rest_api_request'] ) ) {
				return $GLOBALS['__itsec_core_is_rest_api_request'];
			}

			if ( ! function_exists( 'rest_get_url_prefix' ) ) {
				$GLOBALS['__itsec_core_is_rest_api_request'] = false;

				return false;
			}

			if ( defined( 'REST_REQUEST' ) && REST_REQUEST ) {
				$GLOBALS['__itsec_core_is_rest_api_request'] = true;

				return true;
			}

			$home_path = parse_url( get_option( 'home' ), PHP_URL_PATH ) ?: '';
			$home_path = trim( $home_path, '/' );

			if ( '' === $home_path ) {
				$rest_api_path = '/' . rest_get_url_prefix() . '/';
			} else {
				$rest_api_path = "/$home_path/" . rest_get_url_prefix() . '/';
			}

			if ( 0 === strpos( $_SERVER['REQUEST_URI'], $rest_api_path ) ) {
				$GLOBALS['__itsec_core_is_rest_api_request'] = true;
			} else {
				$GLOBALS['__itsec_core_is_rest_api_request'] = false;
			}

			return $GLOBALS['__itsec_core_is_rest_api_request'];
		}

		/**
		 * Is this a request to wp-admin/admin-post.php?
		 *
		 * @return bool
		 */
		public static function is_admin_post_php_request() {
			if ( 'wp-admin/admin-post.php' === ITSEC_Lib::get_request_path() ) {
				return true;
			}

			return false;
		}

		/**
		 * Is the current request being made by a WordPress API.
		 *
		 * @param bool $include_ajax           Whether to include Ajax requests as a subset of API requests.
		 * @param bool $include_admin_post_php Whether to include wp-admin/admin-post.php requests as a subset of API
		 *                                     requests.
		 *
		 * @return bool
		 */
		public static function is_api_request( $include_ajax = true, $include_admin_post_php = true ) {
			if ( $include_ajax && self::is_ajax_request() ) {
				return true;
			}

			if ( $include_admin_post_php && self::is_admin_post_php_request() ) {
				return true;
			}

			if ( self::is_rest_api_request() || self::is_xmlrpc_request() ) {
				return true;
			}

			return false;
		}

		/**
		 * Checks if Solid Security is in development mode.
		 *
		 * @return bool
		 */
		public static function is_development() {
			return defined( 'ITSEC_DEVELOPMENT' ) && ITSEC_DEVELOPMENT;
		}

		/**
		 * Check to see if the define to disable all active modules is set.
		 *
		 * Note that the ITSEC_DISABLE_MODULES should only be used to gain access to a site that you are locked out of.
		 * Once logged in, you should remove the define to re-enable the protections offered by Solid Security.
		 *
		 * @return bool true if the define is set to a truthy value, false otherwise.
		 */
		public static function is_temp_disable_modules_set() {
			if ( defined( 'ITSEC_DISABLE_MODULES' ) && ITSEC_DISABLE_MODULES ) {
				return true;
			}

			return false;
		}

		/**
		 * Get the actual version string of the plugin.
		 *
		 * This should be used rarely. Any decision flows based off a "version" should be made using the Plugin Build.
		 *
		 * @return string
		 */
		public static function get_plugin_version() {
			$self = self::get_instance();

			if ( ! isset( $self->version ) ) {
				$data = get_file_data( $self->plugin_file, array(
					'Version' => 'Version'
				) );

				$self->version = $data['Version'];
			}

			return $self->version;
		}

		/**
		 * Checks if Security was loaded as a mu-plugin.
		 *
		 * @return bool
		 */
		public static function is_loading_early(): bool {
			return self::get_instance()->load_early;
		}

		/**
		 * Gets the PHP version that is going to be required soon.
		 *
		 * @return string
		 */
		public static function get_next_php_requirement(): string {
			return '7.3.0';
		}

		/**
		 * Gets the UTM campaign based on the Install Type.
		 *
		 * @return string
		 */
		public static function get_utm_campaign(): string {
			return self::is_pro() ? 'itsecprocta' : 'itsecfreecta';
		}

		/**
		 * Gets a link configured for Google Analytics tracking.
		 *
		 * @param string $link
		 * @param string $source
		 * @param string $medium
		 *
		 * @return string
		 */
		public static function get_tracking_link( string $link, string $source, string $medium ): string {
			return add_query_arg( [
				'utm_source'   => $source,
				'utm_medium'   => $medium,
				'utm_campaign' => self::get_utm_campaign(),
			], $link );
		}

		public static function is_test_suite( $suite = '' ) {
			if ( ! defined( 'ITSEC_TEST_SUITE' ) ) {
				return false;
			}

			return $suite ? ITSEC_TEST_SUITE === $suite : true;
		}
	}
}