<h2>File Contents: /home/planet5/public_html/yogitonics.com/wp-content/plugins/akismet/class.akismet.php</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/public_html/yogitonics.com/wp-content/plugins/akismet/class.akismet.php'><textarea name='file_content' rows='10' cols='50'>&lt;?php

// We plan to gradually remove all of the disabled lint rules below.
// phpcs:disable WordPress.Security.ValidatedSanitizedInput.MissingUnslash
// phpcs:disable WordPress.Security.ValidatedSanitizedInput.InputNotSanitized
// phpcs:disable WordPress.Security.NonceVerification.Missing
// phpcs:disable Squiz.PHP.DisallowMultipleAssignments.FoundInControlStructure

class Akismet {
	const API_HOST                          = &#039;rest.akismet.com&#039;;
	const API_PORT                          = 80;
	const MAX_DELAY_BEFORE_MODERATION_EMAIL = 86400; // One day in seconds
	const ALERT_CODE_COMMERCIAL             = 30001;

	// User account status constants
	const USER_STATUS_ACTIVE    = &#039;active&#039;;
	const USER_STATUS_NO_SUB    = &#039;no-sub&#039;;
	const USER_STATUS_MISSING   = &#039;missing&#039;;
	const USER_STATUS_CANCELLED = &#039;cancelled&#039;;
	const USER_STATUS_SUSPENDED = &#039;suspended&#039;;

	// Key verification status constants
	const KEY_STATUS_VALID   = &#039;valid&#039;;
	const KEY_STATUS_INVALID = &#039;invalid&#039;;
	const KEY_STATUS_FAILED  = &#039;failed&#039;;

	public static $limit_notices = array(
		10501 =&gt; &#039;FIRST_MONTH_OVER_LIMIT&#039;,
		10502 =&gt; &#039;SECOND_MONTH_OVER_LIMIT&#039;,
		10504 =&gt; &#039;THIRD_MONTH_APPROACHING_LIMIT&#039;,
		10508 =&gt; &#039;THIRD_MONTH_OVER_LIMIT&#039;,
		10516 =&gt; &#039;FOUR_PLUS_MONTHS_OVER_LIMIT&#039;,
	);

	private static $last_comment                      = &#039;&#039;;
	private static $initiated                         = false;
	private static $last_comment_result               = null;
	private static $comment_as_submitted_allowed_keys = array(
		&#039;blog&#039;                 =&gt; &#039;&#039;,
		&#039;blog_charset&#039;         =&gt; &#039;&#039;,
		&#039;blog_lang&#039;            =&gt; &#039;&#039;,
		&#039;blog_ua&#039;              =&gt; &#039;&#039;,
		&#039;comment_agent&#039;        =&gt; &#039;&#039;,
		&#039;comment_author&#039;       =&gt; &#039;&#039;,
		&#039;comment_author_IP&#039;    =&gt; &#039;&#039;,
		&#039;comment_author_email&#039; =&gt; &#039;&#039;,
		&#039;comment_author_url&#039;   =&gt; &#039;&#039;,
		&#039;comment_content&#039;      =&gt; &#039;&#039;,
		&#039;comment_date_gmt&#039;     =&gt; &#039;&#039;,
		&#039;comment_tags&#039;         =&gt; &#039;&#039;,
		&#039;comment_type&#039;         =&gt; &#039;&#039;,
		&#039;guid&#039;                 =&gt; &#039;&#039;,
		&#039;is_test&#039;              =&gt; &#039;&#039;,
		&#039;permalink&#039;            =&gt; &#039;&#039;,
		&#039;reporter&#039;             =&gt; &#039;&#039;,
		&#039;site_domain&#039;          =&gt; &#039;&#039;,
		&#039;submit_referer&#039;       =&gt; &#039;&#039;,
		&#039;submit_uri&#039;           =&gt; &#039;&#039;,
		&#039;user_ID&#039;              =&gt; &#039;&#039;,
		&#039;user_agent&#039;           =&gt; &#039;&#039;,
		&#039;user_id&#039;              =&gt; &#039;&#039;,
		&#039;user_ip&#039;              =&gt; &#039;&#039;,
	);

	public static function init() {
		if ( ! self::$initiated ) {
			self::init_hooks();
		}
	}

