<?php

/**

 * These functions can be replaced via plugins. If plugins do not redefine these

 * functions, then these will be used instead.

 *

 * @package WordPress

 */

if ( ! function_exists( 'wp_set_current_user' ) ) :

	/**

	 * Changes the current user by ID or name.

	 *

	 * Set $id to null and specify a name if you do not know a user's ID.

	 *

	 * Some WordPress functionality is based on the current user and not based on

	 * the signed in user. Therefore, it opens the ability to edit and perform

	 * actions on users who aren't signed in.

	 *

	 * @since 2.0.3

	 *

	 * @global WP_User $current_user The current user object which holds the user data.

	 *

	 * @param int|null $id   User ID.

	 * @param string   $name User's username.

	 * @return WP_User Current user User object.

	 */

	function wp_set_current_user( $id, $name = '' ) {

		global $current_user;

		// If `$id` matches the current user, there is nothing to do.

		if ( isset( $current_user )

		&& ( $current_user instanceof WP_User )

		&& ( $id === $current_user->ID )

		&& ( null !== $id )

		) {

			return $current_user;

		}

		$current_user = new WP_User( $id, $name );

		setup_userdata( $current_user->ID );

		/**

		 * Fires after the current user is set.

		 *

		 * @since 2.0.1

		 */

		do_action( 'set_current_user' );

		return $current_user;

	}

endif;

if ( ! function_exists( 'wp_get_current_user' ) ) :

	/**

	 * Retrieves the current user object.

	 *

	 * Will set the current user, if the current user is not set. The current user

	 * will be set to the logged-in person. If no user is logged-in, then it will

	 * set the current user to 0, which is invalid and won't have any permissions.

	 *

	 * @since 2.0.3

	 *

	 * @see _wp_get_current_user()

	 * @global WP_User $current_user Checks if the current user is set.

	 *

	 * @return WP_User Current WP_User instance.

	 */

	function wp_get_current_user() {

		return _wp_get_current_user();

	}

endif;

if ( ! function_exists( 'get_userdata' ) ) :

	/**

	 * Retrieves user info by user ID.

	 *

	 * @since 0.71

	 *

	 * @param int $user_id User ID

	 * @return WP_User|false WP_User object on success, false on failure.

	 */

	function get_userdata( $user_id ) {

		return get_user_by( 'id', $user_id );

	}

endif;

if ( ! function_exists( 'get_user_by' ) ) :

	/**

	 * Retrieves user info by a given field.

	 *

	 * @since 2.8.0

	 * @since 4.4.0 Added 'ID' as an alias of 'id' for the `$field` parameter.

	 *

	 * @global WP_User $current_user The current user object which holds the user data.

	 *

	 * @param string     $field The field to retrieve the user with. id | ID | slug | email | login.

	 * @param int|string $value A value for $field. A user ID, slug, email address, or login name.

	 * @return WP_User|false WP_User object on success, false on failure.

	 */

	function get_user_by( $field, $value ) {

		$userdata = WP_User::get_data_by( $field, $value );

		if ( ! $userdata ) {

			return false;

		}

		$user = new WP_User();

		$user->init( $userdata );

		return $user;

	}

endif;

if ( ! function_exists( 'cache_users' ) ) :

	/**

	 * Retrieves info for user lists to prevent multiple queries by get_userdata().

	 *

	 * @since 3.0.0

	 *

	 * @global wpdb $wpdb WordPress database abstraction object.

	 *

	 * @param int[] $user_ids User ID numbers list

	 */

	function cache_users( $user_ids ) {

		global $wpdb;

		update_meta_cache( 'user', $user_ids );

		$clean = _get_non_cached_ids( $user_ids, 'users' );

		if ( empty( $clean ) ) {

			return;

		}

		$list = implode( ',', $clean );

		$users = $wpdb->get_results( "SELECT * FROM $wpdb->users WHERE ID IN ($list)" );

		foreach ( $users as $user ) {

			update_user_caches( $user );

		}

	}

