<?php
// @codingStandardsIgnoreStart
/*
Plugin Name: Easy Updates Manager
Plugin URI: https://easyupdatesmanager.com
Description: Manage and disable WordPress updates, including core, plugin, theme, and automatic updates - Works with Multisite and has built-in logging features.
Author: Easy Updates Manager Team
Version: 9.0.20
Update URI: https://wordpress.org/plugins/stops-core-theme-and-plugin-updates/
Author URI: https://easyupdatesmanager.com
Contributors: kidsguide, ronalfy
Text Domain: stops-core-theme-and-plugin-updates
Domain Path: /languages
Updates: true
Network: true
*/
// @codingStandardsIgnoreEnd

if (!defined('ABSPATH')) die('No direct access allowed');

if (!defined('EASY_UPDATES_MANAGER_VERSION')) define('EASY_UPDATES_MANAGER_VERSION', '9.0.20');

if (!defined('EASY_UPDATES_MANAGER_MAIN_PATH')) define('EASY_UPDATES_MANAGER_MAIN_PATH', plugin_dir_path(__FILE__));
if (!defined('EASY_UPDATES_MANAGER_URL')) define('EASY_UPDATES_MANAGER_URL', plugin_dir_url(__FILE__));
if (!defined('EASY_UPDATES_MANAGER_SITE_URL')) define('EASY_UPDATES_MANAGER_SITE_URL', 'https://easyupdatesmanager.com/');
if (!defined('EASY_UPDATES_MANAGER_SLUG')) define('EASY_UPDATES_MANAGER_SLUG', plugin_basename(__FILE__));

