<?php

/**

 * Main WordPress API

 *

 * @package WordPress

 */

require( ABSPATH . WPINC . '/option.php' );

/**

 * Convert given date string into a different format.

 *

 * $format should be either a PHP date format string, e.g. 'U' for a Unix

 * timestamp, or 'G' for a Unix timestamp assuming that $date is GMT.

 *

 * If $translate is true then the given date and format string will

 * be passed to date_i18n() for translation.

 *

 * @since 0.71

 *

 * @param string $format    Format of the date to return.

 * @param string $date      Date string to convert.

 * @param bool   $translate Whether the return date should be translated. Default true.

 * @return string|int|bool Formatted date string or Unix timestamp. False if $date is empty.

 */

function mysql2date( $format, $date, $translate = true ) {

	if ( empty( $date ) ) {

		return false;

	}

	if ( 'G' == $format ) {

		return strtotime( $date . ' +0000' );

	}

	$i = strtotime( $date );

	if ( 'U' == $format ) {

		return $i;

	}

	if ( $translate ) {

		return date_i18n( $format, $i );

	} else {

		return date( $format, $i );

	}

}

/**

 * Retrieve the current time based on specified type.

 *

 * The 'mysql' type will return the time in the format for MySQL DATETIME field.

 * The 'timestamp' type will return the current timestamp.

 * Other strings will be interpreted as PHP date formats (e.g. 'Y-m-d').

 *

 * If $gmt is set to either '1' or 'true', then both types will use GMT time.

 * if $gmt is false, the output is adjusted with the GMT offset in the WordPress option.

 *

 * @since 1.0.0

 *

 * @param string   $type Type of time to retrieve. Accepts 'mysql', 'timestamp', or PHP date

 *                       format string (e.g. 'Y-m-d').

 * @param int|bool $gmt  Optional. Whether to use GMT timezone. Default false.

 * @return int|string Integer if $type is 'timestamp', string otherwise.

 */

function current_time( $type, $gmt = 0 ) {

	switch ( $type ) {

		case 'mysql':

			return ( $gmt ) ? gmdate( 'Y-m-d H:i:s' ) : gmdate( 'Y-m-d H:i:s', ( time() + ( get_option( 'gmt_offset' ) * HOUR_IN_SECONDS ) ) );

		case 'timestamp':

			return ( $gmt ) ? time() : time() + ( get_option( 'gmt_offset' ) * HOUR_IN_SECONDS );

		default:

			return ( $gmt ) ? gmdate( $type ) : gmdate( $type, time() + ( get_option( 'gmt_offset' ) * HOUR_IN_SECONDS ) );

	}

}

/**

 * Retrieve the date in localized format, based on a sum of Unix timestamp and

 * timezone offset in seconds.

 *

 * If the locale specifies the locale month and weekday, then the locale will

 * take over the format for the date. If it isn't, then the date format string

 * will be used instead.

 *

 * @since 0.71

 *

 * @global WP_Locale $wp_locale

 *

 * @param string   $dateformatstring      Format to display the date.

 * @param int|bool $timestamp_with_offset Optional. A sum of Unix timestamp and timezone offset in seconds.

 *                                        Default false.

 * @param bool     $gmt                   Optional. Whether to use GMT timezone. Only applies if timestamp is

 *                                        not provided. Default false.

 *

 * @return string The date, translated if locale specifies it.

 */