endif;

if ( ! function_exists( 'wp_mail' ) ) :

	/**

	 * Sends an email, similar to PHP's mail function.

	 *

	 * A true return value does not automatically mean that the user received the

	 * email successfully. It just only means that the method used was able to

	 * process the request without any errors.

	 *

	 * The default content type is `text/plain` which does not allow using HTML.

	 * However, you can set the content type of the email by using the

	 * {@see 'wp_mail_content_type'} filter.

	 *

	 * The default charset is based on the charset used on the blog. The charset can

	 * be set using the {@see 'wp_mail_charset'} filter.

	 *

	 * @since 1.2.1

	 * @since 5.5.0 is_email() is used for email validation,

	 *              instead of PHPMailer's default validator.

	 *

	 * @global PHPMailer\PHPMailer\PHPMailer $phpmailer

	 *

	 * @param string|string[] $to          Array or comma-separated list of email addresses to send message.

	 * @param string          $subject     Email subject.

	 * @param string          $message     Message contents.

	 * @param string|string[] $headers     Optional. Additional headers.

	 * @param string|string[] $attachments Optional. Paths to files to attach.

	 * @return bool Whether the email was sent successfully.

	 */

	function wp_mail( $to, $subject, $message, $headers = '', $attachments = array() ) {

		// Compact the input, apply the filters, and extract them back out.

		/**

		 * Filters the wp_mail() arguments.

		 *

		 * @since 2.2.0

		 *

		 * @param array $args {

		 *     Array of the `wp_mail()` arguments.

		 *

		 *     @type string|string[] $to          Array or comma-separated list of email addresses to send message.

		 *     @type string          $subject     Email subject.

		 *     @type string          $message     Message contents.

		 *     @type string|string[] $headers     Additional headers.

		 *     @type string|string[] $attachments Paths to files to attach.

		 * }

		 */

		$atts = apply_filters( 'wp_mail', compact( 'to', 'subject', 'message', 'headers', 'attachments' ) );

		/**

		 * Filters whether to preempt sending an email.

		 *

		 * Returning a non-null value will short-circuit {@see wp_mail()}, returning

		 * that value instead. A boolean return value should be used to indicate whether

		 * the email was successfully sent.

		 *

		 * @since 5.7.0

		 *

		 * @param null|bool $return Short-circuit return value.

		 * @param array     $atts {

		 *     Array of the `wp_mail()` arguments.

		 *

		 *     @type string|string[] $to          Array or comma-separated list of email addresses to send message.

		 *     @type string          $subject     Email subject.

		 *     @type string          $message     Message contents.

		 *     @type string|string[] $headers     Additional headers.

		 *     @type string|string[] $attachments Paths to files to attach.

		 * }

		 */

		$pre_wp_mail = apply_filters( 'pre_wp_mail', null, $atts );

		if ( null !== $pre_wp_mail ) {

			return $pre_wp_mail;

		}

		if ( isset( $atts['to'] ) ) {

			$to = $atts['to'];

		}

		if ( ! is_array( $to ) ) {

			$to = explode( ',', $to );

		}

		if ( isset( $atts['subject'] ) ) {

			$subject = $atts['subject'];

		}

		if ( isset( $atts['message'] ) ) {

			$message = $atts['message'];

		}

		if ( isset( $atts['headers'] ) ) {

			$headers = $atts['headers'];

		}

		if ( isset( $atts['attachments'] ) ) {

			$attachments = $atts['attachments'];

		}

		if ( ! is_array( $attachments ) ) {

			$attachments = explode( "\n", str_replace( "\r\n", "\n", $attachments ) );

		}

		global $phpmailer;

		// (Re)create it, if it's gone missing.

		if ( ! ( $phpmailer instanceof PHPMailer\PHPMailer\PHPMailer ) ) {

			require_once ABSPATH . WPINC . '/PHPMailer/PHPMailer.php';

			require_once ABSPATH . WPINC . '/PHPMailer/SMTP.php';

			require_once ABSPATH . WPINC . '/PHPMailer/Exception.php';

			require_once ABSPATH . WPINC . '/class-wp-phpmailer.php';

			$phpmailer = new WP_PHPMailer( true );

			$phpmailer::$validator = static function ( $email ) {

				return (bool) is_email( $email );

			};

		}

		// Headers.

		$cc       = array();

		$bcc      = array();

		$reply_to = array();

		if ( empty( $headers ) ) {

			$headers = array();

		} else {

			if ( ! is_array( $headers ) ) {

				/*

				 * Explode the headers out, so this function can take

				 * both string headers and an array of headers.

				 */

				$tempheaders = explode( "\n", str_replace( "\r\n", "\n", $headers ) );

			} else {

				$tempheaders = $headers;

			}

			$headers = array();

			// If it's actually got contents.

			if ( ! empty( $tempheaders ) ) {

				// Iterate through the raw headers.

				foreach ( (array) $tempheaders as $header ) {

					if ( ! str_contains( $header, ':' ) ) {

						if ( false !== stripos( $header, 'boundary=' ) ) {

							$parts    = preg_split( '/boundary=/i', trim( $header ) );

							$boundary = trim( str_replace( array( "'", '"' ), '', $parts[1] ) );

						}

						continue;

					}

					// Explode them out.

					list( $name, $content ) = explode( ':', trim( $header ), 2 );

					// Cleanup crew.

					$name    = trim( $name );

					$content = trim( $content );

					switch ( strtolower( $name ) ) {

						// Mainly for legacy -- process a "From:" header if it's there.

						case 'from':

							$bracket_pos = strpos( $content, '<' );

							if ( false !== $bracket_pos ) {

								// Text before the bracketed email is the "From" name.

								if ( $bracket_pos > 0 ) {

									$from_name = substr( $content, 0, $bracket_pos );

									$from_name = str_replace( '"', '', $from_name );

									$from_name = trim( $from_name );

								}

								$from_email = substr( $content, $bracket_pos + 1 );

								$from_email = str_replace( '>', '', $from_email );

								$from_email = trim( $from_email );

								// Avoid setting an empty $from_email.

							} elseif ( '' !== trim( $content ) ) {

								$from_email = trim( $content );

							}

							break;

						case 'content-type':

							if ( str_contains( $content, ';' ) ) {

								list( $type, $charset_content ) = explode( ';', $content );

								$content_type                   = trim( $type );

								if ( false !== stripos( $charset_content, 'charset=' ) ) {

									$charset = trim( str_replace( array( 'charset=', '"' ), '', $charset_content ) );

								} elseif ( false !== stripos( $charset_content, 'boundary=' ) ) {

									$boundary = trim( str_replace( array( 'BOUNDARY=', 'boundary=', '"' ), '', $charset_content ) );

									$charset  = '';

								}

								// Avoid setting an empty $content_type.

							} elseif ( '' !== trim( $content ) ) {

								$content_type = trim( $content );

							}

							break;

						case 'cc':

							$cc = array_merge( (array) $cc, explode( ',', $content ) );

							break;

						case 'bcc':

							$bcc = array_merge( (array) $bcc, explode( ',', $content ) );

							break;

						case 'reply-to':

							$reply_to = array_merge( (array) $reply_to, explode( ',', $content ) );

							break;

						default:

							// Add it to our grand headers array.

							$headers[ trim( $name ) ] = trim( $content );

							break;

					}

				}

			}

		}

		// Empty out the values that may be set.

		$phpmailer->clearAllRecipients();

		$phpmailer->clearAttachments();

		$phpmailer->clearCustomHeaders();

		$phpmailer->clearReplyTos();

		$phpmailer->Body    = '';

		$phpmailer->AltBody = '';

		// Set "From" name and email.

		// If we don't have a name from the input headers.

		if ( ! isset( $from_name ) ) {

			$from_name = 'WordPress';

		}

		/*

		 * If we don't have an email from the input headers, default to wordpress@$sitename

		 * Some hosts will block outgoing mail from this address if it doesn't exist,

		 * but there's no easy alternative. Defaulting to admin_email might appear to be

		 * another option, but some hosts may refuse to relay mail from an unknown domain.

		 * See https://core.trac.wordpress.org/ticket/5007.

		 */

		if ( ! isset( $from_email ) ) {

			// Get the site domain and get rid of www.

			$sitename   = wp_parse_url( network_home_url(), PHP_URL_HOST );

			$from_email = 'wordpress@';

			if ( null !== $sitename ) {

				if ( str_starts_with( $sitename, 'www.' ) ) {

					$sitename = substr( $sitename, 4 );

				}

				$from_email .= $sitename;

			}

		}

		/**

		 * Filters the email address to send from.

		 *

		 * @since 2.2.0

		 *

		 * @param string $from_email Email address to send from.

		 */

		$from_email = apply_filters( 'wp_mail_from', $from_email );

		/**

		 * Filters the name to associate with the "from" email address.

		 *

		 * @since 2.3.0

		 *

		 * @param string $from_name Name associated with the "from" email address.

		 */

		$from_name = apply_filters( 'wp_mail_from_name', $from_name );

		try {

			$phpmailer->setFrom( $from_email, $from_name, false );

		} catch ( PHPMailer\PHPMailer\Exception $e ) {

			$mail_error_data                             = compact( 'to', 'subject', 'message', 'headers', 'attachments' );

			$mail_error_data['phpmailer_exception_code'] = $e->getCode();

			/** This filter is documented in wp-includes/pluggable.php */

			do_action( 'wp_mail_failed', new WP_Error( 'wp_mail_failed', $e->getMessage(), $mail_error_data ) );

			return false;

		}

		// Set mail's subject and body.

		$phpmailer->Subject = $subject;

		$phpmailer->Body    = $message;

		// Set destination addresses, using appropriate methods for handling addresses.

		$address_headers = compact( 'to', 'cc', 'bcc', 'reply_to' );

		foreach ( $address_headers as $address_header => $addresses ) {

			if ( empty( $addresses ) ) {

				continue;

			}

			foreach ( (array) $addresses as $address ) {

				try {

					// Break $recipient into name and address parts if in the format "Foo <bar@baz.com>".

					$recipient_name = '';

					if ( preg_match( '/(.*)<(.+)>/', $address, $matches ) ) {

						if ( count( $matches ) === 3 ) {

							$recipient_name = $matches[1];

							$address        = $matches[2];

						}

					}

					switch ( $address_header ) {

						case 'to':

							$phpmailer->addAddress( $address, $recipient_name );

							break;

						case 'cc':

							$phpmailer->addCc( $address, $recipient_name );

							break;

						case 'bcc':

							$phpmailer->addBcc( $address, $recipient_name );

							break;

						case 'reply_to':

							$phpmailer->addReplyTo( $address, $recipient_name );

							break;

					}

				} catch ( PHPMailer\PHPMailer\Exception $e ) {

					continue;

				}

			}

		}

		// Set to use PHP's mail().

		$phpmailer->isMail();

		// Set Content-Type and charset.

		// If we don't have a Content-Type from the input headers.

		if ( ! isset( $content_type ) ) {

			$content_type = 'text/plain';

		}

		/**

		 * Filters the wp_mail() content type.

		 *

		 * @since 2.3.0

		 *

		 * @param string $content_type Default wp_mail() content type.

		 */

		$content_type = apply_filters( 'wp_mail_content_type', $content_type );

		$phpmailer->ContentType = $content_type;

		// Set whether it's plaintext, depending on $content_type.

		if ( 'text/html' === $content_type ) {

			$phpmailer->isHTML( true );

		}