if (!class_exists('MPSUM_Updates_Manager')) {
	/**
	 * Main plugin class
	 *
	 * Initializes auto-loader, internationalization, and plugin dependencies.
	 */
	class MPSUM_Updates_Manager {

		/**
		 * Holds the class instance.
		 *
		 * @since 5.0.0
		 * @access static
		 * @var MPSUM_Updates_Manager $instance
		 */
		private static $instance = null;

		/**
		 * Stores the plugin's options
		 *
		 * @since 5.0.0
		 * @access static
		 * @var array $options
		 */
		private static $options = false;

		/**
		 * Template directories
		 *
		 * @var string
		 */
		private $template_directories;

		/**
		 * Notice class instance
		 *
		 * @var object
		 */
		protected static $notices_instance = null;

		// Minimum PHP version required to run this plugin
		const PHP_REQUIRED = '5.4';
		// Minimum WP version required to run this plugin
		const WP_REQUIRED = '5.1';

		/**
		 * Retrieve a class instance.
		 *
		 * Retrieve a class instance.
		 *
		 * @since 5.0.0
		 * @access static
		 *
		 * @return MPSUM_Updates_Manager Instance of the class.
		 */
		public static function get_instance() {
			if (null == self::$instance) {
				self::$instance = new self;
			}
			return self::$instance;
		} //end get_instance

		/**
		 * Retrieve the plugin basename.
		 *
		 * Retrieve the plugin basename.
		 *
		 * @since 5.0.0
		 * @access static
		 *
		 * @return string plugin basename
		 */
		public static function get_plugin_basename() {
			return EASY_UPDATES_MANAGER_SLUG;
		}

		/**
		 * Get the WordPress version
		 *
		 * @return String - the version
		 */
		public function get_wordpress_version() {
			static $got_wp_version = false;
			if (!$got_wp_version) {
				global $wp_version;
				@include(ABSPATH.WPINC.'/version.php');
				$got_wp_version = $wp_version;
			}
			return $got_wp_version;
		}


		/**
		 * Class constructor.
		 *
		 * Set up internationalization, auto-loader, and plugin initialization.
		 *
		 * @since 5.0.0
		 * @access private
		 */
		private function __construct() {
			$has_errors = false;

			if (version_compare(PHP_VERSION, self::PHP_REQUIRED, '<')) {
				add_action('admin_notices', array($this, 'admin_notice_insufficient_php'));
				if (is_multisite()) {
					add_action('network_admin_notices', array($this, 'admin_notice_insufficient_php'));
				}
				$has_errors = true;
			}

			include ABSPATH.WPINC.'/version.php';
			if (version_compare($wp_version, self::WP_REQUIRED, '<')) {// phpcs:ignore VariableAnalysis.CodeAnalysis.VariableAnalysis.UndefinedVariable
				add_action('admin_notices', array($this, 'admin_notice_insufficient_wp'));
				if (is_multisite()) {
					add_action('network_admin_notices', array($this, 'admin_notice_insufficient_wp'));
				}
				$has_errors = true;
			}
			if (!$has_errors) {
				spl_autoload_register(array($this, 'loader'));
				add_action('init', array($this, 'init'));
				add_action('plugins_loaded', array($this, 'plugins_loaded'));
				add_action('admin_init', array($this, 'admin_init'));
				add_action('wp_ajax_easy_updates_manager_ajax', array($this, 'easy_updates_manager_ajax_handler'));
				new MPSUM_UpdraftCentral();
				register_deactivation_hook(__FILE__, array($this, 'deactivation_hook'));
			}
		} //end constructor

		/**
		 * Run code during the init action.
		 *
		 * Run code during the init action.
		 *
		 * @since 6.2.5
		 * @access public
		 */
		public function init() {
			/* Localization Code */
			load_plugin_textdomain('stops-core-theme-and-plugin-updates', false, dirname(plugin_basename(__FILE__)) . '/languages/');

			// Logging
			$options = MPSUM_Updates_Manager::get_options('core');
			if (!isset($options['logs']) || 'off' === $options['logs']) { // As of 8.1.0, the `Enable Logs` button is no longer used, hence we need to ensure the 'logs' option is always turned on
				$options['logs'] = 'on';
				MPSUM_Updates_Manager::update_options($options, 'core');
			}
			if (!$this->is_premium() && 'on' === $options['logs']) {
				MPSUM_Logs::run();
			}

			$options = MPSUM_Updates_Manager::get_options();
			if (!isset($options['migrated_from_9_0_9'])) {
				if (isset($options['core']['core_updates'])) {
					switch ($options['core']['core_updates']) {
						case 'disable_auto_updates_migrated_from_9_0_9':
							$options['core']['core_updates'] = 'on'; // 'on' is for 'Manually update', it's different with 'automatic', since 'automatic_off' (disable auto updates) and 'on' is basically the same, so we use 'on' instead and remove the 'automatic_off', also the UI.
							break;
						case 'manually_update_migrated_from_9_0_9':
							$options['core']['core_updates'] = 'automatic_minor';
							break;
						default:
							break;
					}
				}
				$options['migrated_from_9_0_9'] = true;
				MPSUM_Updates_Manager::update_options($options);
			}
			MPSUM_Admin_Ajax::get_instance();
		}

		/**
		 * Return the absolute path to an asset.
		 *
		 * Return the absolute path to an asset based on a relative argument.
		 *
		 * @since 5.0.0
		 * @access static
		 *
		 * @param string $path Relative path to the asset.
		 * @return string Absolute path to the relative asset.
		 */
		public static function get_plugin_dir($path = '') {
			$dir = rtrim(plugin_dir_path(__FILE__), '/');
			if (!empty($path) && is_string($path))
				$dir .= '/' . ltrim($path, '/');
			return $dir;
		}

		/**
		 * Unserialize data while maintaining compatibility across PHP versions due to different number of arguments required by PHP's "unserialize" function
		 *
		 * @param string        $serialized_data Data to be unserialized, should be one that is already serialized
		 * @param boolean|array $allowed_classes Either an array of class names which should be accepted, false to accept no classes, or true to accept all classes
		 * @param integer       $max_depth       The maximum depth of structures permitted during unserialization, and is intended to prevent stack overflows
		 * @return mixed Unserialized data can be any of types (integer, float, boolean, string, array or object)
		 */
		public static function unserialize($serialized_data, $allowed_classes = false, $max_depth = 0) {
			static $polyfill_unserialize_loaded = false;
			if (version_compare(PHP_VERSION, '5.2', '<=')) {
				$result = unserialize($serialized_data); // For PHP 5.2 users, the search-replace feature has been removed, meaning that any input provided in this context will not undergo search-replace processing.
			} else {
				if (!$polyfill_unserialize_loaded) {
					if (!class_exists('Brumann\Polyfill\DisallowedClassesSubstitutor')) {
						include_once(EASY_UPDATES_MANAGER_MAIN_PATH.'vendor/brumann/polyfill-unserialize/src/DisallowedClassesSubstitutor.php');
					}
					
					if (!class_exists('Brumann\Polyfill\Unserialize')) {
						include_once(EASY_UPDATES_MANAGER_MAIN_PATH.'vendor/brumann/polyfill-unserialize/src/Unserialize.php');
						$polyfill_unserialize_loaded = true;
					}
				}

				$result = call_user_func(
					array('Brumann\Polyfill\Unserialize', 'unserialize'),
					$serialized_data,
					array(
						'allowed_classes' => $allowed_classes,
						'max_depth'       => $max_depth,
					)
				);
			}
			return $result;
		}
		
		/**
		 * Return the web path to an asset.
		 *
		 * Return the web path to an asset based on a relative argument.
		 *
		 * @since 5.0.0
		 * @access static
		 *
		 * @param string $path Relative path to the asset.
		 * @return string Web path to the relative asset.
		 */
		public static function get_plugin_url($path = '') {
			$dir = rtrim(plugin_dir_url(__FILE__), '/');
			if (!empty($path) && is_string($path))
				$dir .= '/' . ltrim($path, '/');
			return $dir;
		}

		/**
		 * Retrieve the plugin's options
		 *
		 * Retrieve the plugin's options based on context
		 *
		 * @since 5.0.0
		 * @access static
		 *
		 * @param  string $context      Context to retrieve options for.	 This is used as an array key.
		 * @param  bool	  $force_reload Whether to retrieve cached options or forcefully retrieve from the database.
		 * @return array All options if no context, or associative array if context is set.	 Empty array if no options.
		 */
		public static function get_options($context = '', $force_reload = false) {
			// Try to get cached options
			$options = self::$options;
			if (false === $options || true === $force_reload) {
				$options = get_site_option('MPSUM', false);
			}

			if (false === $options) {
				$options = self::maybe_migrate_options();
			}

			// Store options
			if (!is_array($options)) { // this may indicate that the plugin is being activated the first time or it's not a migration from the older versions
				$options = array();
			}

			if ('advanced' === $context) {
				$options = self::maybe_migrate_excluded_users_options($options);
			}

			// Migrate to new UI
			$options = self::maybe_migrate_ui_options($options);

			// Assign options for caching
			self::$options = $options;

			// Attempt to get context
			if (!empty($context) && is_string($context)) {
				if (array_key_exists($context, $options)) {
					return (array) $options[$context];
				} else {
					return array();
				}
			}

			return $options;
		} //get_options

		/**
		 * Auto-loads classes.
		 *
		 * Auto-load classes that belong to this plugin.
		 *
		 * @since 5.0.0
		 * @access private
		 *
		 * @param string $class_name The name of the class.
		 */
		private function loader($class_name) {
			if (class_exists($class_name, false) || false === strpos($class_name, 'MPSUM')) {
				return;
			}
			$file = MPSUM_Updates_Manager::get_plugin_dir("includes/{$class_name}.php");
			if (file_exists($file)) {
				include_once($file);
			}
		}

		/**
		 * Determine whether to migrate options from an older version of the plugin.
		 *
		 * Migrate old options to new plugin format.
		 *
		 * @since 5.0.0
		 * @access private
		 *
		 * @return bool|array  false if no migration, associative array of options if migration successful
		 */
		public static function maybe_migrate_options() {
			$options = false;
			$original_options = get_option('_disable_updates', false);

			if (false !== $original_options && is_array($original_options)) {
				$options = array(
					'core' => array(),
					'plugins' => array(),
					'themes' => array()
				);
				// Global WP Updates
				if (isset($original_options['all']) && "1" === $original_options['all']) {
					$options['core']['all_updates'] = 'off';
				}
				// Global Plugin Updates
				if (isset($original_options['plugin']) && "1" === $original_options['plugin']) {
					$options['core']['plugin_updates'] = 'off';
				}
				// Global Theme Updates
				if (isset($original_options['theme']) && "1" === $original_options['theme']) {
					$options['core']['theme_updates'] = 'off';
				}
				// Global Core Updates
				if (isset($original_options['core']) && "1" === $original_options['core']) {
					$options['core']['core_updates'] = 'off';
				}
				// Global Individual Theme Updates
				if (isset($original_options['it']) && "1" === $original_options['it']) {
					if (isset($original_options['themes']) && is_array($original_options['themes'])) {
						$options['themes'] = $original_options['themes'];
					}
				}
				// Global Individual Plugin Updates
				if (isset($original_options['ip']) && "1" === $original_options['ip']) {
					if (isset($original_options['plugins']) && is_array($original_options['plugins'])) {
						$options['plugins'] = $original_options['plugins'];
					}
				}
				// Browser Nag
				if (isset($original_options['bnag']) && "1" === $original_options['bnag']) {
					$options['core']['misc_browser_nag'] = 'off';
				}
				// WordPress Version
				if (isset($original_options['wpv']) && "1" === $original_options['wpv']) {
					$options['core']['misc_wp_footer'] = 'off';
				}
				// Translation Updates
				if (isset($original_options['auto-translation-updates']) && "1" === $original_options['auto-translation-updates']) {
					$options['core']['automatic_translation_updates'] = 'off';
				}
				// Translation Updates
				if (isset($original_options['auto-core-emails']) && "1" === $original_options['auto-core-emails']) {
					$options['core']['notification_core_update_emails'] = 'off';
				}
				// Automatic Updates
				if (isset($original_options['abup']) && "1" === $original_options['abup']) {
					$options['core']['automatic_major_updates'] = 'off';
					$options['core']['automatic_minor_updates'] = 'off';
					$options['core']['automatic_plugin_updates'] = 'off';
					$options['core']['automatic_theme_updates'] = 'off';
				}

				delete_option('_disable_updates');
				delete_site_option('_disable_updates');
				MPSUM_Updates_Manager::update_options($options);
			}
			return $options;
		}

		/**
		 * Migrates from the legacy UI options to the new UI options.
		 *
		 * @param array $options Array of plugin options
		 *
		 * @return array Updated array of plugin options
		 */
		public static function maybe_migrate_ui_options($options) {

			$new_options = array();
			// Migrate WordPress Core options.
			if (isset($options['core']['automatic_major_updates']) && isset($options['core']['automatic_minor_updates'])) {
				if ('on' === $options['core']['automatic_major_updates'] && 'on' === $options['core']['automatic_minor_updates']) {
					$new_options['core']['core_updates'] = 'automatic';
				} elseif ('on' === $options['core']['automatic_minor_updates']) {
					$new_options['core']['core_updates'] = 'automatic_minor';
				} elseif ('on' === $options['core']['automatic_major_updates']) {
					$new_options['core']['core_updates'] = 'automatic';
				} elseif ('off' === $options['core']['automatic_major_updates'] || 'off' === $options['core']['automatic_minor_updates']) {
					$new_options['core']['core_updates'] = 'on'; // 'on' is for 'Manually update', it's different with 'automatic', since 'automatic_off' and 'on' is basically the same, so we use 'on' instead and remove the 'automatic_off', also the UI.
				}
				unset($options['core']['automatic_major_updates']);
			}
			if (isset($options['core']['core_updates']) && 'off' === $options['core']['core_updates']) {
				$new_options['core']['core_updates'] = 'off';
			} elseif (!isset($options['migrated_from_9_0_9']) && isset($options['core']['core_updates']) && 'automatic_off' === $options['core']['core_updates']) {
				$new_options['core']['core_updates'] = 'disable_auto_updates_migrated_from_9_0_9';
			} elseif (!isset($options['migrated_from_9_0_9']) && isset($options['core']['core_updates']) && 'on' === $options['core']['core_updates']) {
				// the 'Manually update (on)' setting doesn't do automatic minor updates anymore, so we change users' preference whose setting is set to 'Manually update' to becoming 'automatic_minor' (Auto update all minor versions)
				$new_options['core']['core_updates'] = 'manually_update_migrated_from_9_0_9';
			}
			if (isset($new_options['core']['core_updates'])) {
				$options['core']['core_updates'] = $new_options['core']['core_updates'];
			}

			// Migrate Plugin Options.
			if (isset($options['core']['automatic_plugin_updates'])) {
				if ('on' === $options['core']['automatic_plugin_updates']) {
					$new_options['core']['plugin_updates'] = 'automatic';
				} elseif ('custom' === $options['core']['automatic_plugin_updates']) {
					$new_options['core']['plugin_updates'] = 'individual';
				} elseif ('off' === $options['core']['automatic_plugin_updates']) {
					$new_options['core']['plugin_updates'] = 'automatic_off';
				}
				unset($options['core']['automatic_plugin_updates']);
			}
			if (isset($options['core']['plugin_updates']) && 'off' === $options['core']['plugin_updates']) {
				$new_options['core']['plugin_updates'] = 'off';
			}
			if (isset($new_options['core']['plugin_updates'])) {
				$options['core']['plugin_updates'] = $new_options['core']['plugin_updates'];
			}

			// Migrate Theme Options.
			if (isset($options['core']['automatic_theme_updates'])) {
				if ('on' === $options['core']['automatic_theme_updates']) {
					$new_options['core']['theme_updates'] = 'automatic';
				} elseif ('custom' === $options['core']['automatic_theme_updates']) {
					$new_options['core']['theme_updates'] = 'individual';
				} elseif ('off' === $options['core']['automatic_theme_updates']) {
					$new_options['core']['theme_updates'] = 'automatic_off';
				}
				unset($options['core']['automatic_theme_updates']);
			}
			if (isset($options['core']['theme_updates']) && 'off' === $options['core']['theme_updates']) {
				$new_options['core']['theme_updates'] = 'off';
			}
			if (isset($new_options['core']['theme_updates'])) {
				$options['core']['theme_updates'] = $new_options['core']['theme_updates'];
			}

			// Migrate Translation Options.
			if (isset($options['core']['automatic_translation_updates'])) {
				if ('on' === $options['core']['automatic_translation_updates']) {
					$new_options['core']['translation_updates'] = 'automatic';
				} elseif ('off' === $options['core']['automatic_translation_updates']) {
					$new_options['core']['translation_updates'] = 'on'; // After 9.0.12 version, translation 'Disable auto updates' is removed and is united to 'Manually update' as they are just the same
				}
				unset($options['core']['automatic_translation_updates']);
			}
			if (isset($options['core']['translation_updates']) && 'off' === $options['core']['translation_updates']) {
				$new_options['core']['translation_updates'] = 'off';
			} elseif (isset($options['core']['translation_updates']) && 'automatic_off' ===  $options['core']['translation_updates']) { // After 9.0.12 version, translation 'Disable auto updates' is removed and is united to 'Manually update' as they are just the same
				$new_options['core']['translation_updates'] = 'on';
			}
			if (isset($new_options['core']['translation_updates'])) {
				$options['core']['translation_updates'] = $new_options['core']['translation_updates'];
			}

			return $options;
		}

		/**
		 * Migrates `excluded_users` option to `advanced` context
		 *
		 * @param array $options Array of plugin options
		 *
		 * @return array Updated array of plugin options
		 */
		public static function maybe_migrate_excluded_users_options($options) {
			if (isset($options['advanced']['excluded_users'])) {
				if (isset($options['excluded_usders'])) {
					unset($options['excluded_users']);
				}
				return $options;
			}
			if (isset($options['excluded_users'])) {
				$options['advanced']['excluded_users'] = $options['excluded_users'];
				unset($options['excluded_users']);
			} elseif (isset($options['advanced']['excluded_users']) && isset($options['excluded_users'])) {
				$options['advanced']['excluded_users'] = $options['excluded_users'];
			} else {
				$options = array_merge(array('advanced' => array('excluded_users' => array())), $options);
			}
			return $options;
		}

		/**
		 * Initialize the plugin and its dependencies.
		 *
		 * Initialize the plugin and its dependencies.
		 *
		 * @since 5.0.0
		 * @access public
		 * @see __construct
		 * @internal Uses plugins_loaded action
		 */
		public function plugins_loaded() {

			// Skip disable updates if a user is excluded
			$disable_updates_skip = false;
			if (current_user_can('update_plugins')) {
				$current_user = wp_get_current_user();
				$current_user_id = $current_user->ID;
				$advanced_options = MPSUM_Updates_Manager::get_options('advanced');
				$excluded_users = isset($advanced_options['excluded_users']) ? $advanced_options['excluded_users'] : array();
				if (in_array($current_user_id, $excluded_users)) {
					$disable_updates_skip = true;
				}
			}
			if (false === $disable_updates_skip) {
				MPSUM_Disable_Updates::run();
			}

			$not_doing_ajax = (!defined('DOING_AJAX') || !DOING_AJAX);
			$not_admin_disabled = true;
			if (defined('MPSUM_DISABLE_ADMIN')) {
				$not_admin_disabled = MPSUM_DISABLE_ADMIN ? false : true;
			}
			if (current_user_can('manage_options') && $not_doing_ajax && $not_admin_disabled && !$disable_updates_skip) {
				MPSUM_Admin::run();
			}
			$this->check_premium();
		}

		/**
		 * Checks if this is the premium version and loads it. It also ensures that if the free version is installed then it is disabled with an appropriate error message.
		 *
		 *  @returns true if premium, false if not
		 */
		private function check_premium() {

			// Run Premium loader if it exists
			if (file_exists(EASY_UPDATES_MANAGER_MAIN_PATH . 'premium.php') && !class_exists('MPSUM_Premium')) {
				include_once(EASY_UPDATES_MANAGER_MAIN_PATH . 'premium.php');
			}

			$utils = MPSUM_Utils::get_instance();
			$utils->maybe_deactivate_free_version();
		}

		/**
		 * This is a notice to show users that premium is installed
		 */
		public function show_admin_notice_premium() {
			echo '<div id="eum-premium-installed-warning" class="error"><p>'.esc_html__('Easy Updates Manager (Free) has been de-activated, because Easy Updates Manager Premium is active.', 'stops-core-theme-and-plugin-updates').'</p></div>';
			// phpcs:ignore WordPress.Security.NonceVerification.Recommended -- Nonce verification not required as we are only unsetting a query parameter.
			if (isset($_GET['activate'])) unset($_GET['activate']);
		}

		/**
		 * Checks whether this is premium plugin or not
		 *
		 * @return Boolean - returns true if premium otherwise false
		 */
		public function is_premium() {
			if (file_exists(__DIR__ . '/premium.php')) return true;
			return false;
		}

		/**
		 * Save plugin options.
		 *
		 * Saves the plugin options based on context.  If no context is provided, updates all options.
		 *
		 * @since 5.0.0
		 * @access static
		 *
		 * @param array	 $options Associative array of plugin options.
		 * @param string $context Array key of which options to update
		 */
		public static function update_options($options = array(), $context = '') {
			$options_to_save = self::get_options();

			if (!empty($context) && is_string($context)) {
				$options_to_save[$context] = $options;
			} else {
				$options_to_save = $options;
			}
			if (is_multisite()) {
				update_site_option('MPSUM', $options_to_save);
			} else {
				update_option('MPSUM', $options_to_save);
			}
			self::$options = $options_to_save;
		}

		/**
		 * Saves option based on single site / multi site setup
		 *
		 * @param string $option Option key to be updated
		 * @param mixed  $value  Option value to be updated
		 */
		public static function update_option($option, $value) {
			if (is_multisite()) {
				update_site_option($option, $value);
			} else {
				update_option($option, $value);
			}
		}

		/**
		 * Get object of Easy_Updates_Manager_Notices
		 *
		 * @return object object of Easy_Updates_Manager_Notices
		 */
		public static function get_notices() {
			if (empty(self::$notices_instance)) {
				if (!class_exists('Easy_Updates_Manager_Notices')) include_once(EASY_UPDATES_MANAGER_MAIN_PATH.'includes/easy-updates-manager-notices.php');
				self::$notices_instance = new Easy_Updates_Manager_Notices();
			}
			return self::$notices_instance;
		}

		/**
		 * Gets an array of plugins active on either the current site, or site-wide
		 *
		 * @return array - a list of plugin paths (relative to the plugin directory)
		 */
		private function get_active_plugins() {

			// Gets all active plugins on the current site
			$active_plugins = get_option('active_plugins');

			if (is_multisite()) {
				$network_active_plugins = get_site_option('active_sitewide_plugins');
				if (!empty($network_active_plugins)) {
					$network_active_plugins = array_keys($network_active_plugins);
					$active_plugins = array_merge($active_plugins, $network_active_plugins);
				}
			}

			return $active_plugins;
		}

		/**
		 * This function checks whether a specific plugin is installed, and returns information about it
		 *
		 * @param  string $name Specify "Plugin Name" to return details about it.
		 * @return array        Returns an array of details such as if installed, the name of the plugin and if it is active.
		 */
		public function is_installed($name) {

			// Needed to have the 'get_plugins()' function
			if (!function_exists('get_plugins')) {
				include_once(ABSPATH.'wp-admin/includes/plugin.php');
			}

			// Gets all plugins available
			$get_plugins = get_plugins();

			$active_plugins = $this->get_active_plugins();
			$plugin_info = array();
			$plugin_info['installed'] = false;
			$plugin_info['active'] = false;


			// Loops around each plugin available.
			foreach ($get_plugins as $key => $value) {
				// If the plugin name matches that of the specified name, it will gather details.
				if ($value['Name'] != $name) continue;
				$plugin_info['installed'] = true;
				$plugin_info['name'] = $key;
				$plugin_info['version'] = $value['Version'];
				if (in_array($key, $active_plugins)) {
					$plugin_info['active'] = true;
				}
				break;
			}
			return $plugin_info;
		}

		/**
		 * Adds actions which fired on admin_init action hook
		 *
		 * @return void
		 */
		public function admin_init() {
			global $plugin_page;
			$pagenow = $GLOBALS['pagenow'];

			$this->register_template_directories();

			// Check for WP Constants that disable updates and display a notice.
			$prohibited_active_constants = MPSUM_Constant_Checks::get_instance()->get_prohibited_active_constants();
			$upgrade_constant_notice = get_site_option('easy_updates_manager_dismiss_constant_notices', array());
			if (!is_array($upgrade_constant_notice)) $upgrade_constant_notice = array();
			$prohibited_active_constants = array_diff($prohibited_active_constants, $upgrade_constant_notice);
			if (!empty($prohibited_active_constants)) {
				if ('mpsum-update-options' === $plugin_page || current_user_can($this->capability_required())) add_action('all_admin_notices', array($this, 'show_autoupdate_constant_warning'));
			}

			// Add filters to overwrite auto update UI in WP 5.5
			add_filter('plugin_auto_update_setting_html', array($this, 'eum_plugin_auto_update_setting_html'), 10, 3);
			add_filter('theme_auto_update_setting_html', array($this, 'eum_theme_auto_update_setting_html'), 10, 3);
			add_filter('theme_auto_update_setting_template', array($this, 'eum_auto_update_setting_template'));

			if ('index.php' != $pagenow) return;
			if (current_user_can('update_plugins') || (defined('EASY_UPDATES_MANAGER_FORCE_DASHNOTICE') && EASY_UPDATES_MANAGER_FORCE_DASHNOTICE)) {
				$dismissed_until = get_site_option('easy_updates_manager_dismiss_dash_notice_until', 0);
				if (isset($_GET['page']) && 'mpsum-update-options' == $_GET['page']) { // phpcs:ignore WordPress.Security.NonceVerification.Recommended -- Nonce verification is not required as we are only retrieving the admin page slug.
					$dismissed_until = get_site_option('easy_updates_manager_dismiss_eum_notice_until', 0);
				}
				$installed = $installed_for = true;
				if (file_exists(EASY_UPDATES_MANAGER_MAIN_PATH . 'index.html')) {
					$installed = filemtime(EASY_UPDATES_MANAGER_MAIN_PATH . 'index.html');
					$installed_for = (time() - $installed);
				}
				$is_eum_admin = false;
				if (isset($_GET['page']) && 'mpsum-update-options' === $_GET['page']) { // phpcs:ignore WordPress.Security.NonceVerification.Recommended -- Nonce verification is not required as we are only retrieving the admin page slug.
					$is_eum_admin = true;
				}
				if (!$is_eum_admin) {
					if (current_user_can($this->capability_required())) add_action('all_admin_notices', array($this, 'maybe_show_admin_notice_upgraded'));
				}

				if (!$is_eum_admin) return;
				if (($installed && time() > $dismissed_until && $installed_for < (14 * 86400) && !defined('EASY_UPDATES_MANAGER_NOADS_B')) || (defined('EASY_UPDATES_MANAGER_FORCE_DASHNOTICE') && EASY_UPDATES_MANAGER_FORCE_DASHNOTICE)) {
					add_action('all_admin_notices', array($this, 'show_admin_notice_upgraded'));
				} else {
					$enable_notices = get_site_option('easy_updates_manager_enable_notices', 'on');
					if ('on' === $enable_notices) {
						add_action('all_admin_notices', array($this->get_notices(), 'do_notice'));
					}
				}
			}
		}

		/**
		 * This function will overwrite the default auto update UI on the plugins page in the WordPress dashboard in WordPress 5.5+, depending on the options setup in EUM will depend on the output
		 *
		 * @param string $html        - the HTML to filter
		 * @param string $plugin_file - the plugin file the HTML is for
		 * @return string - the filtered HTML auto update UI
		 */
		public function eum_plugin_auto_update_setting_html($html, $plugin_file) {
			return $this->eum_entity_auto_update_setting_html($html, 'plugin', $plugin_file, false);
		}

		/**
		 * This function will overwrite the default auto update UI on the themes page on a multisite in the WordPress dashboard in WordPress 5.5+, depending on the options setup in EUM will depend on the output
		 *
		 * @param string $html       - the HTML to filter
		 * @param string $stylesheet - the theme file the HTML is for
		 * @return string - the filtered HTML auto update UI
		 */
		public function eum_theme_auto_update_setting_html($html, $stylesheet) {
			return $this->eum_entity_auto_update_setting_html($html, 'theme', $stylesheet, false);
		}

		/**
		 * This function will overwrite the default auto update UI on the themes page for single sites in the WordPress dashboard in WordPress 5.5+ depending on the options setup in EUM will depend on the output
		 *
		 * @param string $template - the theme template
		 *
		 * @return string - returns a filtered theme template
		 */
		public function eum_auto_update_setting_template($template) {
			return $this->eum_entity_auto_update_setting_html($template, 'theme', '', true);
		}

		/**
		 * This function will overwrite the default auto update UI on the passed in entity page for single and multi sites in the WordPress dashboard in WordPress 5.5+ depending on the options setup in EUM will depend on the output
		 *
		 * @param string  $html        - the HTML to filter
		 * @param string  $entity      - the entity type (theme/plugin)
		 * @param string  $entity_file - the entity file the HTML is for
		 * @param boolean $template    - if this should be returned in template format or not (single site themes currently uses this)
		 *
		 * @return string - returns a filtered HTML string or template
		 */
		private function eum_entity_auto_update_setting_html($html, $entity, $entity_file, $template) {
			$entity_option = 'plugin' == $entity ? 'plugins' : 'themes';
			$core_options = MPSUM_Updates_Manager::get_options('core');
			$entity_options = MPSUM_Updates_Manager::get_options($entity_option);
			$entity_automatic_options = MPSUM_Updates_Manager::get_options($entity_option.'_automatic');
			$url = MPSUM_Admin::get_url();
			
			// Allow white-labelling
			$eum_white_label = apply_filters('eum_whitelabel_name', __('Easy Updates Manager', 'stops-core-theme-and-plugin-updates'));

			if (!isset($core_options['plugin_updates']) || !isset($core_options['theme_updates'])) {
				/* translators: %s: Label Name */
				$html = '<a href="'.$url.'">'.sprintf(__('Managed by %s.', 'stops-core-theme-and-plugin-updates'), $eum_white_label).'</a>';
				return $html;
			}

			$updates = 'plugin' == $entity ? $core_options['plugin_updates'] : $core_options['theme_updates'];

			if ('automatic' == $updates) {
				/* translators: %s: Label Name */
				$html = '<a href="'.$url.'">'.sprintf(__('Managed by %s.', 'stops-core-theme-and-plugin-updates'), $eum_white_label).'</a>';
				if ($template) return $html;
			} elseif ('on' == $updates) {
				/* Translators: 1: Label Name, 2: on */
				$html = '<a href="'.$url.'">'.sprintf(__('Managed by %1$s (%2$s).', 'stops-core-theme-and-plugin-updates'), $eum_white_label, __('on', 'stops-core-theme-and-plugin-updates')).'</a>';
				if ($template) return $html;
			} elseif ('off' == $updates) {
				/* translators: %s: Label Name */
				$html = '<a href="'.$url.'">'.sprintf(__('Disabled in %s.', 'stops-core-theme-and-plugin-updates'), $eum_white_label).'</a>';
				if ($template) return $html;
			} elseif ('automatic_off' == $updates) {
				/* translators: %s: Label Name */
				$html = '<a href="'.$url.'">'.sprintf(__('Disabled in %s.', 'stops-core-theme-and-plugin-updates'), $eum_white_label).'</a>';
				if ($template) return $html;
			} elseif ('individual' == $updates && !$template) {
				
				/* translators: %s: Label Name */
				$html = '<a href="'.$url.'">'.sprintf(__('Managed by %s.', 'stops-core-theme-and-plugin-updates'), $eum_white_label).'</a>';

				if (!empty($entity_options)) {
					foreach ($entity_options as $ent) {
						/* translators: %s: Label Name */
						if ($ent == $entity_file) $html = '<a href="'.$url.'">'.sprintf(__('Disabled in %s.', 'stops-core-theme-and-plugin-updates'), $eum_white_label).'</a>';
					}
				}

				if (!empty($entity_automatic_options)) {
					foreach ($entity_automatic_options as $ent) {
						/* translators: %s: Label Name */
						if ($ent == $entity_file) $html = '<a href="'.$url.'">'.sprintf(__('Managed by %s.', 'stops-core-theme-and-plugin-updates'), $eum_white_label).'</a>';
					}
				}
			} elseif ('individual' == $updates && $template) {
				
				$entity_options_string = '';
				$entity_automatic_options_string = '';
				$entity_options_html = '';
				$entity_automatic_options_html = '';

				if (!empty($entity_options)) {
					$last = count($entity_options) - 1;
					foreach ($entity_options as $key => $ent) {
						$entity_options_string .= "'".$ent."'";
						if ($last != $key) $entity_options_string .= ',';
					}
					/* translators: %s: Label Name */
					$entity_options_html = '<a href="'.$url.'">'.sprintf(__('Disabled in %s.', 'stops-core-theme-and-plugin-updates'), $eum_white_label).'</a>';
				}

				if (!empty($entity_automatic_options)) {
					$last = count($entity_automatic_options) - 1;
					foreach ($entity_automatic_options as $key => $theme) {
						$entity_automatic_options_string .= "'".$theme."'";
						if ($last != $key) $entity_automatic_options_string .= ',';
					}
					/* translators: %s: Label Name */
					$entity_automatic_options_html = '<a href="'.$url.'">'.sprintf(__('Managed by %s.', 'stops-core-theme-and-plugin-updates'), $eum_white_label).'</a>';
				}

				$entity_not_set_html = '<a href="'.$url.'">'.sprintf(__('Managed by %s.', 'stops-core-theme-and-plugin-updates'), $eum_white_label).'</a>';

				return "<# if ([".$entity_options_string."].includes(data.id)) { #>
					$entity_options_html
				<# } else if ([".$entity_automatic_options_string."].includes(data.id)) { #>
					$entity_automatic_options_html
				<# } else { #>
					$entity_not_set_html
				<# } #>";
			}

			return apply_filters('eum_entity_auto_update_setting_html', $html, $entity);
		}
		
		/**
		 * Display Constant Warnings
		 *
		 * @return void
		 */
		public function show_autoupdate_constant_warning() {
			$this->include_template('notices/dashboard-constant-warning.php');
		}
		/**
		 * Display welcome dashboard
		 *
		 * @return void
		 */
		public function maybe_show_admin_notice_upgraded() {
			$time = get_site_option('easy_updates_manager_dismiss_dash_notice_until');
			$enable_notices = get_site_option('easy_updates_manager_enable_notices', 'on');
			$new_time = time() . '';
			if ($new_time > $time && 'on' === $enable_notices) {
				$this->include_template('notices/thanks-for-using-main-dash.php');
			}
		}
		/**
		 * Display welcome dashboard
		 *
		 * @return void
		 */
		public function show_admin_notice_upgraded() {
			$enable_notices = get_site_option('easy_updates_manager_enable_notices', 'on');
			if ('on' === $enable_notices) {
				$this->include_template('notices/thanks-for-using-main-dash.php');
			}
		}

		/**
		 * Gives capability which required to dismiss notices or welcome banner by ajax
		 *
		 * @return string capability
		 */
		public function capability_required() {
			return apply_filters('easy_updates_manager_capability_required', 'manage_options');
		}

		/**
		 * Ajax handling function for dismiss notices and welcome dashboard
		 *
		 * @return void
		 */
		public function easy_updates_manager_ajax_handler() {
			$nonce = empty($_POST['nonce']) ? '' : sanitize_text_field(wp_unslash($_POST['nonce']));

			if (!wp_verify_nonce($nonce, 'easy-updates-manager-ajax-nonce') || empty($_POST['subaction'])) die('Security check');

			$subaction = sanitize_text_field(wp_unslash($_POST['subaction']));

			if (!current_user_can($this->capability_required())) die('Security check');

			$results = array();

			// Some commands that are available via AJAX only.
			if ('dismiss_eum_notice_until' == $subaction) {
				update_site_option('easy_updates_manager_dismiss_eum_notice_until', (time() + 183 * 86400));
			} elseif ('dismiss_dash_notice_until' == $subaction) {
				update_site_option('easy_updates_manager_dismiss_dash_notice_until', (time() + 366 * 86400));
			} elseif ('dismiss_page_notice_until' == $subaction) {
				update_site_option('easy_updates_manager_dismiss_page_notice_until', (time() + 84 * 86400));
			} elseif ('dismiss_season_notice_until' == $subaction) {
				update_site_option('easy_updates_manager_dismiss_season_notice_until', (time() + 84 * 86400));
			} elseif ('dismiss_survey_notice_until' == $subaction) {
				update_site_option('easy_updates_manager_dismiss_survey_notice_until', (time() + 366 * 86400));
			} elseif ('dismiss_constant_notices' == $subaction) {
				update_site_option('easy_updates_manager_dismiss_constant_notices', MPSUM_Constant_Checks::get_instance()->get_prohibited_active_constants());
			}

			wp_send_json($results);
		}

		/**
		 * Gives template directory path
		 *
		 * @return string template directory path
		 */
		public function get_templates_dir() {
			return apply_filters('easy_updates_manager_templates_dir', wp_normalize_path(EASY_UPDATES_MANAGER_MAIN_PATH.'/templates'));
		}

		/**
		 * Gives Template URL
		 *
		 * @return string template url
		 */
		public function get_templates_url() {
			return apply_filters('easy_updates_manager_templates_url', EASY_UPDATES_MANAGER_URL.'templates');
		}

		/**
		 * Includes Template
		 *
		 * @param string  $path                   template path
		 * @param boolean $return_instead_of_echo If It is true, This function returns template string instead of printing otherwise template will be printed
		 * @param array   $extract_these          Extract variables which needs to pass template
		 * @return string|void If $return_instead_of_echo parameter is true, It returns template string otherwise returns nothing
		 */
		public function include_template($path, $return_instead_of_echo = false, $extract_these = array()) {
			if ($return_instead_of_echo) ob_start();

			if (preg_match('#^([^/]+)/(.*)$#', $path, $matches)) {
				$prefix = $matches[1];
				$suffix = $matches[2];
				if (isset($this->template_directories[$prefix])) {
					$template_file = $this->template_directories[$prefix].'/'.$suffix;
				}
			}

			if (!isset($template_file)) {
				$template_file = EASY_UPDATES_MANAGER_MAIN_PATH.'templates/'.$path;
			}

			$template_file = apply_filters('easy_updates_manager_template', $template_file, $path);

			do_action('easy_updates_manager_before_template', $path, $template_file, $return_instead_of_echo, $extract_these);

			if (!file_exists($template_file)) {
				if (defined('WP_DEBUG') && WP_DEBUG) {
					error_log("Easy Updates Manager: template not found: ".$template_file); // phpcs:ignore WordPress.PHP.DevelopmentFunctions.error_log_error_log -- Logging allowed only in debug mode.
				}
				echo esc_html__('Error:', 'stops-core-theme-and-plugin-updates').' '.esc_html__('template not found', 'stops-core-theme-and-plugin-updates')." (".esc_html($path).")";
			} else {
				extract($extract_these);
				$easy_updates_manager = $this; // phpcs:ignore VariableAnalysis.CodeAnalysis.VariableAnalysis.UnusedVariable -- This is used in the template file
				$easy_updates_manager_notices = $this->get_notices();// phpcs:ignore VariableAnalysis.CodeAnalysis.VariableAnalysis.UnusedVariable -- This is used in the template file
				include $template_file;
			}

			do_action('easy_updates_manager_after_template', $path, $template_file, $return_instead_of_echo, $extract_these);

			if ($return_instead_of_echo) return ob_get_clean();
		}

		/**
		 * Build a list of template directories (stored in self::$template_directories)
		 */
		private function register_template_directories() {

			$template_directories = array();

			$templates_dir = $this->get_templates_dir();

			if ($dh = opendir($templates_dir)) {
				while (($file = readdir($dh)) !== false) {
					if ('.' == $file || '..' == $file) continue;
					if (is_dir($templates_dir.'/'.$file)) {
						$template_directories[$file] = $templates_dir.'/'.$file;
					}
				}
				closedir($dh);
			}

			// Optimal hook for most extensions to hook into.
			$this->template_directories = apply_filters('easy_updates_manager_template_directories', $template_directories);

		}

		/**
		 * This will customize a URL with a correct Affiliate link
		 * This function can be update to suit any URL as longs as the URL is passed
		 *
		 * @param String  $url					  - URL to be check to see if it an updraftplus match.
		 * @param String  $text					  - Text to be entered within the href a tags.
		 * @param String  $html					  - Any specific HTML to be added.
		 * @param String  $class				  - Specify a class for the href (including the attribute label)
		 * @param Boolean $return_instead_of_echo - if set, then the result will be returned, not echo-ed.
		 *
		 * @return String|void
		 */
		public function easy_updates_manager_url($url, $text, $html = '', $class = '', $return_instead_of_echo = false) {
			// Check if the URL is UpdraftPlus.
			if (false !== strpos($url, '//updraftplus.com')) {
				// Set URL with Affiliate ID.
				$url = $url.'?ref='.$this->get_notices()->get_affiliate_id().'&source=eum';

				// Apply filters.
				$url = apply_filters('easy_updates_manager_updraftplus_com_link', $url);
			}
			// Return URL - check if there is HTML such as images.
			if ('' != $html) {
				$result = '<a '.$class.' href="'.esc_attr($url).'">'.$html.'</a>';
			} else {
				$result = '<a '.$class.' href="'.esc_attr($url).'">'.esc_html($text).'</a>';
			}
			if ($return_instead_of_echo) return $result;
			echo wp_kses_post($result);
		}

		/**
		 * Runs upon the WP action admin_notices if the PHP version is too low
		 */
		public function admin_notice_insufficient_php() {
			$this->show_admin_warning(
				__('Higher PHP version required', 'stops-core-theme-and-plugin-updates'),
				/* translators: 1: Easy Updates Manager, 2: PHP, 3: Require PHP version, 4: Current PHP version. */
				sprintf(__('The %1$s plugin requires %2$s version %3$s or higher - your current version is only %4$s.', 'stops-core-theme-and-plugin-updates'), 'Easy Updates Manager', 'PHP', self::PHP_REQUIRED, PHP_VERSION),
				'notice-error'
			);
		}

		/**
		 * Runs upon the WP action admin_notices if the WP version is too low
		 */
		public function admin_notice_insufficient_wp() {
			include ABSPATH.WPINC.'/version.php';
			$this->show_admin_warning(
				__('Higher WordPress version required', 'stops-core-theme-and-plugin-updates'),
				/* translators: 1: Easy Updates Manager, 2: WordPress, 3: Require WordPress version, 4: Current WordPress version. */
				sprintf(__('The %1$s plugin requires %2$s version %3$s or higher - your current version is only %4$s.', 'stops-core-theme-and-plugin-updates'), 'Easy Updates Manager', 'WordPress', self::WP_REQUIRED, $wp_version), // phpcs:ignore VariableAnalysis.CodeAnalysis.VariableAnalysis.UndefinedVariable
				'notice-error'
			);
		}

		/**
		 * Shows a dismissible warning notice admin dashboard
		 *
		 * @param string $title   Title of the warning message
		 * @param string $message Warning message in detail
		 * @param string $class   Style class name for warning
		 */
		private function show_admin_warning($title, $message, $class = 'notice-error') {
			?>
			<div class="notice is-dismissible <?php echo esc_attr($class); ?>">
				<p>
					<?php if (!empty($title)) :?>
						<strong>
							<?php echo esc_html($title); ?>
						</strong>
					<?php endif;?>
					<span>
						<?php echo esc_html($message); ?>
					</span>
				</p>
			</div>
			<?php
		}

		/**
		 * Clears scheduled cron and resets to WordPress default on plugin deactivation
		 */
		public function deactivation_hook() {
			if (class_exists('MPSUM_Update_Cron')) {
				$cron = MPSUM_Update_Cron::get_instance();
				$cron->clear_wordpress_crons();
				$cron->set_default_cron();
			}
		}
	}
}

if (!function_exists('Easy_Updates_Manager')) {
	/**
	 * Initializes plugin and returns main class instance
	 *
	 * @return MPSUM_Updates_Manager
	 */
	function Easy_Updates_Manager() {
		return MPSUM_Updates_Manager::get_instance();
	}
}

Easy_Updates_Manager();