function date_i18n( $dateformatstring, $timestamp_with_offset = false, $gmt = false ) {

	global $wp_locale;

	$i = $timestamp_with_offset;

	if ( false === $i ) {

		$i = current_time( 'timestamp', $gmt );

	}

	/*

	 * Store original value for language with untypical grammars.

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

	 */

	$req_format = $dateformatstring;

	$dateformatstring = preg_replace( '/(?<!\\\\)c/', DATE_W3C, $dateformatstring );

	$dateformatstring = preg_replace( '/(?<!\\\\)r/', DATE_RFC2822, $dateformatstring );

	if ( ( ! empty( $wp_locale->month ) ) && ( ! empty( $wp_locale->weekday ) ) ) {

		$datemonth            = $wp_locale->get_month( date( 'm', $i ) );

		$datemonth_abbrev     = $wp_locale->get_month_abbrev( $datemonth );

		$dateweekday          = $wp_locale->get_weekday( date( 'w', $i ) );

		$dateweekday_abbrev   = $wp_locale->get_weekday_abbrev( $dateweekday );

		$datemeridiem         = $wp_locale->get_meridiem( date( 'a', $i ) );

		$datemeridiem_capital = $wp_locale->get_meridiem( date( 'A', $i ) );

		$dateformatstring     = ' ' . $dateformatstring;

		$dateformatstring     = preg_replace( '/([^\\\])D/', "\\1" . backslashit( $dateweekday_abbrev ), $dateformatstring );

		$dateformatstring     = preg_replace( '/([^\\\])F/', "\\1" . backslashit( $datemonth ), $dateformatstring );

		$dateformatstring     = preg_replace( '/([^\\\])l/', "\\1" . backslashit( $dateweekday ), $dateformatstring );

		$dateformatstring     = preg_replace( '/([^\\\])M/', "\\1" . backslashit( $datemonth_abbrev ), $dateformatstring );

		$dateformatstring     = preg_replace( '/([^\\\])a/', "\\1" . backslashit( $datemeridiem ), $dateformatstring );

		$dateformatstring     = preg_replace( '/([^\\\])A/', "\\1" . backslashit( $datemeridiem_capital ), $dateformatstring );

		$dateformatstring = substr( $dateformatstring, 1, strlen( $dateformatstring ) - 1 );

	}

	$timezone_formats    = array( 'P', 'I', 'O', 'T', 'Z', 'e' );

	$timezone_formats_re = implode( '|', $timezone_formats );

	if ( preg_match( "/$timezone_formats_re/", $dateformatstring ) ) {

		$timezone_string = get_option( 'timezone_string' );

		if ( false === $timestamp_with_offset && $gmt ) {

			$timezone_string = 'UTC';

		}

		if ( $timezone_string ) {

			$timezone_object = timezone_open( $timezone_string );

			$date_object     = date_create( null, $timezone_object );

			foreach ( $timezone_formats as $timezone_format ) {

				if ( false !== strpos( $dateformatstring, $timezone_format ) ) {

					$formatted        = date_format( $date_object, $timezone_format );

					$dateformatstring = ' ' . $dateformatstring;

					$dateformatstring = preg_replace( "/([^\\\])$timezone_format/", "\\1" . backslashit( $formatted ), $dateformatstring );

					$dateformatstring = substr( $dateformatstring, 1, strlen( $dateformatstring ) - 1 );

				}

			}

		} else {

			$offset = get_option( 'gmt_offset' );

			foreach ( $timezone_formats as $timezone_format ) {

				if ( 'I' === $timezone_format ) {

					continue;

				}

				if ( false !== strpos( $dateformatstring, $timezone_format ) ) {

					if ( 'Z' === $timezone_format ) {

						$formatted = (string) ( $offset * HOUR_IN_SECONDS );

					} else {

						$prefix    = '';

						$hours     = (int) $offset;

						$separator = '';

						$minutes   = abs( ( $offset - $hours ) * 60 );

						if ( 'T' === $timezone_format ) {

							$prefix = 'GMT';

						} elseif ( 'e' === $timezone_format || 'P' === $timezone_format ) {

							$separator = ':';

						}

						$formatted = sprintf( '%s%+03d%s%02d', $prefix, $hours, $separator, $minutes );

					}

					$dateformatstring = ' ' . $dateformatstring;

					$dateformatstring = preg_replace( "/([^\\\])$timezone_format/", "\\1" . backslashit( $formatted ), $dateformatstring );

					$dateformatstring = substr( $dateformatstring, 1 );

				}

			}

		}

	}

	$j = @date( $dateformatstring, $i );

	/**

	 * Filters the date formatted based on the locale.

	 *

	 * @since 2.8.0

	 *

	 * @param string $j          Formatted date string.

	 * @param string $req_format Format to display the date.

	 * @param int    $i          A sum of Unix timestamp and timezone offset in seconds.

	 * @param bool   $gmt        Whether to use GMT timezone. Only applies if timestamp was

	 *                           not provided. Default false.

	 */

	$j = apply_filters( 'date_i18n', $j, $req_format, $i, $gmt );

	return $j;

}

/**

 * Determines if the date should be declined.

 *

 * If the locale specifies that month names require a genitive case in certain

 * formats (like 'j F Y'), the month name will be replaced with a correct form.

 *

 * @since 4.4.0

 *

 * @global WP_Locale $wp_locale

 *

 * @param string $date Formatted date string.

 * @return string The date, declined if locale specifies it.

 */