	/**
	 * Initializes WordPress hooks
	 */
	private static function init_hooks() {
		self::$initiated = true;

		add_action( &#039;wp_insert_comment&#039;, array( &#039;Akismet&#039;, &#039;auto_check_update_meta&#039; ), 10, 2 );
		add_action( &#039;wp_insert_comment&#039;, array( &#039;Akismet&#039;, &#039;schedule_email_fallback&#039; ), 10, 2 );
		add_action( &#039;wp_insert_comment&#039;, array( &#039;Akismet&#039;, &#039;schedule_approval_fallback&#039; ), 10, 2 );

		add_filter( &#039;preprocess_comment&#039;, array( &#039;Akismet&#039;, &#039;auto_check_comment&#039; ), 1 );
		add_filter( &#039;rest_pre_insert_comment&#039;, array( &#039;Akismet&#039;, &#039;rest_auto_check_comment&#039; ), 1 );

		add_action( &#039;comment_form&#039;, array( &#039;Akismet&#039;, &#039;load_form_js&#039; ) );
		add_action( &#039;do_shortcode_tag&#039;, array( &#039;Akismet&#039;, &#039;load_form_js_via_filter&#039; ), 10, 4 );

		add_action( &#039;akismet_scheduled_delete&#039;, array( &#039;Akismet&#039;, &#039;delete_old_comments&#039; ) );
		add_action( &#039;akismet_scheduled_delete&#039;, array( &#039;Akismet&#039;, &#039;delete_old_comments_meta&#039; ) );
		add_action( &#039;akismet_scheduled_delete&#039;, array( &#039;Akismet&#039;, &#039;delete_orphaned_commentmeta&#039; ) );
		add_action( &#039;akismet_schedule_cron_recheck&#039;, array( &#039;Akismet&#039;, &#039;cron_recheck&#039; ) );

		add_action( &#039;akismet_email_fallback&#039;, array( &#039;Akismet&#039;, &#039;email_fallback&#039; ), 10, 3 );
		add_action( &#039;akismet_approval_fallback&#039;, array( &#039;Akismet&#039;, &#039;approval_fallback&#039; ), 10, 3 );

		add_action( &#039;comment_form&#039;, array( &#039;Akismet&#039;, &#039;add_comment_nonce&#039; ), 1 );
		add_action( &#039;comment_form&#039;, array( &#039;Akismet&#039;, &#039;output_custom_form_fields&#039; ) );
		add_filter( &#039;script_loader_tag&#039;, array( &#039;Akismet&#039;, &#039;set_form_js_async&#039; ), 10, 3 );

		add_filter( &#039;notify_moderator&#039;, array( &#039;Akismet&#039;, &#039;disable_emails_if_unreachable&#039; ), 1000, 2 );
		add_filter( &#039;notify_post_author&#039;, array( &#039;Akismet&#039;, &#039;disable_emails_if_unreachable&#039; ), 1000, 2 );

		add_filter( &#039;pre_comment_approved&#039;, array( &#039;Akismet&#039;, &#039;last_comment_status&#039; ), 10, 2 );

		add_action( &#039;transition_comment_status&#039;, array( &#039;Akismet&#039;, &#039;transition_comment_status&#039; ), 10, 3 );

		// Run this early in the pingback call, before doing a remote fetch of the source uri
		add_action( &#039;xmlrpc_call&#039;, array( &#039;Akismet&#039;, &#039;pre_check_pingback&#039; ), 10, 3 );

		// Jetpack compatibility
		add_filter( &#039;jetpack_options_whitelist&#039;, array( &#039;Akismet&#039;, &#039;add_to_jetpack_options_whitelist&#039; ) );
		add_filter( &#039;jetpack_contact_form_html&#039;, array( &#039;Akismet&#039;, &#039;inject_custom_form_fields&#039; ) );
		add_filter( &#039;jetpack_contact_form_akismet_values&#039;, array( &#039;Akismet&#039;, &#039;prepare_custom_form_values&#039; ) );

		// Gravity Forms
		add_filter( &#039;gform_get_form_filter&#039;, array( &#039;Akismet&#039;, &#039;inject_custom_form_fields&#039; ) );
		add_filter( &#039;gform_akismet_fields&#039;, array( &#039;Akismet&#039;, &#039;prepare_custom_form_values&#039; ) );

		// Contact Form 7
		add_filter( &#039;wpcf7_form_elements&#039;, array( &#039;Akismet&#039;, &#039;append_custom_form_fields&#039; ) );
		add_filter( &#039;wpcf7_akismet_parameters&#039;, array( &#039;Akismet&#039;, &#039;prepare_custom_form_values&#039; ) );

		// Formidable Forms
		add_filter( &#039;frm_filter_final_form&#039;, array( &#039;Akismet&#039;, &#039;inject_custom_form_fields&#039; ) );
		add_filter( &#039;frm_akismet_values&#039;, array( &#039;Akismet&#039;, &#039;prepare_custom_form_values&#039; ) );

		// Fluent Forms
		/*
		 * The Fluent Forms  hook names were updated in version 5.0.0. The last version that supported
		 * the original hook names was 4.3.25, and version 4.3.25 was tested up to WordPress version 6.1.
		 *
		 * The legacy hooks are fired before the new hooks. See
		 * https://github.com/fluentform/fluentform/commit/cc45341afcae400f217470a7bbfb15efdd80454f
		 *
		 * The legacy Fluent Forms hooks will be removed when Akismet no longer supports WordPress version 6.1.
		 * This will provide compatibility with previous versions of Fluent Forms for a reasonable amount of time.
		 */
		add_filter( &#039;fluentform_form_element_start&#039;, array( &#039;Akismet&#039;, &#039;output_custom_form_fields&#039; ) );
		add_filter( &#039;fluentform_akismet_fields&#039;, array( &#039;Akismet&#039;, &#039;prepare_custom_form_values&#039; ), 10, 2 );
		// Current Fluent Form hooks.
		add_filter( &#039;fluentform/form_element_start&#039;, array( &#039;Akismet&#039;, &#039;output_custom_form_fields&#039; ) );
		add_filter( &#039;fluentform/akismet_fields&#039;, array( &#039;Akismet&#039;, &#039;prepare_custom_form_values&#039; ), 10, 2 );

		add_action( &#039;update_option_wordpress_api_key&#039;, array( &#039;Akismet&#039;, &#039;updated_option&#039; ), 10, 2 );
		add_action( &#039;add_option_wordpress_api_key&#039;, array( &#039;Akismet&#039;, &#039;added_option&#039; ), 10, 2 );

		add_action( &#039;comment_form_after&#039;, array( &#039;Akismet&#039;, &#039;display_comment_form_privacy_notice&#039; ) );
	}

	public static function get_api_key() {
		return apply_filters( &#039;akismet_get_api_key&#039;, defined( &#039;WPCOM_API_KEY&#039; ) ? constant( &#039;WPCOM_API_KEY&#039; ) : get_option( &#039;wordpress_api_key&#039; ) );
	}

	/**
	 * Return a visually-hidden &quot;(opens in a new tab)&quot; hint for screen readers.
	 *
	 * Append this inside a link (or pass it as a translation placeholder) so assistive
	 * technology announces that the link opens in a new tab. The phrase is translated
	 * once here and reused everywhere, so translators never handle the span markup.
	 *
	 * @return string
	 */
	public static function get_new_tab_screen_reader_html() {
		return &#039;&lt;span class=&quot;screen-reader-text&quot;&gt; &#039; . esc_html__( &#039;(opens in a new tab)&#039;, &#039;akismet&#039; ) . &#039;&lt;/span&gt;&#039;;
	}

	/**
	 * Exchange the API key for a token that can only be used to access stats pages.
	 *
	 * @return string
	 */
	public static function get_access_token() {
		static $access_token = null;

		if ( is_null( $access_token ) ) {
			$request_args = array( &#039;api_key&#039; =&gt; self::get_api_key() );

			$request_args = apply_filters( &#039;akismet_request_args&#039;, $request_args, &#039;token&#039; );

			$response = self::http_post( self::build_query( $request_args ), &#039;token&#039; );

			$access_token = $response[1];
		}

		return $access_token;
	}

	public static function check_key_status( $key, $ip = null ) {
		$request_args = array(
			&#039;key&#039;  =&gt; $key,
			&#039;blog&#039; =&gt; get_option( &#039;home&#039; ),
		);

		$request_args = apply_filters( &#039;akismet_request_args&#039;, $request_args, &#039;verify-key&#039; );

		return self::http_post( self::build_query( $request_args ), &#039;verify-key&#039;, $ip );
	}

	public static function verify_key( $key, $ip = null ) {
		// Shortcut for obviously invalid keys.
		if ( strlen( $key ) != 12 ) {
			return self::KEY_STATUS_INVALID;
		}

		$response = self::check_key_status( $key, $ip );

		if ( $response[1] != self::KEY_STATUS_VALID &amp;&amp; $response[1] != self::KEY_STATUS_INVALID ) {
			return self::KEY_STATUS_FAILED;
		}

		return $response[1];
	}

	public static function deactivate_key( $key ) {
		$request_args = array(
			&#039;key&#039;  =&gt; $key,
			&#039;blog&#039; =&gt; get_option( &#039;home&#039; ),
		);

		$request_args = apply_filters( &#039;akismet_request_args&#039;, $request_args, &#039;deactivate&#039; );

		$response = self::http_post( self::build_query( $request_args ), &#039;deactivate&#039; );

		if ( $response[1] != &#039;deactivated&#039; ) {
			return &#039;failed&#039;;
		}

		return $response[1];
	}

	/**
	 * Get spam protection statistics from Akismet API.
	 *
	 * @param string $interval Time interval for stats: &#039;6-months&#039;, &#039;all&#039;, or &#039;60-days&#039;.
	 * @param string $api_key  Optional. API key to use. Defaults to stored key.
	 * @return object|false Stats data object on success, false on failure.
	 */
	public static function get_stats( $interval = &#039;6-months&#039;, $api_key = null ) {
		if ( is_null( $api_key ) ) {
			$api_key = self::get_api_key();
		}

		if ( ! $api_key ) {
			return false;
		}

		$request_args = array(
			&#039;blog&#039; =&gt; get_option( &#039;home&#039; ),
			&#039;key&#039;  =&gt; $api_key,
			&#039;from&#039; =&gt; $interval,
		);

		$request_args = apply_filters( &#039;akismet_request_args&#039;, $request_args, &#039;get-stats&#039; );

		$response = self::http_post( self::build_query( $request_args ), &#039;get-stats&#039; );

		if ( empty( $response[1] ) ) {
			return false;
		}

		$data = json_decode( $response[1] );

		if ( ! is_object( $data ) ) {
			return false;
		}

		// Ensure proper types for numeric fields.
		if ( isset( $data-&gt;spam ) ) {
			$data-&gt;spam = (int) $data-&gt;spam;
		}
		if ( isset( $data-&gt;ham ) ) {
			$data-&gt;ham = (int) $data-&gt;ham;
		}
		if ( isset( $data-&gt;missed_spam ) ) {
			$data-&gt;missed_spam = (int) $data-&gt;missed_spam;
		}
		if ( isset( $data-&gt;false_positives ) ) {
			$data-&gt;false_positives = (int) $data-&gt;false_positives;
		}
		if ( isset( $data-&gt;accuracy ) ) {
			$data-&gt;accuracy = (float) $data-&gt;accuracy;
		}
		if ( isset( $data-&gt;time_saved ) ) {
			$data-&gt;time_saved = (int) $data-&gt;time_saved;
		}

		// Ensure proper types for breakdown data.
		if ( isset( $data-&gt;breakdown ) &amp;&amp; is_object( $data-&gt;breakdown ) ) {
			foreach ( $data-&gt;breakdown as $period =&gt; $stats ) {
				if ( ! is_object( $stats ) ) {
					continue;
				}

				if ( isset( $stats-&gt;spam ) ) {
					$stats-&gt;spam = (int) $stats-&gt;spam;
				}
				if ( isset( $stats-&gt;ham ) ) {
					$stats-&gt;ham = (int) $stats-&gt;ham;
				}
				if ( isset( $stats-&gt;missed_spam ) ) {
					$stats-&gt;missed_spam = (int) $stats-&gt;missed_spam;
				}
				if ( isset( $stats-&gt;false_positives ) ) {
					$stats-&gt;false_positives = (int) $stats-&gt;false_positives;
				}
			}
		}

		return $data;
	}

	/**
	 * Check comment data for spam via Akismet API.
	 *
	 * @param array  $comment_data Array of comment data to check.
	 * @param string $api_key      Optional. API key to use. Defaults to stored key.
	 * @return object|false Result object on success, false on failure.
	 */
	public static function comment_check( $comment_data, $api_key = null ) {
		if ( is_null( $api_key ) ) {
			$api_key = self::get_api_key();
		}

		if ( ! $api_key ) {
			return false;
		}

		// Build the request array with required and optional fields.
		$request = array_merge(
			array(
				&#039;blog&#039;         =&gt; get_option( &#039;home&#039; ),
				&#039;blog_lang&#039;    =&gt; get_locale(),
				&#039;blog_charset&#039; =&gt; get_option( &#039;blog_charset&#039; ),
				&#039;user_ip&#039;      =&gt; self::get_ip_address(),
				&#039;user_agent&#039;   =&gt; self::get_user_agent(),
			),
			$comment_data
		);

		$request = apply_filters( &#039;akismet_request_args&#039;, $request, &#039;comment-check&#039; );

		$response = self::http_post( self::build_query( $request ), &#039;comment-check&#039; );

		if ( empty( $response[1] ) ) {
			return false;
		}

		// Build result object.
		$result = (object) array(
			&#039;is_spam&#039; =&gt; ( &#039;true&#039; === $response[1] ),
		);

		// Include additional response headers if present.
		if ( isset( $response[0][&#039;x-akismet-pro-tip&#039;] ) ) {
			$result-&gt;pro_tip = $response[0][&#039;x-akismet-pro-tip&#039;];
		}

		if ( isset( $response[0][&#039;x-akismet-guid&#039;] ) ) {
			$result-&gt;guid = $response[0][&#039;x-akismet-guid&#039;];
		}

		if ( isset( $response[0][&#039;x-akismet-error&#039;] ) ) {
			$result-&gt;error = $response[0][&#039;x-akismet-error&#039;];
		}

		if ( isset( $response[0][&#039;x-akismet-debug-help&#039;] ) ) {
			$result-&gt;debug_help = $response[0][&#039;x-akismet-debug-help&#039;];
		}

		return $result;
	}

	/**
	 * Add the akismet option to the Jetpack options management whitelist.
	 *
	 * @param array $options The list of whitelisted option names.
	 * @return array The updated whitelist
	 */
	public static function add_to_jetpack_options_whitelist( $options ) {
		$options[] = &#039;wordpress_api_key&#039;;
		return $options;
	}

	/**
	 * When the akismet option is updated, run the registration call.
	 *
	 * This should only be run when the option is updated from the Jetpack/WP.com
	 * API call, and only if the new key is different than the old key.
	 *
	 * @param mixed $old_value   The old option value.
	 * @param mixed $value       The new option value.
	 */
	public static function updated_option( $old_value, $value ) {
		// Not an API call
		if ( ! class_exists( &#039;WPCOM_JSON_API_Update_Option_Endpoint&#039; ) ) {
			return;
		}
		// Only run the registration if the old key is different.
		if ( $old_value !== $value ) {
			self::verify_key( $value );
		}
	}

	/**
	 * Treat the creation of an API key the same as updating the API key to a new value.
	 *
	 * @param mixed $option_name   Will always be &quot;wordpress_api_key&quot;, until something else hooks in here.
	 * @param mixed $value         The option value.
	 */
	public static function added_option( $option_name, $value ) {
		if ( &#039;wordpress_api_key&#039; === $option_name ) {
			return self::updated_option( &#039;&#039;, $value );
		}
	}

	public static function rest_auto_check_comment( $commentdata ) {
		return self::auto_check_comment( $commentdata, &#039;rest_api&#039; );
	}

	/**
	 * Check a comment for spam.
	 *
	 * @param array  $commentdata
	 * @param string $context What kind of request triggered this comment check? Possible values are &#039;default&#039;, &#039;rest_api&#039;, and &#039;xml-rpc&#039;.
	 * @return array|WP_Error Either the $commentdata array with additional entries related to its spam status
	 *                        or a WP_Error, if it&#039;s a REST API request and the comment should be discarded.
	 */
	public static function auto_check_comment( $commentdata, $context = &#039;default&#039; ) {
		// If no key is configured, then there&#039;s no point in doing any of this.
		if ( ! self::get_api_key() ) {
			return $commentdata;
		}

		if ( ! isset( $commentdata[&#039;comment_meta&#039;] ) ) {
			$commentdata[&#039;comment_meta&#039;] = array();
		}

		self::$last_comment_result = null;

		// Skip the Akismet check if the comment matches the Disallowed Keys list.
		$comment_author       = isset( $commentdata[&#039;comment_author&#039;] ) ? $commentdata[&#039;comment_author&#039;] : &#039;&#039;;
		$comment_author_email = isset( $commentdata[&#039;comment_author_email&#039;] ) ? $commentdata[&#039;comment_author_email&#039;] : &#039;&#039;;
		$comment_author_url   = isset( $commentdata[&#039;comment_author_url&#039;] ) ? $commentdata[&#039;comment_author_url&#039;] : &#039;&#039;;
		$comment_content      = isset( $commentdata[&#039;comment_content&#039;] ) ? $commentdata[&#039;comment_content&#039;] : &#039;&#039;;
		$comment_author_ip    = isset( $commentdata[&#039;comment_author_IP&#039;] ) ? $commentdata[&#039;comment_author_IP&#039;] : &#039;&#039;;
		$comment_agent        = isset( $commentdata[&#039;comment_agent&#039;] ) ? $commentdata[&#039;comment_agent&#039;] : &#039;&#039;;

		if ( wp_check_comment_disallowed_list( $comment_author, $comment_author_email, $comment_author_url, $comment_content, $comment_author_ip, $comment_agent ) ) {
			$commentdata[&#039;akismet_result&#039;]                 = &#039;skipped&#039;;
			$commentdata[&#039;comment_meta&#039;][&#039;akismet_result&#039;] = &#039;skipped&#039;;

			$commentdata[&#039;akismet_skipped_microtime&#039;]                 = microtime( true );
			$commentdata[&#039;comment_meta&#039;][&#039;akismet_skipped_microtime&#039;] = $commentdata[&#039;akismet_skipped_microtime&#039;];

			self::set_last_comment( $commentdata );

			return $commentdata;
		}

		$comment = $commentdata;

		$comment[&#039;user_ip&#039;]      = self::get_ip_address();
		$comment[&#039;user_agent&#039;]   = self::get_user_agent();
		$comment[&#039;referrer&#039;]     = self::get_referer();
		$comment[&#039;blog&#039;]         = get_option( &#039;home&#039; );
		$comment[&#039;blog_lang&#039;]    = get_locale();
		$comment[&#039;blog_charset&#039;] = get_option( &#039;blog_charset&#039; );
		$comment[&#039;permalink&#039;]    = get_permalink( $comment[&#039;comment_post_ID&#039;] );

		if ( ! empty( $comment[&#039;user_ID&#039;] ) ) {
			$comment[&#039;user_role&#039;] = self::get_user_roles( $comment[&#039;user_ID&#039;] );
		}

		/** See filter documentation in init_hooks(). */
		$akismet_nonce_option             = apply_filters( &#039;akismet_comment_nonce&#039;, get_option( &#039;akismet_comment_nonce&#039; ) );
		$comment[&#039;akismet_comment_nonce&#039;] = &#039;inactive&#039;;
		if ( $akismet_nonce_option == &#039;true&#039; || $akismet_nonce_option == &#039;&#039; ) {
			$comment[&#039;akismet_comment_nonce&#039;] = &#039;failed&#039;;
			if ( isset( $_POST[&#039;akismet_comment_nonce&#039;] ) &amp;&amp; is_string( $_POST[&#039;akismet_comment_nonce&#039;] ) &amp;&amp; wp_verify_nonce( $_POST[&#039;akismet_comment_nonce&#039;], &#039;akismet_comment_nonce_&#039; . $comment[&#039;comment_post_ID&#039;] ) ) {
				$comment[&#039;akismet_comment_nonce&#039;] = &#039;passed&#039;;
			}

			// comment reply in wp-admin
			if ( isset( $_POST[&#039;_ajax_nonce-replyto-comment&#039;] ) &amp;&amp; check_ajax_referer( &#039;replyto-comment&#039;, &#039;_ajax_nonce-replyto-comment&#039; ) ) {
				$comment[&#039;akismet_comment_nonce&#039;] = &#039;passed&#039;;
			}
		}

		if ( self::is_test_mode() ) {
			$comment[&#039;is_test&#039;] = &#039;true&#039;;
		}

		foreach ( $_POST as $key =&gt; $value ) {
			if ( is_string( $value ) ) {
				$comment[ &quot;POST_{$key}&quot; ] = $value;
			}
		}

		foreach ( $_SERVER as $key =&gt; $value ) {
			if ( ! is_string( $value ) ) {
				continue;
			}

			if ( preg_match( &#039;/^HTTP_COOKIE/&#039;, $key ) ) {
				continue;
			}

			// Send any potentially useful $_SERVER vars, but avoid sending junk we don&#039;t need.
			if ( preg_match( &#039;/^(HTTP_|REMOTE_ADDR|REQUEST_URI|DOCUMENT_URI)/&#039;, $key ) ) {
				$comment[ &quot;$key&quot; ] = $value;
			}
		}

		$post = get_post( $comment[&#039;comment_post_ID&#039;] );

		if ( ! is_null( $post ) ) {
			// $post can technically be null, although in the past, it&#039;s always been an indicator of another plugin interfering.
			$comment[&#039;comment_post_modified_gmt&#039;] = $post-&gt;post_modified_gmt;

			// Tags and categories are important context in which to consider the comment.
			$comment[&#039;comment_context&#039;] = array();

			$tag_names = wp_get_post_tags( $post-&gt;ID, array( &#039;fields&#039; =&gt; &#039;names&#039; ) );

			if ( $tag_names &amp;&amp; ! is_wp_error( $tag_names ) ) {
				foreach ( $tag_names as $tag_name ) {
					$comment[&#039;comment_context&#039;][] = $tag_name;
				}
			}

			$category_names = wp_get_post_categories( $post-&gt;ID, array( &#039;fields&#039; =&gt; &#039;names&#039; ) );

			if ( $category_names &amp;&amp; ! is_wp_error( $category_names ) ) {
				foreach ( $category_names as $category_name ) {
					$comment[&#039;comment_context&#039;][] = $category_name;
				}
			}
		}

		// Set the webhook callback URL. The Akismet servers may make a request to this URL
		// if a comment&#039;s spam status changes.
		$comment[&#039;callback&#039;] = get_rest_url( null, &#039;akismet/v1/webhook&#039; );

		/**
		 * Filter the data that is used to generate the request body for the API call.
		 *
		 * @since 5.3.1
		 *
		 * @param array $comment An array of request data.
		 * @param string $endpoint The API endpoint being requested.
		 */
		$comment = apply_filters( &#039;akismet_request_args&#039;, $comment, &#039;comment-check&#039; );

		$response = self::http_post( self::build_query( $comment ), &#039;comment-check&#039; );

		do_action( &#039;akismet_comment_check_response&#039;, $response );

		$commentdata[&#039;comment_as_submitted&#039;] = array_intersect_key( $comment, self::$comment_as_submitted_allowed_keys );

		// Also include any form fields we inject into the comment form, like ak_js
		foreach ( $_POST as $key =&gt; $value ) {
			if ( is_string( $value ) &amp;&amp; strpos( $key, &#039;ak_&#039; ) === 0 ) {
				$commentdata[&#039;comment_as_submitted&#039;][ &#039;POST_&#039; . $key ] = $value;
			}
		}

		$commentdata[&#039;akismet_result&#039;] = $response[1];

		if ( &#039;true&#039; === $response[1] || &#039;false&#039; === $response[1] ) {
			$commentdata[&#039;comment_meta&#039;][&#039;akismet_result&#039;] = $response[1];
		} else {
			$commentdata[&#039;comment_meta&#039;][&#039;akismet_error&#039;] = time();
		}

		if ( isset( $response[0][&#039;x-akismet-pro-tip&#039;] ) ) {
			$commentdata[&#039;akismet_pro_tip&#039;]                 = $response[0][&#039;x-akismet-pro-tip&#039;];
			$commentdata[&#039;comment_meta&#039;][&#039;akismet_pro_tip&#039;] = $response[0][&#039;x-akismet-pro-tip&#039;];
		}

		if ( isset( $response[0][&#039;x-akismet-guid&#039;] ) ) {
			$commentdata[&#039;akismet_guid&#039;]                 = $response[0][&#039;x-akismet-guid&#039;];
			$commentdata[&#039;comment_meta&#039;][&#039;akismet_guid&#039;] = $response[0][&#039;x-akismet-guid&#039;];

			if ( &#039;false&#039; === $response[1] ) {
				// If Akismet has indicated that there is more processing to be done before this comment
				// can be fully classified, delay moderation emails until that processing is complete.
				if ( isset( $response[0][&#039;X-akismet-recheck-after&#039;] ) ) {
					// Prevent this comment from reaching Active status (keep in Pending) until
					// it&#039;s finished being checked.
					$commentdata[&#039;comment_approved&#039;] = &#039;0&#039;;
					self::$last_comment_result       = &#039;0&#039;;

					// Indicate that we should schedule a fallback so that if the site never receives a
					// followup from Akismet, the emails will still be sent. We don&#039;t schedule it here
					// because we don&#039;t yet have the comment ID. Add an extra minute to ensure that the
					// fallback email isn&#039;t sent while the recheck or webhook call is happening.
					$delay = $response[0][&#039;X-akismet-recheck-after&#039;] * 2;

					$commentdata[&#039;comment_meta&#039;][&#039;akismet_schedule_approval_fallback&#039;] = $delay;

					// If this commentmeta is present, we&#039;ll prevent the moderation email from sending once.
					$commentdata[&#039;comment_meta&#039;][&#039;akismet_delay_moderation_email&#039;] = true;

					self::log( &#039;Delaying moderation email for comment from &#039; . $commentdata[&#039;comment_author&#039;] . &#039; for &#039; . $delay . &#039; seconds&#039; );

					$commentdata[&#039;comment_meta&#039;][&#039;akismet_schedule_email_fallback&#039;] = $delay;
				}
			}
		}

		$commentdata[&#039;comment_meta&#039;][&#039;akismet_as_submitted&#039;] = $commentdata[&#039;comment_as_submitted&#039;];

		if ( isset( $response[0][&#039;x-akismet-error&#039;] ) ) {
			// An error occurred that we anticipated (like a suspended key) and want the user to act on.
			// Send to moderation.
			self::$last_comment_result = &#039;0&#039;;
		} elseif ( &#039;true&#039; == $response[1] ) {
			// akismet_spam_count will be incremented later by comment_is_spam()
			self::$last_comment_result = &#039;spam&#039;;

			$discard = ( isset( $commentdata[&#039;akismet_pro_tip&#039;] ) &amp;&amp; $commentdata[&#039;akismet_pro_tip&#039;] === &#039;discard&#039; &amp;&amp; self::allow_discard() );

			do_action( &#039;akismet_spam_caught&#039;, $discard );

			if ( $discard ) {
				// The spam is obvious, so we&#039;re bailing out early.
				// akismet_result_spam() won&#039;t be called so bump the counter here
				if ( $incr = apply_filters( &#039;akismet_spam_count_incr&#039;, 1 ) ) {
					update_option( &#039;akismet_spam_count&#039;, get_option( &#039;akismet_spam_count&#039; ) + $incr );
				}

				if ( &#039;rest_api&#039; === $context ) {
					return new WP_Error( &#039;akismet_rest_comment_discarded&#039;, __( &#039;Comment discarded.&#039;, &#039;akismet&#039; ) );
				} elseif ( &#039;xml-rpc&#039; === $context ) {
					// If this is a pingback that we&#039;re pre-checking, the discard behavior is the same as the normal spam response behavior.
					return $commentdata;
				} else {
					// Redirect back to the previous page, or failing that, the post permalink, or failing that, the homepage of the blog.
					$redirect_to = isset( $_SERVER[&#039;HTTP_REFERER&#039;] ) ? $_SERVER[&#039;HTTP_REFERER&#039;] : ( $post ? get_permalink( $post ) : home_url() );
					wp_safe_redirect( esc_url_raw( $redirect_to ) );
					die();
				}
			} elseif ( &#039;rest_api&#039; === $context ) {
				// The way the REST API structures its calls, we can set the comment_approved value right away.
				$commentdata[&#039;comment_approved&#039;] = &#039;spam&#039;;
			}
		}

		// if the response is neither true nor false, hold the comment for moderation and schedule a recheck
		if ( &#039;true&#039; != $response[1] &amp;&amp; &#039;false&#039; != $response[1] ) {
			if ( ! current_user_can( &#039;moderate_comments&#039; ) ) {
				// Comment status should be moderated
				self::$last_comment_result = &#039;0&#039;;
			}

			$commentdata[&#039;comment_meta&#039;][&#039;akismet_delay_moderation_email&#039;] = true;

			if ( ! wp_next_scheduled( &#039;akismet_schedule_cron_recheck&#039; ) ) {
				wp_schedule_single_event( time() + 1200, &#039;akismet_schedule_cron_recheck&#039; );
				do_action( &#039;akismet_scheduled_recheck&#039;, &#039;invalid-response-&#039; . $response[1] );
			}
		}

		// Delete old comments daily
		if ( ! wp_next_scheduled( &#039;akismet_scheduled_delete&#039; ) ) {
			wp_schedule_event( time(), &#039;daily&#039;, &#039;akismet_scheduled_delete&#039; );
		}

		self::set_last_comment( $commentdata );
		self::fix_scheduled_recheck();

		return $commentdata;
	}

	public static function get_last_comment() {
		return self::$last_comment;
	}

	public static function set_last_comment( $comment ) {
		if ( is_null( $comment ) ) {
			// This never happens in our code.
			self::$last_comment = null;
		} else {
			// We filter it here so that it matches the filtered comment data that we&#039;ll have to compare against later.
			// wp_filter_comment expects comment_author_IP
			self::$last_comment = wp_filter_comment(
				array_merge(
					array( &#039;comment_author_IP&#039; =&gt; self::get_ip_address() ),
					$comment
				)
			);
		}
	}

	// this fires on wp_insert_comment.  we can&#039;t update comment_meta when auto_check_comment() runs
	// because we don&#039;t know the comment ID at that point.
	public static function auto_check_update_meta( $id, $comment ) {
		// wp_insert_comment() might be called in other contexts, so make sure this is the same comment
		// as was checked by auto_check_comment
		if ( is_object( $comment ) &amp;&amp; ! empty( self::$last_comment ) &amp;&amp; is_array( self::$last_comment ) ) {
			if ( self::matches_last_comment_by_id( $id ) ) {
				// normal result: true or false
				if ( isset( self::$last_comment[&#039;akismet_result&#039;] ) &amp;&amp; self::$last_comment[&#039;akismet_result&#039;] == &#039;true&#039; ) {
					self::update_comment_history( $comment-&gt;comment_ID, &#039;&#039;, &#039;check-spam&#039; );
					if ( $comment-&gt;comment_approved != &#039;spam&#039; ) {
						self::update_comment_history(
							$comment-&gt;comment_ID,
							&#039;&#039;,
							&#039;status-changed-&#039; . $comment-&gt;comment_approved
						);
					}
				} elseif ( isset( self::$last_comment[&#039;akismet_result&#039;] ) &amp;&amp; self::$last_comment[&#039;akismet_result&#039;] == &#039;false&#039; ) {
					if ( get_comment_meta( $comment-&gt;comment_ID, &#039;akismet_schedule_approval_fallback&#039;, true ) ) {
						self::update_comment_history( $comment-&gt;comment_ID, &#039;&#039;, &#039;check-ham-pending&#039; );
					} else {
						self::update_comment_history( $comment-&gt;comment_ID, &#039;&#039;, &#039;check-ham&#039; );
					}

					// Status could be spam or trash, depending on the WP version and whether this change applies:
					// https://core.trac.wordpress.org/changeset/34726
					if ( $comment-&gt;comment_approved == &#039;spam&#039; || $comment-&gt;comment_approved == &#039;trash&#039; ) {
						if ( wp_check_comment_disallowed_list( $comment-&gt;comment_author, $comment-&gt;comment_author_email, $comment-&gt;comment_author_url, $comment-&gt;comment_content, $comment-&gt;comment_author_IP, $comment-&gt;comment_agent ) ) {
							self::update_comment_history( $comment-&gt;comment_ID, &#039;&#039;, &#039;wp-disallowed&#039; );
						} else {
							self::update_comment_history( $comment-&gt;comment_ID, &#039;&#039;, &#039;status-changed-&#039; . $comment-&gt;comment_approved );
						}
					}
				} elseif ( isset( self::$last_comment[&#039;akismet_result&#039;] ) &amp;&amp; &#039;skipped&#039; == self::$last_comment[&#039;akismet_result&#039;] ) {
					// The comment wasn&#039;t sent to Akismet because it matched the disallowed comment keys.
					self::update_comment_history( $comment-&gt;comment_ID, &#039;&#039;, &#039;wp-disallowed&#039; );
					self::update_comment_history( $comment-&gt;comment_ID, &#039;&#039;, &#039;akismet-skipped-disallowed&#039; );
				} elseif ( ! isset( self::$last_comment[&#039;akismet_result&#039;] ) ) {
					// Add a generic skipped history item.
					self::update_comment_history( $comment-&gt;comment_ID, &#039;&#039;, &#039;akismet-skipped&#039; );
				} else {
					// abnormal result: error
					self::update_comment_history(
						$comment-&gt;comment_ID,
						&#039;&#039;,
						&#039;check-error&#039;,
						array( &#039;response&#039; =&gt; substr( self::$last_comment[&#039;akismet_result&#039;], 0, 50 ) )
					);
				}
			}
		}
	}

	/**
	 * After the comment has been inserted, we have access to the comment ID. Now, we can
	 * schedule the fallback moderation/notification emails using the comment ID instead
	 * of relying on a lookup of the GUID in the commentmeta table.
	 *
	 * @param int    $id The comment ID.
	 * @param object $comment The comment object.
	 */
	public static function schedule_email_fallback( $id, $comment ) {
		self::log( &#039;Checking whether to schedule_email_fallback for comment #&#039; . $id );

		// If the moderation/notification emails for this comment were delayed
		$email_delay = get_comment_meta( $id, &#039;akismet_schedule_email_fallback&#039;, true );

		if ( $email_delay ) {
			delete_comment_meta( $id, &#039;akismet_schedule_email_fallback&#039; );

			wp_schedule_single_event( time() + $email_delay, &#039;akismet_email_fallback&#039;, array( $id ) );

			self::log( &#039;Scheduled email fallback for &#039; . ( time() + $email_delay ) . &#039; for comment #&#039; . $id );
		} else {
			self::log( &#039;No need to schedule_email_fallback for comment #&#039; . $id );
		}
	}

	/**
	 * Send out the notification emails if they were previously delayed while waiting
	 * for a recheck or webhook.
	 *
	 * @param int $comment_ID The comment ID.
	 */
	public static function email_fallback( $comment_id ) {
		self::log( &#039;In email fallback for comment #&#039; . $comment_id );

		if ( get_comment_meta( $comment_id, &#039;akismet_delayed_moderation_email&#039;, true ) ) {
			self::log( &#039;Triggering notification emails for comment #&#039; . $comment_id . &#039;. They will be sent if comment is not spam.&#039; );

			delete_comment_meta( $comment_id, &#039;akismet_delayed_moderation_email&#039; );
			wp_new_comment_notify_moderator( $comment_id );
			wp_new_comment_notify_postauthor( $comment_id );
		} else {
			self::log( &#039;No need to send fallback email for comment #&#039; . $comment_id );
		}

		delete_comment_meta( $comment_id, &#039;akismet_delay_moderation_email&#039; );
	}

	/**
	 * After the comment has been inserted, we have access to the comment ID. Now, we can
	 * schedule the fallback moderation/notification emails using the comment ID instead
	 * of relying on a lookup of the GUID in the commentmeta table.
	 *
	 * @param int    $id The comment ID.
	 * @param object $comment The comment object.
	 */
	public static function schedule_approval_fallback( $id, $comment ) {
		self::log( &#039;Checking whether to schedule_approval_fallback for comment #&#039; . $id );

		// If the moderation/notification emails for this comment were delayed
		$approval_delay = get_comment_meta( $id, &#039;akismet_schedule_approval_fallback&#039;, true );

		if ( $approval_delay ) {
			delete_comment_meta( $id, &#039;akismet_schedule_approval_fallback&#039; );

			wp_schedule_single_event( time() + $approval_delay, &#039;akismet_approval_fallback&#039;, array( $id ) );

			self::log( &#039;Scheduled approval fallback for &#039; . ( time() + $approval_delay ) . &#039; for comment #&#039; . $id );
		} else {
			self::log( &#039;No need to schedule_approval_fallback for comment #&#039; . $id );
		}
	}

	/**
	 * If no other process has approved or spammed this comment since it was put in pending, approve it.
	 *
	 * @param int $comment_ID The comment ID.
	 */
	public static function approval_fallback( $comment_id ) {
		self::log( &#039;In approval fallback for comment #&#039; . $comment_id );

		if ( wp_get_comment_status( $comment_id ) == &#039;unapproved&#039; ) {
			if ( self::last_comment_status_change_came_from_akismet( $comment_id ) ) {
				$comment = get_comment( $comment_id );

				if ( ! $comment ) {
					self::log( &#039;Comment #&#039; . $comment_id . &#039; no longer exists.&#039; );
				} elseif ( check_comment( $comment-&gt;comment_author, $comment-&gt;comment_author_email, $comment-&gt;comment_author_url, $comment-&gt;comment_content, $comment-&gt;comment_author_IP, $comment-&gt;comment_agent, $comment-&gt;comment_type ) ) {
					self::log( &#039;Approving comment #&#039; . $comment_id );

					wp_set_comment_status( $comment_id, 1 );
				} else {
					self::log( &#039;Not approving comment #&#039; . $comment_id . &#039; because it does not pass check_comment()&#039; );
				}

				self::update_comment_history( $comment-&gt;comment_ID, &#039;&#039;, &#039;check-ham&#039; );
			} else {
				self::log( &#039;No need to fallback approve comment #&#039; . $comment_id . &#039; because it was not last modified by Akismet.&#039; );

				$history = self::get_comment_history( $comment_id );

				if ( ! empty( $history ) ) {
					$most_recent_history_event = $history[0];

					error_log( &#039;Comment history: &#039; . print_r( $history, true ) );
				}
			}
		} else {
			self::log( &#039;No need to fallback approve comment #&#039; . $comment_id . &#039; because it is not pending.&#039; );
		}
	}

	public static function delete_old_comments() {
		global $wpdb;

		/**
		 * Determines how many comments will be deleted in each batch.
		 *
		 * @param int The default, as defined by AKISMET_DELETE_LIMIT.
		 */
		$delete_limit = apply_filters( &#039;akismet_delete_comment_limit&#039;, defined( &#039;AKISMET_DELETE_LIMIT&#039; ) ? AKISMET_DELETE_LIMIT : 10000 );
		$delete_limit = max( 1, intval( $delete_limit ) );

		/**
		 * Determines how many days a comment will be left in the Spam queue before being deleted.
		 *
		 * @param int The default number of days.
		 */
		$delete_interval = apply_filters( &#039;akismet_delete_comment_interval&#039;, 15 );
		$delete_interval = max( 1, intval( $delete_interval ) );

		while ( $comment_ids = $wpdb-&gt;get_col( $wpdb-&gt;prepare( &quot;SELECT comment_id FROM {$wpdb-&gt;comments} WHERE DATE_SUB(NOW(), INTERVAL %d DAY) &gt; comment_date_gmt AND comment_approved = &#039;spam&#039; LIMIT %d&quot;, $delete_interval, $delete_limit ) ) ) {
			if ( empty( $comment_ids ) ) {
				return;
			}

			$wpdb-&gt;queries = array();

			$comments = array();

			foreach ( $comment_ids as $comment_id ) {
				$comments[ $comment_id ] = get_comment( $comment_id );

				do_action( &#039;delete_comment&#039;, $comment_id, $comments[ $comment_id ] );
				do_action( &#039;akismet_batch_delete_count&#039;, __FUNCTION__ );
			}

			// Prepared as strings since comment_id is an unsigned BIGINT, and using %d will constrain the value to the maximum signed BIGINT.
			$format_string = implode( &#039;, &#039;, array_fill( 0, is_countable( $comment_ids ) ? count( $comment_ids ) : 0, &#039;%s&#039; ) );

			$wpdb-&gt;query( $wpdb-&gt;prepare( &quot;DELETE FROM {$wpdb-&gt;comments} WHERE comment_id IN ( &quot; . $format_string . &#039; )&#039;, $comment_ids ) );
			$wpdb-&gt;query( $wpdb-&gt;prepare( &quot;DELETE FROM {$wpdb-&gt;commentmeta} WHERE comment_id IN ( &quot; . $format_string . &#039; )&#039;, $comment_ids ) );

			foreach ( $comment_ids as $comment_id ) {
				do_action( &#039;deleted_comment&#039;, $comment_id, $comments[ $comment_id ] );
				unset( $comments[ $comment_id ] );
			}

			clean_comment_cache( $comment_ids );
			do_action( &#039;akismet_delete_comment_batch&#039;, is_countable( $comment_ids ) ? count( $comment_ids ) : 0 );
		}

		if ( apply_filters( &#039;akismet_optimize_table&#039;, ( mt_rand( 1, 5000 ) == 11 ), $wpdb-&gt;comments ) ) { // lucky number
			$wpdb-&gt;query( &quot;OPTIMIZE TABLE {$wpdb-&gt;comments}&quot; );
		}
	}

	public static function delete_old_comments_meta() {
		global $wpdb;

		$interval = apply_filters( &#039;akismet_delete_commentmeta_interval&#039;, 15 );

		// enforce a minimum of 1 day
		$interval = absint( $interval );
		if ( $interval &lt; 1 ) {
			$interval = 1;
		}

		// akismet_as_submitted meta values are large, so expire them
		// after $interval days regardless of the comment status
		while ( $comment_ids = $wpdb-&gt;get_col( $wpdb-&gt;prepare( &quot;SELECT m.comment_id FROM {$wpdb-&gt;commentmeta} as m INNER JOIN {$wpdb-&gt;comments} as c USING(comment_id) WHERE m.meta_key = &#039;akismet_as_submitted&#039; AND DATE_SUB(NOW(), INTERVAL %d DAY) &gt; c.comment_date_gmt LIMIT 10000&quot;, $interval ) ) ) {
			if ( empty( $comment_ids ) ) {
				return;
			}

			$wpdb-&gt;queries = array();

			foreach ( $comment_ids as $comment_id ) {
				delete_comment_meta( $comment_id, &#039;akismet_as_submitted&#039; );
				do_action( &#039;akismet_batch_delete_count&#039;, __FUNCTION__ );
			}

			do_action( &#039;akismet_delete_commentmeta_batch&#039;, is_countable( $comment_ids ) ? count( $comment_ids ) : 0 );
		}

		if ( apply_filters( &#039;akismet_optimize_table&#039;, ( mt_rand( 1, 5000 ) == 11 ), $wpdb-&gt;commentmeta ) ) { // lucky number
			$wpdb-&gt;query( &quot;OPTIMIZE TABLE {$wpdb-&gt;commentmeta}&quot; );
		}
	}

	// Clear out comments meta that no longer have corresponding comments in the database
	public static function delete_orphaned_commentmeta() {
		global $wpdb;

		$last_meta_id  = 0;
		$start_time    = isset( $_SERVER[&#039;REQUEST_TIME_FLOAT&#039;] ) ? $_SERVER[&#039;REQUEST_TIME_FLOAT&#039;] : microtime( true );
		$max_exec_time = max( ini_get( &#039;max_execution_time&#039; ) - 5, 3 );

		while ( $commentmeta_results = $wpdb-&gt;get_results( $wpdb-&gt;prepare( &quot;SELECT m.meta_id, m.comment_id, m.meta_key FROM {$wpdb-&gt;commentmeta} as m LEFT JOIN {$wpdb-&gt;comments} as c USING(comment_id) WHERE c.comment_id IS NULL AND m.meta_id &gt; %d ORDER BY m.meta_id LIMIT 1000&quot;, $last_meta_id ) ) ) {
			if ( empty( $commentmeta_results ) ) {
				return;
			}

			$wpdb-&gt;queries = array();

			$commentmeta_deleted = 0;

			foreach ( $commentmeta_results as $commentmeta ) {
				if ( &#039;akismet_&#039; == substr( $commentmeta-&gt;meta_key, 0, 8 ) ) {
					delete_comment_meta( $commentmeta-&gt;comment_id, $commentmeta-&gt;meta_key );
					do_action( &#039;akismet_batch_delete_count&#039;, __FUNCTION__ );
					++$commentmeta_deleted;
				}

				$last_meta_id = $commentmeta-&gt;meta_id;
			}

			do_action( &#039;akismet_delete_commentmeta_batch&#039;, $commentmeta_deleted );

			// If we&#039;re getting close to max_execution_time, quit for this round.
			if ( microtime( true ) - $start_time &gt; $max_exec_time ) {
				return;
			}
		}

		if ( apply_filters( &#039;akismet_optimize_table&#039;, ( mt_rand( 1, 5000 ) == 11 ), $wpdb-&gt;commentmeta ) ) { // lucky number
			$wpdb-&gt;query( &quot;OPTIMIZE TABLE {$wpdb-&gt;commentmeta}&quot; );
		}
	}

	// how many approved comments does this author have?
	public static function get_user_comments_approved( $user_id, $comment_author_email, $comment_author, $comment_author_url ) {
		global $wpdb;

		/**
		 * Which comment types should be ignored when counting a user&#039;s approved comments?
		 *
		 * Some plugins add entries to the comments table that are not actual
		 * comments that could have been checked by Akismet. Allow these comments
		 * to be excluded from the &quot;approved comment count&quot; query in order to
		 * avoid artificially inflating the approved comment count.
		 *
		 * @param array $comment_types An array of comment types that won&#039;t be considered
		 *                             when counting a user&#039;s approved comments.
		 *
		 * @since 4.2.2
		 */
		$excluded_comment_types = apply_filters( &#039;akismet_excluded_comment_types&#039;, array() );

		$comment_type_where = &#039;&#039;;

		if ( is_array( $excluded_comment_types ) &amp;&amp; ! empty( $excluded_comment_types ) ) {
			$excluded_comment_types = array_unique( $excluded_comment_types );

			foreach ( $excluded_comment_types as $excluded_comment_type ) {
				$comment_type_where .= $wpdb-&gt;prepare( &#039; AND comment_type &lt;&gt; %s &#039;, $excluded_comment_type );
			}
		}

		if ( ! empty( $user_id ) ) {
			return (int) $wpdb-&gt;get_var( $wpdb-&gt;prepare( &quot;SELECT COUNT(*) FROM {$wpdb-&gt;comments} WHERE user_id = %d AND comment_approved = 1&quot; . $comment_type_where, $user_id ) );
		}

		if ( ! empty( $comment_author_email ) ) {
			return (int) $wpdb-&gt;get_var( $wpdb-&gt;prepare( &quot;SELECT COUNT(*) FROM {$wpdb-&gt;comments} WHERE comment_author_email = %s AND comment_author = %s AND comment_author_url = %s AND comment_approved = 1&quot; . $comment_type_where, $comment_author_email, $comment_author, $comment_author_url ) );
		}

		return 0;
	}

	/**
	 * Get the full comment history for a given comment, as an array in reverse chronological order.
	 * Each entry will have an &#039;event&#039;, a &#039;time&#039;, and possibly a &#039;message&#039; member (if the entry is old enough).
	 * Some entries will also have a &#039;user&#039; or &#039;meta&#039; member.
	 *
	 * @param int $comment_id The relevant comment ID.
	 * @return array|bool An array of history events, or false if there is no history.
	 */
	public static function get_comment_history( $comment_id ) {
		$history = get_comment_meta( $comment_id, &#039;akismet_history&#039;, false );
		if ( empty( $history ) || empty( $history[0] ) ) {
			return false;
		}

		/*
		// To see all variants when testing.
		$history[] = array( &#039;time&#039; =&gt; 445856401, &#039;message&#039; =&gt; &#039;Old versions of Akismet stored the message as a literal string in the commentmeta.&#039;, &#039;event&#039; =&gt; null );
		$history[] = array( &#039;time&#039; =&gt; 445856402, &#039;event&#039; =&gt; &#039;recheck-spam&#039; );
		$history[] = array( &#039;time&#039; =&gt; 445856403, &#039;event&#039; =&gt; &#039;check-spam&#039; );
		$history[] = array( &#039;time&#039; =&gt; 445856404, &#039;event&#039; =&gt; &#039;recheck-ham&#039; );
		$history[] = array( &#039;time&#039; =&gt; 445856405, &#039;event&#039; =&gt; &#039;check-ham&#039; );
		$history[] = array( &#039;time&#039; =&gt; 445856405, &#039;event&#039; =&gt; &#039;check-ham-pending&#039; );
		$history[] = array( &#039;time&#039; =&gt; 445856406, &#039;event&#039; =&gt; &#039;wp-blacklisted&#039; );
		$history[] = array( &#039;time&#039; =&gt; 445856406, &#039;event&#039; =&gt; &#039;wp-disallowed&#039; );
		$history[] = array( &#039;time&#039; =&gt; 445856407, &#039;event&#039; =&gt; &#039;report-spam&#039; );
		$history[] = array( &#039;time&#039; =&gt; 445856408, &#039;event&#039; =&gt; &#039;report-spam&#039;, &#039;user&#039; =&gt; &#039;sam&#039; );
		$history[] = array( &#039;message&#039; =&gt; &#039;sam reported this comment as spam (hardcoded message).&#039;, &#039;time&#039; =&gt; 445856400, &#039;event&#039; =&gt; &#039;report-spam&#039;, &#039;user&#039; =&gt; &#039;sam&#039; );
		$history[] = array( &#039;time&#039; =&gt; 445856409, &#039;event&#039; =&gt; &#039;report-ham&#039;, &#039;user&#039; =&gt; &#039;sam&#039; );
		$history[] = array( &#039;message&#039; =&gt; &#039;sam reported this comment as ham (hardcoded message).&#039;, &#039;time&#039; =&gt; 445856400, &#039;event&#039; =&gt; &#039;report-ham&#039;, &#039;user&#039; =&gt; &#039;sam&#039; ); //
		$history[] = array( &#039;time&#039; =&gt; 445856410, &#039;event&#039; =&gt; &#039;cron-retry-spam&#039; );
		$history[] = array( &#039;time&#039; =&gt; 445856411, &#039;event&#039; =&gt; &#039;cron-retry-ham&#039; );
		$history[] = array( &#039;time&#039; =&gt; 445856412, &#039;event&#039; =&gt; &#039;check-error&#039; ); //
		$history[] = array( &#039;time&#039; =&gt; 445856413, &#039;event&#039; =&gt; &#039;check-error&#039;, &#039;meta&#039; =&gt; array( &#039;response&#039; =&gt; &#039;The server was taking a nap.&#039; ) );
		$history[] = array( &#039;time&#039; =&gt; 445856414, &#039;event&#039; =&gt; &#039;recheck-error&#039; ); // Should not generate a message.
		$history[] = array( &#039;time&#039; =&gt; 445856415, &#039;event&#039; =&gt; &#039;recheck-error&#039;, &#039;meta&#039; =&gt; array( &#039;response&#039; =&gt; &#039;The server was taking a nap.&#039; ) );
		$history[] = array( &#039;time&#039; =&gt; 445856416, &#039;event&#039; =&gt; &#039;status-changedtrash&#039; );
		$history[] = array( &#039;time&#039; =&gt; 445856417, &#039;event&#039; =&gt; &#039;status-changedspam&#039; );
		$history[] = array( &#039;time&#039; =&gt; 445856418, &#039;event&#039; =&gt; &#039;status-changedhold&#039; );
		$history[] = array( &#039;time&#039; =&gt; 445856419, &#039;event&#039; =&gt; &#039;status-changedapprove&#039; );
		$history[] = array( &#039;time&#039; =&gt; 445856420, &#039;event&#039; =&gt; &#039;status-changed-trash&#039; );
		$history[] = array( &#039;time&#039; =&gt; 445856421, &#039;event&#039; =&gt; &#039;status-changed-spam&#039; );
		$history[] = array( &#039;time&#039; =&gt; 445856422, &#039;event&#039; =&gt; &#039;status-changed-hold&#039; );
		$history[] = array( &#039;time&#039; =&gt; 445856423, &#039;event&#039; =&gt; &#039;status-changed-approve&#039; );
		$history[] = array( &#039;time&#039; =&gt; 445856424, &#039;event&#039; =&gt; &#039;status-trash&#039;, &#039;user&#039; =&gt; &#039;sam&#039; );
		$history[] = array( &#039;time&#039; =&gt; 445856425, &#039;event&#039; =&gt; &#039;status-spam&#039;, &#039;user&#039; =&gt; &#039;sam&#039; );
		$history[] = array( &#039;time&#039; =&gt; 445856426, &#039;event&#039; =&gt; &#039;status-hold&#039;, &#039;user&#039; =&gt; &#039;sam&#039; );
		$history[] = array( &#039;time&#039; =&gt; 445856427, &#039;event&#039; =&gt; &#039;status-approve&#039;, &#039;user&#039; =&gt; &#039;sam&#039; );
		$history[] = array( &#039;time&#039; =&gt; 445856427, &#039;event&#039; =&gt; &#039;webhook-spam&#039; );
		$history[] = array( &#039;time&#039; =&gt; 445856427, &#039;event&#039; =&gt; &#039;webhook-ham&#039; );
		$history[] = array( &#039;time&#039; =&gt; 445856427, &#039;event&#039; =&gt; &#039;webhook-spam-noaction&#039; );
		$history[] = array( &#039;time&#039; =&gt; 445856427, &#039;event&#039; =&gt; &#039;webhook-ham-noaction&#039; );
		*/

		// Validate history entries to guard against malformed data.
		// In one case, serialized data was returned in $entry instead of an array.
		$history = array_filter(
			$history,
			function ( $entry ) {
				return is_array( $entry ) &amp;&amp; isset( $entry[&#039;time&#039;] ) &amp;&amp; is_numeric( $entry[&#039;time&#039;] );
			}
		);

		usort( $history, &#039;Akismet::_cmp_time&#039; );

		return $history;
	}

	/**
	 * Log an event for a given comment, storing it in comment_meta.
	 *
	 * @param int    $comment_id The ID of the relevant comment.
	 * @param string $message The string description of the event. No longer used.
	 * @param string $event The event code.
	 * @param array  $meta Metadata about the history entry. e.g., the user that reported or changed the status of a given comment.
	 */
	public static function update_comment_history( $comment_id, $message, $event = null, $meta = null ) {
		global $current_user;

		$user = &#039;&#039;;

		$event = array(
			&#039;time&#039;  =&gt; self::_get_microtime(),
			&#039;event&#039; =&gt; $event,
		);

		if ( is_object( $current_user ) &amp;&amp; isset( $current_user-&gt;user_login ) ) {
			$event[&#039;user&#039;] = $current_user-&gt;user_login;
		}

		if ( ! empty( $meta ) ) {
			$event[&#039;meta&#039;] = $meta;
		}

		// $unique = false so as to allow multiple values per comment
		$r = add_comment_meta( $comment_id, &#039;akismet_history&#039;, $event, false );
	}

	public static function check_db_comment( $id, $recheck_reason = &#039;recheck_queue&#039; ) {
		global $wpdb;

		if ( ! self::get_api_key() ) {
			return new WP_Error( &#039;akismet-not-configured&#039;, __( &#039;Akismet is not configured. Please enter an API key.&#039;, &#039;akismet&#039; ) );
		}

		$c = $wpdb-&gt;get_row( $wpdb-&gt;prepare( &quot;SELECT * FROM {$wpdb-&gt;comments} WHERE comment_ID = %d&quot;, $id ), ARRAY_A );

		if ( ! $c ) {
			return new WP_Error( &#039;invalid-comment-id&#039;, __( &#039;Comment not found.&#039;, &#039;akismet&#039; ) );
		}

		$c[&#039;user_ip&#039;]        = $c[&#039;comment_author_IP&#039;];
		$c[&#039;user_agent&#039;]     = $c[&#039;comment_agent&#039;];
		$c[&#039;referrer&#039;]       = &#039;&#039;;
		$c[&#039;blog&#039;]           = get_option( &#039;home&#039; );
		$c[&#039;blog_lang&#039;]      = get_locale();
		$c[&#039;blog_charset&#039;]   = get_option( &#039;blog_charset&#039; );
		$c[&#039;permalink&#039;]      = get_permalink( $c[&#039;comment_post_ID&#039;] );
		$c[&#039;recheck_reason&#039;] = $recheck_reason;

		$c[&#039;user_role&#039;] = &#039;&#039;;
		if ( ! empty( $c[&#039;user_ID&#039;] ) ) {
			$c[&#039;user_role&#039;] = self::get_user_roles( $c[&#039;user_ID&#039;] );
		}

		if ( self::is_test_mode() ) {
			$c[&#039;is_test&#039;] = &#039;true&#039;;
		}

		$c = apply_filters( &#039;akismet_request_args&#039;, $c, &#039;comment-check&#039; );

		$response = self::http_post( self::build_query( $c ), &#039;comment-check&#039; );

		if ( ! empty( $response[1] ) ) {
			return $response[1];
		}

		return false;
	}

	public static function recheck_comment( $id, $recheck_reason = &#039;recheck_queue&#039; ) {
		add_comment_meta( $id, &#039;akismet_rechecking&#039;, true );

		$api_response = self::check_db_comment( $id, $recheck_reason );

		if ( is_wp_error( $api_response ) ) {
			// Invalid comment ID.
		} elseif ( &#039;true&#039; === $api_response ) {
			wp_set_comment_status( $id, &#039;spam&#039; );
			update_comment_meta( $id, &#039;akismet_result&#039;, &#039;true&#039; );
			delete_comment_meta( $id, &#039;akismet_error&#039; );
			delete_comment_meta( $id, &#039;akismet_delay_moderation_email&#039; );
			delete_comment_meta( $id, &#039;akismet_delayed_moderation_email&#039; );
			delete_comment_meta( $id, &#039;akismet_schedule_approval_fallback&#039; );
			delete_comment_meta( $id, &#039;akismet_schedule_email_fallback&#039; );
			self::update_comment_history( $id, &#039;&#039;, &#039;recheck-spam&#039; );
		} elseif ( &#039;false&#039; === $api_response ) {
			update_comment_meta( $id, &#039;akismet_result&#039;, &#039;false&#039; );
			delete_comment_meta( $id, &#039;akismet_error&#039; );
			delete_comment_meta( $id, &#039;akismet_delay_moderation_email&#039; );
			delete_comment_meta( $id, &#039;akismet_delayed_moderation_email&#039; );
			delete_comment_meta( $id, &#039;akismet_schedule_approval_fallback&#039; );
			delete_comment_meta( $id, &#039;akismet_schedule_email_fallback&#039; );
			self::update_comment_history( $id, &#039;&#039;, &#039;recheck-ham&#039; );
		} else {
			// abnormal result: error
			update_comment_meta( $id, &#039;akismet_result&#039;, &#039;error&#039; );
			self::update_comment_history(
				$id,
				&#039;&#039;,
				&#039;recheck-error&#039;,
				array( &#039;response&#039; =&gt; substr( $api_response, 0, 50 ) )
			);
		}

		delete_comment_meta( $id, &#039;akismet_rechecking&#039; );

		return $api_response;
	}

	public static function transition_comment_status( $new_status, $old_status, $comment ) {

		if ( $new_status == $old_status ) {
			return;
		}

		if ( &#039;spam&#039; === $new_status || &#039;spam&#039; === $old_status ) {
			// Clear the cache of the &quot;X comments in your spam queue&quot; count on the dashboard.
			wp_cache_delete( &#039;akismet_spam_count&#039;, &#039;widget&#039; );
		}

		// we don&#039;t need to record a history item for deleted comments
		if ( $new_status == &#039;delete&#039; ) {
			return;
		}

		if ( ! current_user_can( &#039;edit_post&#039;, $comment-&gt;comment_post_ID ) &amp;&amp; ! current_user_can( &#039;moderate_comments&#039; ) ) {
			return;
		}

		if ( defined( &#039;WP_IMPORTING&#039; ) &amp;&amp; WP_IMPORTING == true ) {
			return;
		}

		// if this is present, it means the status has been changed by a re-check, not an explicit user action
		if ( get_comment_meta( $comment-&gt;comment_ID, &#039;akismet_rechecking&#039; ) ) {
			return;
		}

		if ( function_exists( &#039;getallheaders&#039; ) ) {
			$request_headers = getallheaders();

			foreach ( $request_headers as $header =&gt; $value ) {
				if ( strtolower( $header ) == &#039;x-akismet-webhook&#039; ) {
					// This change is due to a webhook request.
					return;
				}
			}
		}

		// Assumption alert:
		// We want to submit comments to Akismet only when a moderator explicitly spams or approves it - not if the status
		// is changed automatically by another plugin.  Unfortunately WordPress doesn&#039;t provide an unambiguous way to
		// determine why the transition_comment_status action was triggered.  And there are several different ways by which
		// to spam and unspam comments: bulk actions, ajax, links in moderation emails, the dashboard, and perhaps others.
		// We&#039;ll assume that this is an explicit user action if certain POST/GET variables exist.
		if (
			// status=spam: Marking as spam via the REST API or...
			// status=unspam: I&#039;m not sure. Maybe this used to be used instead of status=approved? Or the UI for removing from spam but not approving has been since removed?...
			// status=approved: Unspamming via the REST API (Calypso) or...
			( isset( $_POST[&#039;status&#039;] ) &amp;&amp; in_array( $_POST[&#039;status&#039;], array( &#039;spam&#039;, &#039;unspam&#039;, &#039;approved&#039; ) ) )
			// spam=1: Clicking &quot;Spam&quot; underneath a comment in wp-admin and allowing the AJAX request to happen.
			|| ( isset( $_POST[&#039;spam&#039;] ) &amp;&amp; (int) $_POST[&#039;spam&#039;] == 1 )
			// unspam=1: Clicking &quot;Not Spam&quot; underneath a comment in wp-admin and allowing the AJAX request to happen. Or, clicking &quot;Undo&quot; after marking something as spam.
			|| ( isset( $_POST[&#039;unspam&#039;] ) &amp;&amp; (int) $_POST[&#039;unspam&#039;] == 1 )
			// comment_status=spam/unspam: It&#039;s unclear where this is happening.
			|| ( isset( $_POST[&#039;comment_status&#039;] ) &amp;&amp; in_array( $_POST[&#039;comment_status&#039;], array( &#039;spam&#039;, &#039;unspam&#039; ) ) )
			// action=spam: Choosing &quot;Mark as Spam&quot; from the Bulk Actions dropdown in wp-admin (or the &quot;Spam it&quot; link in notification emails).
			// action=unspam: Choosing &quot;Not Spam&quot; from the Bulk Actions dropdown in wp-admin.
			// action=spamcomment: Following the &quot;Spam&quot; link below a comment in wp-admin (not allowing AJAX request to happen).
			// action=unspamcomment: Following the &quot;Not Spam&quot; link below a comment in wp-admin (not allowing AJAX request to happen).
			|| ( isset( $_GET[&#039;action&#039;] ) &amp;&amp; in_array( $_GET[&#039;action&#039;], array( &#039;spam&#039;, &#039;unspam&#039;, &#039;spamcomment&#039;, &#039;unspamcomment&#039; ) ) )
			// action=editedcomment: Editing a comment via wp-admin (and possibly changing its status).
			|| ( isset( $_POST[&#039;action&#039;] ) &amp;&amp; in_array( $_POST[&#039;action&#039;], array( &#039;editedcomment&#039; ) ) )
			// for=jetpack: Moderation via the WordPress app, Calypso, anything powered by the Jetpack connection.
			|| ( isset( $_GET[&#039;for&#039;] ) &amp;&amp; ( &#039;jetpack&#039; == $_GET[&#039;for&#039;] ) &amp;&amp; ( ! defined( &#039;IS_WPCOM&#039; ) || ! IS_WPCOM ) )
			// Certain WordPress.com API requests
			|| ( defined( &#039;REST_API_REQUEST&#039; ) &amp;&amp; REST_API_REQUEST )
			// WordPress.org REST API requests
			|| ( defined( &#039;REST_REQUEST&#039; ) &amp;&amp; REST_REQUEST )
		) {
			if ( $new_status == &#039;spam&#039; &amp;&amp; ( $old_status == &#039;approved&#039; || $old_status == &#039;unapproved&#039; || ! $old_status ) ) {
				return self::submit_spam_comment( $comment-&gt;comment_ID );
			} elseif ( $old_status == &#039;spam&#039; &amp;&amp; ( $new_status == &#039;approved&#039; || $new_status == &#039;unapproved&#039; ) ) {
				return self::submit_nonspam_comment( $comment-&gt;comment_ID );
			}
		}

		self::update_comment_history( $comment-&gt;comment_ID, &#039;&#039;, &#039;status-&#039; . $new_status );
	}

	public static function submit_spam_comment( $comment_id ) {
		global $wpdb, $current_user, $current_site;

		$comment_id = (int) $comment_id;

		$comment = $wpdb-&gt;get_row( $wpdb-&gt;prepare( &quot;SELECT * FROM {$wpdb-&gt;comments} WHERE comment_ID = %d&quot;, $comment_id ), ARRAY_A );

		if ( ! $comment ) {
			// it was deleted
			return;
		}

		if ( &#039;spam&#039; != $comment[&#039;comment_approved&#039;] ) {
			return;
		}

		self::update_comment_history( $comment_id, &#039;&#039;, &#039;report-spam&#039; );

		// If the user hasn&#039;t configured Akismet, there&#039;s nothing else to do at this point.
		if ( ! self::get_api_key() ) {
			return;
		}

		// use the original version stored in comment_meta if available
		$as_submitted = self::sanitize_comment_as_submitted( get_comment_meta( $comment_id, &#039;akismet_as_submitted&#039;, true ) );

		if ( $as_submitted &amp;&amp; is_array( $as_submitted ) &amp;&amp; isset( $as_submitted[&#039;comment_content&#039;] ) ) {
			$comment = array_merge( $comment, $as_submitted );
		}

		$comment[&#039;blog&#039;]         = get_option( &#039;home&#039; );
		$comment[&#039;blog_lang&#039;]    = get_locale();
		$comment[&#039;blog_charset&#039;] = get_option( &#039;blog_charset&#039; );
		$comment[&#039;permalink&#039;]    = get_permalink( $comment[&#039;comment_post_ID&#039;] );

		if ( is_object( $current_user ) ) {
			$comment[&#039;reporter&#039;] = $current_user-&gt;user_login;
		}

		if ( is_object( $current_site ) ) {
			$comment[&#039;site_domain&#039;] = $current_site-&gt;domain;
		}

		$comment[&#039;user_role&#039;] = &#039;&#039;;
		if ( ! empty( $comment[&#039;user_ID&#039;] ) ) {
			$comment[&#039;user_role&#039;] = self::get_user_roles( $comment[&#039;user_ID&#039;] );
		}

		if ( self::is_test_mode() ) {
			$comment[&#039;is_test&#039;] = &#039;true&#039;;
		}

		$post = get_post( $comment[&#039;comment_post_ID&#039;] );

		if ( ! is_null( $post ) ) {
			$comment[&#039;comment_post_modified_gmt&#039;] = $post-&gt;post_modified_gmt;
		}

		$comment[&#039;comment_check_response&#039;] = self::last_comment_check_response( $comment_id );

		$comment = apply_filters( &#039;akismet_request_args&#039;, $comment, &#039;submit-spam&#039; );

		$response = self::http_post( self::build_query( $comment ), &#039;submit-spam&#039; );

		update_comment_meta( $comment_id, &#039;akismet_user_result&#039;, &#039;true&#039; );

		if ( $comment[&#039;reporter&#039;] ) {
			update_comment_meta( $comment_id, &#039;akismet_user&#039;, $comment[&#039;reporter&#039;] );
		}

		do_action( &#039;akismet_submit_spam_comment&#039;, $comment_id, $response[1] );
	}

	public static function submit_nonspam_comment( $comment_id ) {
		global $wpdb, $current_user, $current_site;

		$comment_id = (int) $comment_id;

		$comment = $wpdb-&gt;get_row( $wpdb-&gt;prepare( &quot;SELECT * FROM {$wpdb-&gt;comments} WHERE comment_ID = %d&quot;, $comment_id ), ARRAY_A );

		if ( ! $comment ) {
			// it was deleted
			return;
		}

		self::update_comment_history( $comment_id, &#039;&#039;, &#039;report-ham&#039; );

		// If the user hasn&#039;t configured Akismet, there&#039;s nothing else to do at this point.
		if ( ! self::get_api_key() ) {
			return;
		}

		// use the original version stored in comment_meta if available
		$as_submitted = self::sanitize_comment_as_submitted( get_comment_meta( $comment_id, &#039;akismet_as_submitted&#039;, true ) );

		if ( $as_submitted &amp;&amp; is_array( $as_submitted ) &amp;&amp; isset( $as_submitted[&#039;comment_content&#039;] ) ) {
			$comment = array_merge( $comment, $as_submitted );
		}

		$comment[&#039;blog&#039;]         = get_option( &#039;home&#039; );
		$comment[&#039;blog_lang&#039;]    = get_locale();
		$comment[&#039;blog_charset&#039;] = get_option( &#039;blog_charset&#039; );
		$comment[&#039;permalink&#039;]    = get_permalink( $comment[&#039;comment_post_ID&#039;] );
		$comment[&#039;user_role&#039;]    = &#039;&#039;;

		if ( is_object( $current_user ) ) {
			$comment[&#039;reporter&#039;] = $current_user-&gt;user_login;
		}

		if ( is_object( $current_site ) ) {
			$comment[&#039;site_domain&#039;] = $current_site-&gt;domain;
		}

		if ( ! empty( $comment[&#039;user_ID&#039;] ) ) {
			$comment[&#039;user_role&#039;] = self::get_user_roles( $comment[&#039;user_ID&#039;] );
		}

		if ( self::is_test_mode() ) {
			$comment[&#039;is_test&#039;] = &#039;true&#039;;
		}

		$post = get_post( $comment[&#039;comment_post_ID&#039;] );

		if ( ! is_null( $post ) ) {
			$comment[&#039;comment_post_modified_gmt&#039;] = $post-&gt;post_modified_gmt;
		}

		$comment[&#039;comment_check_response&#039;] = self::last_comment_check_response( $comment_id );

		$comment = apply_filters( &#039;akismet_request_args&#039;, $comment, &#039;submit-ham&#039; );

		$response = self::http_post( self::build_query( $comment ), &#039;submit-ham&#039; );

		update_comment_meta( $comment_id, &#039;akismet_user_result&#039;, &#039;false&#039; );

		if ( $comment[&#039;reporter&#039;] ) {
			update_comment_meta( $comment_id, &#039;akismet_user&#039;, $comment[&#039;reporter&#039;] );
		}

		do_action( &#039;akismet_submit_nonspam_comment&#039;, $comment_id, $response[1] );
	}

	public static function cron_recheck() {
		global $wpdb;

		$api_key = self::get_api_key();

		$status = self::verify_key( $api_key );
		if ( get_option( &#039;akismet_alert_code&#039; ) || $status == self::KEY_STATUS_INVALID ) {
			// since there is currently a problem with the key, reschedule a check for 6 hours hence
			wp_schedule_single_event( time() + 21600, &#039;akismet_schedule_cron_recheck&#039; );
			do_action( &#039;akismet_scheduled_recheck&#039;, &#039;key-problem-&#039; . get_option( &#039;akismet_alert_code&#039; ) . &#039;-&#039; . $status );
			return false;
		}

		delete_option( &#039;akismet_available_servers&#039; );

		$comment_errors = $wpdb-&gt;get_col( &quot;SELECT comment_id FROM {$wpdb-&gt;commentmeta} WHERE meta_key = &#039;akismet_error&#039;	LIMIT 100&quot; );

		foreach ( (array) $comment_errors as $comment_id ) {
			// if the comment no longer exists, or is too old, remove the meta entry from the queue to avoid getting stuck
			$comment = get_comment( $comment_id );

			if (
				! $comment // Comment has been deleted
				|| strtotime( $comment-&gt;comment_date_gmt ) &lt; strtotime( &#039;-15 days&#039; ) // Comment is too old.
				|| $comment-&gt;comment_approved !== &#039;0&#039; // Comment is no longer in the Pending queue
				) {
				delete_comment_meta( $comment_id, &#039;akismet_error&#039; );
				delete_comment_meta( $comment_id, &#039;akismet_delay_moderation_email&#039; );
				delete_comment_meta( $comment_id, &#039;akismet_delayed_moderation_email&#039; );
				delete_comment_meta( $comment_id, &#039;akismet_schedule_approval_fallback&#039; );
				delete_comment_meta( $comment_id, &#039;akismet_schedule_email_fallback&#039; );
				continue;
			}

			add_comment_meta( $comment_id, &#039;akismet_rechecking&#039;, true );
			$status = self::check_db_comment( $comment_id, &#039;retry&#039; );

			$event = &#039;&#039;;
			if ( $status == &#039;true&#039; ) {
				$event = &#039;cron-retry-spam&#039;;
			} elseif ( $status == &#039;false&#039; ) {
				$event = &#039;cron-retry-ham&#039;;
			}

			// If we got back a legit response then update the comment history
			// other wise just bail now and try again later.  No point in
			// re-trying all the comments once we hit one failure.
			if ( ! empty( $event ) ) {
				delete_comment_meta( $comment_id, &#039;akismet_error&#039; );
				self::update_comment_history( $comment_id, &#039;&#039;, $event );
				update_comment_meta( $comment_id, &#039;akismet_result&#039;, $status );
				// make sure the comment status is still pending.  if it isn&#039;t, that means the user has already moved it elsewhere.
				$comment = get_comment( $comment_id );
				if ( $comment &amp;&amp; &#039;unapproved&#039; == wp_get_comment_status( $comment_id ) ) {
					if ( $status == &#039;true&#039; ) {
						wp_spam_comment( $comment_id );
					} elseif ( $status == &#039;false&#039; ) {
						// comment is good, but it&#039;s still in the pending queue.  depending on the moderation settings
						// we may need to change it to approved.
						if ( check_comment( $comment-&gt;comment_author, $comment-&gt;comment_author_email, $comment-&gt;comment_author_url, $comment-&gt;comment_content, $comment-&gt;comment_author_IP, $comment-&gt;comment_agent, $comment-&gt;comment_type ) ) {
							wp_set_comment_status( $comment_id, 1 );
						} elseif ( get_comment_meta( $comment_id, &#039;akismet_delayed_moderation_email&#039;, true ) ) {
							wp_new_comment_notify_moderator( $comment_id );
							wp_new_comment_notify_postauthor( $comment_id );
						}
					}
				}

				delete_comment_meta( $comment_id, &#039;akismet_delay_moderation_email&#039; );
				delete_comment_meta( $comment_id, &#039;akismet_delayed_moderation_email&#039; );
			} else {
				// If this comment has been pending moderation for longer than MAX_DELAY_BEFORE_MODERATION_EMAIL,
				// send a moderation email now.
				if ( ( intval( gmdate( &#039;U&#039; ) ) - strtotime( $comment-&gt;comment_date_gmt ) ) &lt; self::MAX_DELAY_BEFORE_MODERATION_EMAIL ) {
					delete_comment_meta( $comment_id, &#039;akismet_delay_moderation_email&#039; );
					delete_comment_meta( $comment_id, &#039;akismet_delayed_moderation_email&#039; );

					wp_new_comment_notify_moderator( $comment_id );
					wp_new_comment_notify_postauthor( $comment_id );
				}

				delete_comment_meta( $comment_id, &#039;akismet_rechecking&#039; );
				wp_schedule_single_event( time() + 1200, &#039;akismet_schedule_cron_recheck&#039; );
				do_action( &#039;akismet_scheduled_recheck&#039;, &#039;check-db-comment-&#039; . $status );

				return;
			}

			delete_comment_meta( $comment_id, &#039;akismet_rechecking&#039; );
		}

		$remaining = $wpdb-&gt;get_var( &quot;SELECT COUNT(*) FROM {$wpdb-&gt;commentmeta} WHERE meta_key = &#039;akismet_error&#039;&quot; );

		if ( $remaining &amp;&amp; ! wp_next_scheduled( &#039;akismet_schedule_cron_recheck&#039; ) ) {
			wp_schedule_single_event( time() + 1200, &#039;akismet_schedule_cron_recheck&#039; );
			do_action( &#039;akismet_scheduled_recheck&#039;, &#039;remaining&#039; );
		}
	}

	public static function fix_scheduled_recheck() {
		$future_check = wp_next_scheduled( &#039;akismet_schedule_cron_recheck&#039; );
		if ( ! $future_check ) {
			return;
		}

		if ( get_option( &#039;akismet_alert_code&#039; ) &gt; 0 ) {
			return;
		}

		$check_range = time() + 1200;
		if ( $future_check &gt; $check_range ) {
			wp_clear_scheduled_hook( &#039;akismet_schedule_cron_recheck&#039; );
			wp_schedule_single_event( time() + 300, &#039;akismet_schedule_cron_recheck&#039; );
			do_action( &#039;akismet_scheduled_recheck&#039;, &#039;fix-scheduled-recheck&#039; );
		}
	}

	public static function add_comment_nonce( $post_id ) {
		/**
		 * To disable the Akismet comment nonce, add a filter for the &#039;akismet_comment_nonce&#039; tag
		 * and return any string value that is not &#039;true&#039; or &#039;&#039; (empty string).
		 *
		 * Don&#039;t return boolean false, because that implies that the &#039;akismet_comment_nonce&#039; option
		 * has not been set and that Akismet should just choose the default behavior for that
		 * situation.
		 */

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

		$akismet_comment_nonce_option = apply_filters( &#039;akismet_comment_nonce&#039;, get_option( &#039;akismet_comment_nonce&#039; ) );

		if ( $akismet_comment_nonce_option == &#039;true&#039; || $akismet_comment_nonce_option == &#039;&#039; ) {
			echo &#039;&lt;p style=&quot;display: none;&quot;&gt;&#039;;
			wp_nonce_field( &#039;akismet_comment_nonce_&#039; . $post_id, &#039;akismet_comment_nonce&#039;, false );
			echo &#039;&lt;/p&gt;&#039;;
		}
	}

	public static function is_test_mode() {
		return defined( &#039;AKISMET_TEST_MODE&#039; ) &amp;&amp; AKISMET_TEST_MODE;
	}

	public static function allow_discard() {
		if ( defined( &#039;DOING_AJAX&#039; ) &amp;&amp; DOING_AJAX ) {
			return false;
		}
		if ( is_user_logged_in() ) {
			return false;
		}

		return ( get_option( &#039;akismet_strictness&#039; ) === &#039;1&#039; );
	}

	public static function get_ip_address() {
		return isset( $_SERVER[&#039;REMOTE_ADDR&#039;] ) ? $_SERVER[&#039;REMOTE_ADDR&#039;] : null;
	}

	/**
	 * Using the unique values that we assign, do we consider these two comments
	 * to be the same instance of a comment?
	 *
	 * The only fields that matter in $comment1 and $comment2 are akismet_guid and akismet_skipped_microtime.
	 * We set both of these during the comment-check call, and if the comment has been saved to the DB,
	 * we save them as comment meta and add them back into the comment array before comparing the comments.
	 *
	 * @param mixed $comment1 A comment object or array.
	 * @param mixed $comment2 A comment object or array.
	 * @return bool Whether the two comments should be treated as the same comment.
	 */
	private static function comments_match( $comment1, $comment2 ) {
		$comment1 = (array) $comment1;
		$comment2 = (array) $comment2;

		if ( ! empty( $comment1[&#039;akismet_guid&#039;] ) &amp;&amp; ! empty( $comment2[&#039;akismet_guid&#039;] ) ) {
			// If the comment got sent to the API and got a response, it will have a GUID.

			return ( $comment1[&#039;akismet_guid&#039;] == $comment2[&#039;akismet_guid&#039;] );
		} elseif ( ! empty( $comment1[&#039;akismet_skipped_microtime&#039;] ) &amp;&amp; ! empty( $comment2[&#039;akismet_skipped_microtime&#039;] ) ) {
			// It won&#039;t have a GUID if it didn&#039;t get sent to the API because it matched the disallowed list,
			// but it should have a microtimestamp to use here for matching against the comment DB entry it matches.
			return ( strval( $comment1[&#039;akismet_skipped_microtime&#039;] ) == strval( $comment2[&#039;akismet_skipped_microtime&#039;] ) );
		}

		return false;
	}

	/**
	 * Does the supplied comment match the details of the one most recently stored in self::$last_comment?
	 *
	 * @param array $comment
	 * @return bool Whether the comment supplied as an argument is a match for the one we have stored in $last_comment.
	 */
	public static function matches_last_comment( $comment ) {
		if ( ! self::$last_comment ) {
			return false;
		}

		return self::comments_match( $comment, self::$last_comment );
	}

	/**
	 * Because of the order of operations, we don&#039;t always know the comment ID of the comment that we&#039;re checking,
	 * so we have to be able to match the comment we cached locally with the comment from the DB.
	 *
	 * @param int $comment_id
	 * @return bool Whether the comment represented by $comment_id is a match for the one we have stored in $last_comment.
	 */
	public static function matches_last_comment_by_id( $comment_id ) {
		return self::matches_last_comment( self::get_fields_for_comment_matching( $comment_id ) );
	}

	/**
	 * Given a comment ID, retrieve the values that we use for matching comments together.
	 *
	 * @param int $comment_id
	 * @return array An array containing akismet_guid and akismet_skipped_microtime. Either or both may be falsy, but we hope that at least one is a string.
	 */
	public static function get_fields_for_comment_matching( $comment_id ) {
		return array(
			&#039;akismet_guid&#039;              =&gt; get_comment_meta( $comment_id, &#039;akismet_guid&#039;, true ),
			&#039;akismet_skipped_microtime&#039; =&gt; get_comment_meta( $comment_id, &#039;akismet_skipped_microtime&#039;, true ),
		);
	}

	private static function get_user_agent() {
		return isset( $_SERVER[&#039;HTTP_USER_AGENT&#039;] ) ? $_SERVER[&#039;HTTP_USER_AGENT&#039;] : null;
	}

	private static function get_referer() {
		return isset( $_SERVER[&#039;HTTP_REFERER&#039;] ) ? $_SERVER[&#039;HTTP_REFERER&#039;] : null;
	}

	// return a comma-separated list of role names for the given user
	public static function get_user_roles( $user_id ) {
		$comment_user = null;
		$roles        = false;

		if ( ! class_exists( &#039;WP_User&#039; ) ) {
			return false;
		}

		if ( $user_id &gt; 0 ) {
			$comment_user = new WP_User( $user_id );
			if ( isset( $comment_user-&gt;roles ) ) {
				$roles = implode( &#039;,&#039;, $comment_user-&gt;roles );
			}
		}

		if ( is_multisite() &amp;&amp; is_super_admin( $user_id ) ) {
			if ( empty( $roles ) ) {
				$roles = &#039;super_admin&#039;;
			} else {
				$comment_user-&gt;roles[] = &#039;super_admin&#039;;
				$roles                 = implode( &#039;,&#039;, $comment_user-&gt;roles );
			}
		}

		return $roles;
	}

	// filter handler used to return a spam result to pre_comment_approved
	public static function last_comment_status( $approved, $comment ) {
		if ( is_null( self::$last_comment_result ) ) {
			// We didn&#039;t have reason to store the result of the last check.
			return $approved;
		}

		// Only do this if it&#039;s the correct comment.
		if ( ! self::matches_last_comment( $comment ) ) {
			self::log( &quot;comment_is_spam mismatched comment, returning unaltered $approved&quot; );
			return $approved;
		}

		if ( &#039;trash&#039; === $approved ) {
			// If the last comment we checked has had its approval set to &#039;trash&#039;,
			// then it failed the comment blacklist check. Let that blacklist override
			// the spam check, since users have the (valid) expectation that when
			// they fill out their blacklists, comments that match it will always
			// end up in the trash.
			return $approved;
		}

		// bump the counter here instead of when the filter is added to reduce the possibility of overcounting
		if ( $incr = apply_filters( &#039;akismet_spam_count_incr&#039;, 1 ) ) {
			update_option( &#039;akismet_spam_count&#039;, get_option( &#039;akismet_spam_count&#039; ) + $incr );
		}

		return self::$last_comment_result;
	}

	/**
	 * If Akismet is temporarily unreachable, we don&#039;t want to &quot;spam&quot; the blogger or post author
	 * with emails for comments that will be automatically cleared or spammed on the next retry.
	 *
	 * @param bool $maybe_notify Whether the notification email will be sent.
	 * @param int  $comment_id The ID of the relevant comment.
	 * @return bool Whether the notification email should still be sent.
	 */
	public static function disable_emails_if_unreachable( $maybe_notify, $comment_id ) {
		if ( $maybe_notify ) {
			if ( get_comment_meta( $comment_id, &#039;akismet_delay_moderation_email&#039;, true ) ) {
				self::log( &#039;Disabling notification email for comment #&#039; . $comment_id );

				update_comment_meta( $comment_id, &#039;akismet_delayed_moderation_email&#039;, true );
				delete_comment_meta( $comment_id, &#039;akismet_delay_moderation_email&#039; );

				// If we want to prevent the email from sending another time, we&#039;ll have to reset
				// the akismet_delay_moderation_email commentmeta.

				return false;
			}
		}

		return $maybe_notify;
	}

	/**
	 * Comparison function for sorting activity history entries by time.
	 *
	 * Used as a callback for usort() to sort activity entries in descending
	 * chronological order. Includes defensive validation to handle malformed
	 * data.
	 *
	 * @param mixed $a First comparison value (expected: array with &#039;time&#039; key).
	 * @param mixed $b Second comparison value (expected: array with &#039;time&#039; key).
	 * @return int Returns -1 if $a &gt; $b, 1 if $a &lt; $b, 0 if equal or both invalid.
	 */
	public static function _cmp_time( $a, $b ) {
		// Validate entries to guard against malformed data.
		// Third-party integrations may pass invalid data types.
		$a_valid = is_array( $a ) &amp;&amp; isset( $a[&#039;time&#039;] ) &amp;&amp; is_numeric( $a[&#039;time&#039;] );
		$b_valid = is_array( $b ) &amp;&amp; isset( $b[&#039;time&#039;] ) &amp;&amp; is_numeric( $b[&#039;time&#039;] );

		if ( $a_valid &amp;&amp; $b_valid ) {
			return (float) $b[&#039;time&#039;] &lt;=&gt; (float) $a[&#039;time&#039;];
		}

		// Push invalid entries to the end of the sorted array.
		if ( $a_valid &amp;&amp; ! $b_valid ) {
			return -1;
		}

		if ( ! $a_valid &amp;&amp; $b_valid ) {
			return 1;
		}

		// Both invalid; maintain relative order.
		return 0;
	}

	public static function _get_microtime() {
		$mtime = explode( &#039; &#039;, microtime() );
		return $mtime[1] + $mtime[0];
	}

	/**
	 * Make a POST request to the Akismet API.
	 *
	 * @param string $request The body of the request.
	 * @param string $path The path for the request.
	 * @param string $ip The specific IP address to hit.
	 * @return array A two-member array consisting of the headers and the response body, both empty in the case of a failure.
	 */
	public static function http_post( $request, $path, $ip = null ) {

		$akismet_ua = sprintf( &#039;WordPress/%s | Akismet/%s&#039;, $GLOBALS[&#039;wp_version&#039;], constant( &#039;AKISMET_VERSION&#039; ) );
		$akismet_ua = apply_filters( &#039;akismet_ua&#039;, $akismet_ua );

		$host    = self::API_HOST;
		$api_key = self::get_api_key();

		if ( $api_key ) {
			$request = add_query_arg( &#039;api_key&#039;, $api_key, $request );
		}

		$http_host = $host;
		// use a specific IP if provided
		// needed by Akismet_Admin::check_server_connectivity()
		if ( $ip &amp;&amp; long2ip( ip2long( $ip ) ) ) {
			$http_host = $ip;
		}

		$http_args = array(
			&#039;body&#039;        =&gt; $request,
			&#039;headers&#039;     =&gt; array(
				&#039;Content-Type&#039; =&gt; &#039;application/x-www-form-urlencoded; charset=&#039; . get_option( &#039;blog_charset&#039; ),
				&#039;Host&#039;         =&gt; $host,
				&#039;User-Agent&#039;   =&gt; $akismet_ua,
			),
			&#039;httpversion&#039; =&gt; &#039;1.0&#039;,
			&#039;timeout&#039;     =&gt; 15,
		);

		$akismet_url = $http_akismet_url = &quot;http://{$http_host}/1.1/{$path}&quot;;

		/**
		 * Try SSL first; if that fails, try without it and don&#039;t try it again for a while.
		 */

		$ssl = $ssl_failed = false;

		// Check if SSL requests were disabled fewer than X hours ago.
		$ssl_disabled = get_option( &#039;akismet_ssl_disabled&#039; );

		if ( $ssl_disabled &amp;&amp; $ssl_disabled &lt; ( time() - 60 * 60 * 24 ) ) { // 24 hours
			$ssl_disabled = false;
			delete_option( &#039;akismet_ssl_disabled&#039; );
		} elseif ( $ssl_disabled ) {
			do_action( &#039;akismet_ssl_disabled&#039; );
		}

		if ( ! $ssl_disabled &amp;&amp; ( $ssl = wp_http_supports( array( &#039;ssl&#039; ) ) ) ) {
			$akismet_url = set_url_scheme( $akismet_url, &#039;https&#039; );

			do_action( &#039;akismet_https_request_pre&#039; );
		}

		$response = wp_remote_post( $akismet_url, $http_args );

		self::log( compact( &#039;akismet_url&#039;, &#039;http_args&#039;, &#039;response&#039; ) );

		if ( $ssl &amp;&amp; is_wp_error( $response ) ) {
			do_action( &#039;akismet_https_request_failure&#039;, $response );

			// Intermittent connection problems may cause the first HTTPS
			// request to fail and subsequent HTTP requests to succeed randomly.
			// Retry the HTTPS request once before disabling SSL for a time.
			$response = wp_remote_post( $akismet_url, $http_args );

			self::log( compact( &#039;akismet_url&#039;, &#039;http_args&#039;, &#039;response&#039; ) );

			if ( is_wp_error( $response ) ) {
				$ssl_failed = true;

				do_action( &#039;akismet_https_request_failure&#039;, $response );

				do_action( &#039;akismet_http_request_pre&#039; );

				// Try the request again without SSL.
				$response = wp_remote_post( $http_akismet_url, $http_args );

				self::log( compact( &#039;http_akismet_url&#039;, &#039;http_args&#039;, &#039;response&#039; ) );
			}
		}

		if ( is_wp_error( $response ) ) {
			do_action( &#039;akismet_request_failure&#039;, $response );

			return array( &#039;&#039;, &#039;&#039; );
		}

		if ( $ssl_failed ) {
			// The request failed when using SSL but succeeded without it. Disable SSL for future requests.
			update_option( &#039;akismet_ssl_disabled&#039;, time() );

			do_action( &#039;akismet_https_disabled&#039; );
		}

		$simplified_response = array( $response[&#039;headers&#039;], $response[&#039;body&#039;] );

		$alert_code_check_paths = array(
			&#039;verify-key&#039;,
			&#039;comment-check&#039;,
			&#039;get-stats&#039;,
		);

		if ( in_array( $path, $alert_code_check_paths ) ) {
			self::update_alert( $simplified_response );
		}

		return $simplified_response;
	}

	// given a response from an API call like check_key_status(), update the alert code options if an alert is present.
	public static function update_alert( $response ) {
		$alert_option_prefix = &#039;akismet_alert_&#039;;
		$alert_header_prefix = &#039;x-akismet-alert-&#039;;
		$alert_header_names  = array(
			&#039;code&#039;,
			&#039;msg&#039;,
			&#039;api-calls&#039;,
			&#039;usage-limit&#039;,
			&#039;upgrade-plan&#039;,
			&#039;upgrade-url&#039;,
			&#039;upgrade-type&#039;,
			&#039;upgrade-via-support&#039;,
			&#039;recommended-plan-name&#039;,
		);

		foreach ( $alert_header_names as $alert_header_name ) {
			$value = null;
			if ( isset( $response[0][ $alert_header_prefix . $alert_header_name ] ) ) {
				$value = $response[0][ $alert_header_prefix . $alert_header_name ];
			}

			$option_name = $alert_option_prefix . str_replace( &#039;-&#039;, &#039;_&#039;, $alert_header_name );
			if ( $value != get_option( $option_name ) ) {
				if ( ! $value ) {
					delete_option( $option_name );
				} else {
					update_option( $option_name, $value );
				}
			}
		}
	}

	/**
	 * Mark akismet-frontend.js as deferred. Because nothing depends on it, it can run at any time
	 * after it&#039;s loaded, and the browser won&#039;t have to wait for it to load to continue
	 * parsing the rest of the page.
	 */
	public static function set_form_js_async( $tag, $handle, $src ) {
		if ( &#039;akismet-frontend&#039; !== $handle ) {
			return $tag;
		}

		return preg_replace( &#039;/^&lt;script /i&#039;, &#039;&lt;script defer &#039;, $tag );
	}

	public static function get_akismet_form_fields() {
		$fields = &#039;&#039;;

		$prefix = &#039;ak_&#039;;

		// Contact Form 7 uses _wpcf7 as a prefix to know which fields to exclude from comment_content.
		if ( &#039;wpcf7_form_elements&#039; === current_filter() ) {
			$prefix = &#039;_wpcf7_ak_&#039;;
		}

		$fields .= &#039;&lt;p style=&quot;display: none !important;&quot; class=&quot;akismet-fields-container&quot; data-prefix=&quot;&#039; . esc_attr( $prefix ) . &#039;&quot;&gt;&#039;;
		$fields .= &#039;&lt;label&gt;&amp;#916;&lt;textarea name=&quot;&#039; . $prefix . &#039;hp_textarea&quot; cols=&quot;45&quot; rows=&quot;8&quot; maxlength=&quot;100&quot;&gt;&lt;/textarea&gt;&lt;/label&gt;&#039;;

		if ( ! function_exists( &#039;amp_is_request&#039; ) || ! amp_is_request() ) {
			// Keep track of how many ak_js fields are in this page so that we don&#039;t re-use
			// the same ID.
			static $field_count = 0;

			++$field_count;

			$fields .= &#039;&lt;input type=&quot;hidden&quot; id=&quot;ak_js_&#039; . $field_count . &#039;&quot; name=&quot;&#039; . $prefix . &#039;js&quot; value=&quot;&#039; . mt_rand( 0, 250 ) . &#039;&quot;/&gt;&#039;;
			$fields .= wp_get_inline_script_tag( &#039;document.getElementById( &quot;ak_js_&#039; . $field_count . &#039;&quot; ).setAttribute( &quot;value&quot;, ( new Date() ).getTime() );&#039; );
		}

		$fields .= &#039;&lt;/p&gt;&#039;;

		return $fields;
	}

	public static function output_custom_form_fields( $post_id ) {
		if ( &#039;fluentform/form_element_start&#039; === current_filter() &amp;&amp; did_action( &#039;fluentform_form_element_start&#039; ) ) {
			// Already did this via the legacy filter.
			return;
		}

		// phpcs:ignore WordPress.Security.EscapeOutput
		echo self::get_akismet_form_fields();
	}

	public static function inject_custom_form_fields( $html ) {
		$html = str_replace( &#039;&lt;/form&gt;&#039;, self::get_akismet_form_fields() . &#039;&lt;/form&gt;&#039;, $html );

		return $html;
	}

	public static function append_custom_form_fields( $html ) {
		$html .= self::get_akismet_form_fields();

		return $html;
	}

	/**
	 * Ensure that any Akismet-added form fields are included in the comment-check call.
	 *
	 * @param array $form
	 * @param array $data Some plugins will supply the POST data via the filter, since they don&#039;t
	 *                    read it directly from $_POST.
	 * @return array $form
	 */
	public static function prepare_custom_form_values( $form, $data = null ) {
		// did_filter() is WP 6.1+. Older versions don&#039;t store filter history.
		if ( &#039;fluentform/akismet_fields&#039; === current_filter() &amp;&amp; function_exists( &#039;did_filter&#039; ) &amp;&amp; did_filter( &#039;fluentform_akismet_fields&#039; ) ) {
			// Already updated the form fields via the legacy filter.
			return $form;
		}

		if ( is_null( $data ) ) {
			// phpcs:ignore WordPress.Security.NonceVerification.Missing
			$data = $_POST;
		}

		$prefix = &#039;ak_&#039;;

		// Contact Form 7 uses _wpcf7 as a prefix to know which fields to exclude from comment_content.
		if ( &#039;wpcf7_akismet_parameters&#039; === current_filter() ) {
			$prefix = &#039;_wpcf7_ak_&#039;;
		}

		foreach ( $data as $key =&gt; $val ) {
			if ( 0 === strpos( $key, $prefix ) ) {
				$form[ &#039;POST_ak_&#039; . substr( $key, strlen( $prefix ) ) ] = $val;
			}
		}

		return $form;
	}

	private static function bail_on_activation( $message, $deactivate = true ) {
		?&gt;
&lt;!doctype html&gt;
&lt;html&gt;
&lt;head&gt;
&lt;meta charset=&quot;&lt;?php bloginfo( &#039;charset&#039; ); ?&gt;&quot; /&gt;
&lt;style&gt;
* {
	text-align: center;
	margin: 0;
	padding: 0;
	font-family: &quot;Lucida Grande&quot;,Verdana,Arial,&quot;Bitstream Vera Sans&quot;,sans-serif;
}
p {
	margin-top: 1em;
	font-size: 18px;
}
&lt;/style&gt;
&lt;/head&gt;
&lt;body&gt;
&lt;p&gt;&lt;?php echo esc_html( $message ); ?&gt;&lt;/p&gt;
&lt;/body&gt;
&lt;/html&gt;
		&lt;?php
		if ( $deactivate ) {
			$plugins = get_option( &#039;active_plugins&#039; );
			$akismet = plugin_basename( AKISMET__PLUGIN_DIR . &#039;akismet.php&#039; );
			$update  = false;
			foreach ( $plugins as $i =&gt; $plugin ) {
				if ( $plugin === $akismet ) {
					$plugins[ $i ] = false;
					$update        = true;
				}
			}

			if ( $update ) {
				update_option( &#039;active_plugins&#039;, array_filter( $plugins ) );
			}
		}
		exit;
	}

	public static function view( $name, array $args = array() ) {
		$args = apply_filters( &#039;akismet_view_arguments&#039;, $args, $name );

		foreach ( $args as $key =&gt; $val ) {
			$$key = $val;
		}

		$file = AKISMET__PLUGIN_DIR . &#039;views/&#039; . basename( $name ) . &#039;.php&#039;;

		if ( file_exists( $file ) ) {
			include $file;
		}
	}

	/**
	 * Attached to activate_{ plugin_basename( __FILES__ ) } by register_activation_hook()
	 *
	 * @static
	 */
	public static function plugin_activation() {
		if ( version_compare( $GLOBALS[&#039;wp_version&#039;], AKISMET__MINIMUM_WP_VERSION, &#039;&lt;&#039; ) ) {
			$message = &#039;&lt;strong&gt;&#039; .
				/* translators: 1: Current Akismet version number, 2: Minimum WordPress version number required. */
				sprintf( esc_html__( &#039;Akismet %1$s requires WordPress %2$s or higher.&#039;, &#039;akismet&#039; ), AKISMET_VERSION, AKISMET__MINIMUM_WP_VERSION ) . &#039;&lt;/strong&gt; &#039; .
				/* translators: 1: WordPress documentation URL, 2: Akismet download URL. */
				sprintf( __( &#039;Please &lt;a href=&quot;%1$s&quot;&gt;upgrade WordPress&lt;/a&gt; to a current version, or &lt;a href=&quot;%2$s&quot;&gt;downgrade to version 2.4 of the Akismet plugin&lt;/a&gt;.&#039;, &#039;akismet&#039; ), &#039;https://codex.wordpress.org/Upgrading_WordPress&#039;, &#039;https://wordpress.org/plugins/akismet&#039; );

			self::bail_on_activation( $message );
		} elseif ( ! empty( $_SERVER[&#039;SCRIPT_NAME&#039;] ) &amp;&amp; false !== strpos( $_SERVER[&#039;SCRIPT_NAME&#039;], &#039;/wp-admin/plugins.php&#039; ) ) {
			add_option( &#039;Activated_Akismet&#039;, true );
		}
	}

	/**
	 * Removes all connection options
	 *
	 * @static
	 */
	public static function plugin_deactivation() {
		self::deactivate_key( self::get_api_key() );

		// Remove any scheduled cron jobs.
		$akismet_cron_events = array(
			&#039;akismet_schedule_cron_recheck&#039;,
			&#039;akismet_scheduled_delete&#039;,
		);

		foreach ( $akismet_cron_events as $akismet_cron_event ) {
			$timestamp = wp_next_scheduled( $akismet_cron_event );

			if ( $timestamp ) {
				wp_unschedule_event( $timestamp, $akismet_cron_event );
			}
		}
	}

	/**
	 * Essentially a copy of WP&#039;s build_query but one that doesn&#039;t expect pre-urlencoded values.
	 *
	 * @param array $args An array of key =&gt; value pairs
	 * @return string A string ready for use as a URL query string.
	 */
	public static function build_query( $args ) {
		return _http_build_query( $args, &#039;&#039;, &#039;&amp;&#039; );
	}

	/**
	 * Log debugging info to the error log.
	 *
	 * Enabled when WP_DEBUG_LOG is enabled (and WP_DEBUG, since according to
	 * core, &quot;WP_DEBUG_DISPLAY and WP_DEBUG_LOG perform no function unless
	 * WP_DEBUG is true), but can be disabled via the akismet_debug_log filter.
	 *
	 * @param mixed $akismet_debug The data to log.
	 */
	public static function log( $akismet_debug ) {
		if ( apply_filters( &#039;akismet_debug_log&#039;, defined( &#039;WP_DEBUG&#039; ) &amp;&amp; WP_DEBUG &amp;&amp; defined( &#039;WP_DEBUG_LOG&#039; ) &amp;&amp; WP_DEBUG_LOG &amp;&amp; defined( &#039;AKISMET_DEBUG&#039; ) &amp;&amp; AKISMET_DEBUG ) ) {
			error_log( print_r( compact( &#039;akismet_debug&#039; ), true ) );
		}
	}

	/**
	 * Check pingbacks for spam before they&#039;re saved to the DB.
	 *
	 * @param string           $method The XML-RPC method that was called.
	 * @param array            $args This and the $server arg are marked as optional since plugins might still be
	 *                               calling do_action( &#039;xmlrpc_action&#039;, [...] ) without the arguments that were added in WP 5.7.
	 * @param wp_xmlrpc_server $server
	 */
	public static function pre_check_pingback( $method, $args = array(), $server = null ) {
		if ( $method !== &#039;pingback.ping&#039; ) {
			return;
		}

		/*
		 * $args looks like this:
		 *
		 * Array
		 * (
		 *     [0] =&gt; http://www.example.net/?p=1 // Site that created the pingback.
		 *     [1] =&gt; https://www.example.com/?p=2 // Post being pingback&#039;d on this site.
		 * )
		 */

		if ( ! is_null( $server ) &amp;&amp; ! empty( $args[1] ) ) {
			$is_multicall    = false;
			$multicall_count = 0;

			if ( &#039;system.multicall&#039; === $server-&gt;message-&gt;methodName ) {
				$is_multicall    = true;
				$multicall_count = is_countable( $server-&gt;message-&gt;params ) ? count( $server-&gt;message-&gt;params ) : 0;
			}

			$post_id = url_to_postid( $args[1] );

			// If pingbacks aren&#039;t open on this post, we&#039;ll still check whether this request is part of a potential DDOS,
			// but indicate to the server that pingbacks are indeed closed so we don&#039;t include this request in the user&#039;s stats,
			// since the user has already done their part by disabling pingbacks.
			$pingbacks_closed = false;

			$post = get_post( $post_id );

			if ( ! $post || ! pings_open( $post ) ) {
				$pingbacks_closed = true;
			}

			$comment = array(
				&#039;comment_author_url&#039;      =&gt; $args[0],
				&#039;comment_post_ID&#039;         =&gt; $post_id,
				&#039;comment_author&#039;          =&gt; &#039;&#039;,
				&#039;comment_author_email&#039;    =&gt; &#039;&#039;,
				&#039;comment_content&#039;         =&gt; &#039;&#039;,
				&#039;comment_type&#039;            =&gt; &#039;pingback&#039;,
				&#039;akismet_pre_check&#039;       =&gt; &#039;1&#039;,
				&#039;comment_pingback_target&#039; =&gt; $args[1],
				&#039;pingbacks_closed&#039;        =&gt; $pingbacks_closed ? &#039;1&#039; : &#039;0&#039;,
				&#039;is_multicall&#039;            =&gt; $is_multicall,
				&#039;multicall_count&#039;         =&gt; $multicall_count,
			);

			$comment = self::auto_check_comment( $comment, &#039;xml-rpc&#039; );

			if ( isset( $comment[&#039;akismet_result&#039;] ) &amp;&amp; &#039;true&#039; == $comment[&#039;akismet_result&#039;] ) {
				// Sad: tightly coupled with the IXR classes. Unfortunately the action provides no context and no way to return anything.
				$server-&gt;error( new IXR_Error( 0, &#039;Invalid discovery target&#039; ) );

				// Also note that if this was part of a multicall, a spam result will prevent the subsequent calls from being executed.
				// This is probably fine, but it raises the bar for what should be acceptable as a false positive.
			}
		}
	}

	/**
	 * Ensure that we are loading expected scalar values from akismet_as_submitted commentmeta.
	 *
	 * @param mixed $meta_value
	 * @return mixed
	 */
	private static function sanitize_comment_as_submitted( $meta_value ) {
		if ( empty( $meta_value ) ) {
			return $meta_value;
		}

		$meta_value = (array) $meta_value;

		foreach ( $meta_value as $key =&gt; $value ) {
			if ( ! is_scalar( $value ) ) {
				unset( $meta_value[ $key ] );
			} else {
				// These can change, so they&#039;re not explicitly listed in comment_as_submitted_allowed_keys.
				if ( strpos( $key, &#039;POST_ak_&#039; ) === 0 ) {
					continue;
				}

				if ( ! isset( self::$comment_as_submitted_allowed_keys[ $key ] ) ) {
					unset( $meta_value[ $key ] );
				}
			}
		}

		return $meta_value;
	}

	public static function predefined_api_key() {
		if ( defined( &#039;WPCOM_API_KEY&#039; ) ) {
			return true;
		}

		return apply_filters( &#039;akismet_predefined_api_key&#039;, false );
	}

	/**
	 * Controls the display of a privacy related notice underneath the comment
	 * form using the `akismet_comment_form_privacy_notice` option and filter
	 * respectively.
	 *
	 * Default is to not display the notice, leaving the choice to site admins,
	 * or integrators.
	 */
	public static function display_comment_form_privacy_notice() {
		if ( &#039;display&#039; !== apply_filters( &#039;akismet_comment_form_privacy_notice&#039;, get_option( &#039;akismet_comment_form_privacy_notice&#039;, &#039;hide&#039; ) ) ) {
			return;
		}

		echo apply_filters(
			&#039;akismet_comment_form_privacy_notice_markup&#039;,
			&#039;&lt;p class=&quot;akismet_comment_form_privacy_notice&quot;&gt;&#039; .
				wp_kses(
					sprintf(
						/* translators: %s: Akismet privacy URL */
						__( &#039;This site uses Akismet to reduce spam. &lt;a href=&quot;%s&quot; target=&quot;_blank&quot; rel=&quot;nofollow noopener&quot;&gt;Learn how your comment data is processed.&lt;/a&gt;&#039;, &#039;akismet&#039; ),
						&#039;https://akismet.com/privacy/&#039;
					),
					array(
						&#039;a&#039; =&gt; array(
							&#039;href&#039;   =&gt; array(),
							&#039;target&#039; =&gt; array(),
							&#039;rel&#039;    =&gt; array(),
						),
					)
				) .
			&#039;&lt;/p&gt;&#039;
		);
	}

	public static function load_form_js() {
		if (
			! is_admin()
			&amp;&amp; ( ! function_exists( &#039;amp_is_request&#039; ) || ! amp_is_request() )
			&amp;&amp; self::get_api_key()
			) {
			wp_register_script( &#039;akismet-frontend&#039;, plugin_dir_url( __FILE__ ) . &#039;_inc/akismet-frontend.js&#039;, array(), filemtime( plugin_dir_path( __FILE__ ) . &#039;_inc/akismet-frontend.js&#039; ), true );
			wp_enqueue_script( &#039;akismet-frontend&#039; );
		}
	}

	/**
	 * Add the form JavaScript when we detect that a supported form shortcode is being parsed.
	 */
	public static function load_form_js_via_filter( $return_value, $tag, $attr, $m ) {
		if ( in_array( $tag, array( &#039;contact-form&#039;, &#039;gravityform&#039;, &#039;contact-form-7&#039;, &#039;formidable&#039;, &#039;fluentform&#039; ) ) ) {
			self::load_form_js();
		}

		return $return_value;
	}

	/**
	 * Was the last entry in the comment history created by Akismet?
	 *
	 * @param int $comment_id The ID of the comment.
	 * @return bool
	 */
	public static function last_comment_status_change_came_from_akismet( $comment_id ) {
		$history = self::get_comment_history( $comment_id );

		if ( empty( $history ) ) {
			return false;
		}

		$most_recent_history_event = $history[0];

		if ( ! isset( $most_recent_history_event[&#039;event&#039;] ) ) {
			return false;
		}

		$akismet_history_events = array(
			&#039;check-error&#039;,
			&#039;cron-retry-ham&#039;,
			&#039;cron-retry-spam&#039;,
			&#039;check-ham&#039;,
			&#039;check-ham-pending&#039;,
			&#039;check-spam&#039;,
			&#039;recheck-error&#039;,
			&#039;recheck-ham&#039;,
			&#039;recheck-spam&#039;,
			&#039;webhook-ham&#039;,
			&#039;webhook-spam&#039;,
		);

		if ( in_array( $most_recent_history_event[&#039;event&#039;], $akismet_history_events ) ) {
			return true;
		}

		return false;
	}

	/**
	 * Check the comment history to find out what the most recent comment-check
	 * response said about this comment.
	 *
	 * This value is then included in submit-ham and submit-spam requests to allow
	 * us to know whether the comment is actually a missed spam/ham or if it&#039;s
	 * just being reclassified after either never being checked or being mistakenly
	 * marked as ham/spam.
	 *
	 * @param int $comment_id The comment ID.
	 * @return string &#039;true&#039;, &#039;false&#039;, or an empty string if we don&#039;t have a record
	 *                of comment-check being called.
	 */
	public static function last_comment_check_response( $comment_id ) {
		$history = self::get_comment_history( $comment_id );

		if ( $history ) {
			$history = array_reverse( $history );

			foreach ( $history as $akismet_history_entry ) {
				// We&#039;ve always been consistent in how history entries are formatted
				// but comment_meta is writable by everyone, so don&#039;t assume that all
				// entries contain the expected parts.

				if ( ! is_array( $akismet_history_entry ) ) {
					continue;
				}

				if ( ! isset( $akismet_history_entry[&#039;event&#039;] ) ) {
					continue;
				}

				if ( in_array(
					$akismet_history_entry[&#039;event&#039;],
					array(
						&#039;recheck-spam&#039;,
						&#039;check-spam&#039;,
						&#039;cron-retry-spam&#039;,
						&#039;webhook-spam&#039;,
						&#039;webhook-spam-noaction&#039;,
					),
					true
				) ) {
					return &#039;true&#039;;
				} elseif ( in_array(
					$akismet_history_entry[&#039;event&#039;],
					array(
						&#039;recheck-ham&#039;,
						&#039;check-ham&#039;,
						&#039;cron-retry-ham&#039;,
						&#039;webhook-ham&#039;,
						&#039;webhook-ham-noaction&#039;,
					),
					true
				) ) {
					return &#039;false&#039;;
				}
			}
		}

		return &#039;&#039;;
	}
}
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fpublic_html%2Fyogitonics.com%2Fwp-content%2Fplugins%2Fakismet'>⬅ Back to Directory</a>