function wp_maybe_decline_date( $date ) {

	global $wp_locale;

	// i18n functions are not available in SHORTINIT mode

	if ( ! function_exists( '_x' ) ) {

		return $date;

	}

	/* translators: If months in your language require a genitive case,

	 * translate this to 'on'. Do not translate into your own language.

	 */

	if ( 'on' === _x( 'off', 'decline months names: on or off' ) ) {

		// Match a format like 'j F Y' or 'j. F'

		if ( @preg_match( '#^\d{1,2}\.? [^\d ]+#u', $date ) ) {

			$months          = $wp_locale->month;

			$months_genitive = $wp_locale->month_genitive;

			foreach ( $months as $key => $month ) {

				$months[ $key ] = '# ' . $month . '( |$)#u';

			}

			foreach ( $months_genitive as $key => $month ) {

				$months_genitive[ $key ] = ' ' . $month . '$1';

			}

			$date = preg_replace( $months, $months_genitive, $date );

		}

	}

	// Used for locale-specific rules

	$locale = get_locale();

	if ( 'ca' === $locale ) {

		// " de abril| de agost| de octubre..." -> " d'abril| d'agost| d'octubre..."

		$date = preg_replace( '# de ([ao])#i', " d'\\1", $date );

	}

	return $date;

}

/**

 * Convert float number to format based on the locale.

 *

 * @since 2.3.0

 *

 * @global WP_Locale $wp_locale

 *

 * @param float $number   The number to convert based on locale.

 * @param int   $decimals Optional. Precision of the number of decimal places. Default 0.

 * @return string Converted number in string format.

 */

function number_format_i18n( $number, $decimals = 0 ) {

	global $wp_locale;

	if ( isset( $wp_locale ) ) {

		$formatted = number_format( $number, absint( $decimals ), $wp_locale->number_format['decimal_point'], $wp_locale->number_format['thousands_sep'] );

	} else {

		$formatted = number_format( $number, absint( $decimals ) );

	}

	/**

	 * Filters the number formatted based on the locale.

	 *

	 * @since 2.8.0

	 * @since 4.9.0 The `$number` and `$decimals` parameters were added.

	 *

	 * @param string $formatted Converted number in string format.

	 * @param float  $number    The number to convert based on locale.

	 * @param int    $decimals  Precision of the number of decimal places.

	 */

	return apply_filters( 'number_format_i18n', $formatted, $number, $decimals );

}

/**

 * Convert number of bytes largest unit bytes will fit into.

 *

 * It is easier to read 1 KB than 1024 bytes and 1 MB than 1048576 bytes. Converts

 * number of bytes to human readable number by taking the number of that unit

 * that the bytes will go into it. Supports TB value.

 *

 * Please note that integers in PHP are limited to 32 bits, unless they are on

 * 64 bit architecture, then they have 64 bit size. If you need to place the

 * larger size then what PHP integer type will hold, then use a string. It will

 * be converted to a double, which should always have 64 bit length.

 *

 * Technically the correct unit names for powers of 1024 are KiB, MiB etc.

 *

 * @since 2.3.0

 *

 * @param int|string $bytes    Number of bytes. Note max integer size for integers.

 * @param int        $decimals Optional. Precision of number of decimal places. Default 0.

 * @return string|false False on failure. Number string on success.

 */

function size_format( $bytes, $decimals = 0 ) {

	$quant = array(

		'TB' => TB_IN_BYTES,

		'GB' => GB_IN_BYTES,

		'MB' => MB_IN_BYTES,

		'KB' => KB_IN_BYTES,

		'B'  => 1,

	);

	if ( 0 === $bytes ) {

		return number_format_i18n( 0, $decimals ) . ' B';

	}

	foreach ( $quant as $unit => $mag ) {

		if ( doubleval( $bytes ) >= $mag ) {

			return number_format_i18n( $bytes / $mag, $decimals ) . ' ' . $unit;

		}

	}

	return false;

}

/**

 * Convert a duration to human readable format.

 *

 * @since 5.1.0

 *

 * @param string $duration Duration will be in string format (HH:ii:ss) OR (ii:ss),

 *                         with a possible prepended negative sign (-).

 * @return string|false A human readable duration string, false on failure.

 */

function human_readable_duration( $duration = '' ) {

	if ( ( empty( $duration ) || ! is_string( $duration ) ) ) {

		return false;

	}

	$duration = trim( $duration );

	// Remove prepended negative sign.

	if ( '-' === substr( $duration, 0, 1 ) ) {

		$duration = substr( $duration, 1 );

	}

	// Extract duration parts.

	$duration_parts = array_reverse( explode( ':', $duration ) );

	$duration_count = count( $duration_parts );

	$hour   = null;

	$minute = null;

	$second = null;

	if ( 3 === $duration_count ) {

		// Validate HH:ii:ss duration format.

		if ( ! ( (bool) preg_match( '/^([0-9]+):([0-5]?[0-9]):([0-5]?[0-9])$/', $duration ) ) ) {

			return false;

		}

		// Three parts: hours, minutes & seconds.

		list( $second, $minute, $hour ) = $duration_parts;

	} elseif ( 2 === $duration_count ) {

		// Validate ii:ss duration format.

		if ( ! ( (bool) preg_match( '/^([0-5]?[0-9]):([0-5]?[0-9])$/', $duration ) ) ) {

			return false;

		}

		// Two parts: minutes & seconds.

		list( $second, $minute ) = $duration_parts;

	} else {

		return false;

	}

	$human_readable_duration = array();

	// Add the hour part to the string.

	if ( is_numeric( $hour ) ) {

		/* translators: Time duration in hour or hours. */

		$human_readable_duration[] = sprintf( _n( '%s hour', '%s hours', $hour ), (int) $hour );

	}

	// Add the minute part to the string.

	if ( is_numeric( $minute ) ) {

		/* translators: Time duration in minute or minutes. */

		$human_readable_duration[] = sprintf( _n( '%s minute', '%s minutes', $minute ), (int) $minute );

	}

	// Add the second part to the string.

	if ( is_numeric( $second ) ) {

		/* translators: Time duration in second or seconds. */

		$human_readable_duration[] = sprintf( _n( '%s second', '%s seconds', $second ), (int) $second );

	}

	return implode( ', ', $human_readable_duration );

}

/**

 * Get the week start and end from the datetime or date string from MySQL.

 *

 * @since 0.71

 *

 * @param string     $mysqlstring   Date or datetime field type from MySQL.

 * @param int|string $start_of_week Optional. Start of the week as an integer. Default empty string.

 * @return array Keys are 'start' and 'end'.

 */

function get_weekstartend( $mysqlstring, $start_of_week = '' ) {

	// MySQL string year.

	$my = substr( $mysqlstring, 0, 4 );

	// MySQL string month.

	$mm = substr( $mysqlstring, 8, 2 );

	// MySQL string day.

	$md = substr( $mysqlstring, 5, 2 );

	// The timestamp for MySQL string day.

	$day = mktime( 0, 0, 0, $md, $mm, $my );

	// The day of the week from the timestamp.

	$weekday = date( 'w', $day );

	if ( ! is_numeric( $start_of_week ) ) {

		$start_of_week = get_option( 'start_of_week' );

	}

	if ( $weekday < $start_of_week ) {

		$weekday += 7;

	}

	// The most recent week start day on or before $day.

	$start = $day - DAY_IN_SECONDS * ( $weekday - $start_of_week );

	// $start + 1 week - 1 second.

	$end = $start + WEEK_IN_SECONDS - 1;

	return compact( 'start', 'end' );

}

/**

 * Unserialize value only if it was serialized.

 *

 * @since 2.0.0

 *

 * @param string $original Maybe unserialized original, if is needed.

 * @return mixed Unserialized data can be any type.

 */

function maybe_unserialize( $original ) {

	if ( is_serialized( $original ) ) { // don't attempt to unserialize data that wasn't serialized going in

		return @unserialize( $original );

	}

	return $original;

}

/**

 * Check value to find if it was serialized.

 *

 * If $data is not an string, then returned value will always be false.

 * Serialized data is always a string.

 *

 * @since 2.0.5

 *

 * @param string $data   Value to check to see if was serialized.

 * @param bool   $strict Optional. Whether to be strict about the end of the string. Default true.

 * @return bool False if not serialized and true if it was.

 */

function is_serialized( $data, $strict = true ) {

	// if it isn't a string, it isn't serialized.

	if ( ! is_string( $data ) ) {

		return false;

	}

	$data = trim( $data );

	if ( 'N;' == $data ) {

		return true;

	}

	if ( strlen( $data ) < 4 ) {

		return false;

	}

	if ( ':' !== $data[1] ) {

		return false;

	}

	if ( $strict ) {

		$lastc = substr( $data, -1 );

		if ( ';' !== $lastc && '}' !== $lastc ) {

			return false;

		}

	} else {

		$semicolon = strpos( $data, ';' );

		$brace     = strpos( $data, '}' );

		// Either ; or } must exist.

		if ( false === $semicolon && false === $brace ) {

			return false;

		}

		// But neither must be in the first X characters.

		if ( false !== $semicolon && $semicolon < 3 ) {

			return false;

		}

		if ( false !== $brace && $brace < 4 ) {

			return false;

		}

	}

	$token = $data[0];