<?php
defined( 'ABSPATH' ) || exit;
// phpcs:disable WordPress.WP.AlternativeFunctions, PluginCheck.CodeAnalysis.WriteFile -- A page cache must write its
// files, the advanced-cache.php drop-in, the WP_CACHE line and the .htaccess rules directly: WP_Filesystem can require
// FTP credentials on some hosts, and these writes happen during page requests and cron where nobody can enter them.
// Every write is to wp-content/cache/zeroconfig, wp-content/advanced-cache.php, wp-config.php (one marked line) or
// the site's .htaccess (one marked block), never to the plugin folder; replacements are written to a temp file and renamed.

/**
 * Apache / LiteSpeed: serve cached HTML with mod_rewrite, before PHP starts.
 * Rules live between markers at the TOP of the root .htaccess (they must run
 * before WordPress' own rewrite to index.php). Writes are locked, atomic and
 * skipped when nothing changed. Nginx users get the advanced-cache drop-in.
 */
class ZeroConfig_Htaccess {

	const BEGIN = '# BEGIN ZeroConfig';
	const END   = '# END ZeroConfig';

	public static function supported() {
		$soft = isset( $_SERVER['SERVER_SOFTWARE'] ) ? strtolower( sanitize_text_field( wp_unslash( $_SERVER['SERVER_SOFTWARE'] ) ) ) : '';
		if ( false === strpos( $soft, 'apache' ) && false === strpos( $soft, 'litespeed' ) ) {
			return false;
		}
		// Rules assume the site lives at the document root; subdirectory installs use the drop-in.
		$path = (string) wp_parse_url( home_url(), PHP_URL_PATH );
		if ( '' !== trim( $path, '/' ) ) {
			return false;
		}
		return true;
	}

	/**
	 * The folder the site's addresses start from, where Apache reads the .htaccess for visitor
	 * requests. Usually ABSPATH; not when WordPress has its own directory (core in /wp/, site at the
	 * root: siteurl ends in /wp, home does not), where it is the folder above. Worked out from the two
	 * addresses rather than core's get_home_path(), which depends on the running script and is wrong
	 * from WP-CLI and cron.
	 */
	public static function home_dir() {
		$abs  = trailingslashit( wp_normalize_path( ABSPATH ) );
		$site = untrailingslashit( (string) wp_parse_url( site_url(), PHP_URL_PATH ) );
		$home = untrailingslashit( (string) wp_parse_url( home_url(), PHP_URL_PATH ) );
		if ( '' !== $site && $site !== $home && ( '' === $home || 0 === strpos( $site, $home . '/' ) ) ) {
			$extra = substr( $site, strlen( $home ) ) . '/'; // e.g. "/wp/"
			if ( substr( $abs, -strlen( $extra ) ) === $extra ) {
				return substr( $abs, 0, -strlen( $extra ) + 1 );
			}
		}
		return $abs;
	}

	public static function file() {
		return self::home_dir() . '.htaccess';
	}

	/** Build the rule block. Mirrors the decision logic in cache-decide.php as far as mod_rewrite allows. */
	public static function rules() {
		// URL path of the cache folder as seen from the site root: /wp/wp-content/... when core has its own folder.
		$content_rel = trim( str_replace( self::home_dir(), '', trailingslashit( wp_normalize_path( WP_CONTENT_DIR ) ) ), '/' );
		$cache       = '/' . $content_rel . '/cache/zeroconfig';
		$params      = str_replace( '$', '', ZEROCONFIG_TRACKING_PARAMS );
		$exclude     = array();
		// Filter values become part of a RewriteCond: a space or a line break there would make Apache
		// answer 500 for the whole site. Only plain path text gets in.
		foreach ( (array) ZeroConfig_Page_Cache::config()['exclude'] as $ex ) {
			$ex = trim( (string) $ex, '/' );
			if ( '' !== $ex && preg_match( '#^[A-Za-z0-9._~/%-]+$#', $ex ) ) {
				$exclude[] = preg_quote( $ex, '#' );
			}
		}
		$exclude_re = $exclude ? '(' . implode( '|', $exclude ) . ')' : '__never__';

		$common = array(
			// Only while the plugin is installed: deleting or renaming its folder over FTP switches the
			// cache off at once, even though the plugin never got the chance to remove these lines.
			'RewriteCond ' . str_replace( ' ', '\ ', wp_normalize_path( ZEROCONFIG_FILE ) ) . ' -f',
			'RewriteCond %{REQUEST_METHOD} GET',
			// The Host header names the cache folder below: only the site's own addresses may.
			'RewriteCond %{HTTP_HOST} ^(' . self::host_re() . ')$ [NC]',
			'RewriteCond %{QUERY_STRING} ^$ [OR]',
			'RewriteCond %{QUERY_STRING} ^((' . $params . ')[^&]*(&|$))+$ [NC]',
			'RewriteCond %{REQUEST_URI} !^/(wp-admin|wp-login|wp-json|xmlrpc|wp-cron|wp-comments|feed) [NC]',
			'RewriteCond %{REQUEST_URI} !\.(php|xml|txt)$ [NC]',
			'RewriteCond %{REQUEST_URI} !/feed/?$ [NC]',
			'RewriteCond %{REQUEST_URI} !' . $exclude_re . ' [NC]',
			'RewriteCond %{HTTP_COOKIE} !(wordpress_logged_in_|wp-postpass_|comment_author_|woocommerce_|wp_woocommerce_session_|edd_|wpsc_|pll_language|wp-wpml_current_language|aelia_cs_selected_currency|wcml_client_currency|wmc_current_currency|woocs_current_currency|yith_wcmcs_currency) [NC]',
		);
		$lines  = array( self::BEGIN, '# Serves ZeroConfig page cache without starting PHP. Regenerated by the plugin; do not edit.', '<IfModule mod_rewrite.c>', 'RewriteEngine On', 'RewriteBase /' );
		// Self-test for the plugin's check: /zc-ping.txt answers with a token from the cache folder only
		// when these rules really run. Needs no other module. (.txt is never treated as a page.)
		$lines[] = 'RewriteCond %{DOCUMENT_ROOT}' . $cache . '/ping.txt -f';
		$lines[] = 'RewriteRule ^zc-ping\.txt$ ' . $cache . '/ping.txt [L,T=text/plain]';
		foreach ( array( 'm' => '', 'd' => '!' ) as $dev => $neg ) {
			foreach ( array( true, false ) as $gz ) {
				$file  = $cache . '/%{HTTP_HOST}%{REQUEST_URI}index-' . $dev . '.html' . ( $gz ? '.gz' : '' );
				$block = $common;
				$block[] = 'RewriteCond %{HTTP_USER_AGENT} ' . $neg . '(Mobile|Android|iPhone|iPad|iPod|Opera\ Mini|IEMobile) [NC]';
				if ( $gz ) {
					$block[] = 'RewriteCond %{HTTP:Accept-Encoding} gzip';
				}
				$block[] = 'RewriteCond %{DOCUMENT_ROOT}' . $file . ' -f';
				// gz: force the HTML type and stop mod_deflate from compressing it a second time.
				$block[] = 'RewriteRule .* ' . $file . ( $gz ? ' [L,T=text/html,E=no-gzip:1]' : ' [L]' );
				if ( $gz ) {
					// Only serve the .gz variant where Apache can label it as gzip (mod_mime ships enabled everywhere;
					// mod_headers often does not). Without the label browsers would show compressed bytes.
					$block = array_merge( array( '<IfModule mod_mime.c>' ), $block, array( '</IfModule>' ) );
				}
				$lines = array_merge( $lines, $block );
			}
		}
		$lines[] = '</IfModule>';
		// Scoped to our cache file names only: never touches other .gz files on the site (backups, downloads).
		$lines[] = '<FilesMatch "^index-[md](-[a-z0-9_]+)?\.html\.gz$">';
		$lines[] = 'ForceType text/html';
		$lines[] = 'AddDefaultCharset UTF-8';
		$lines[] = '<IfModule mod_mime.c>';
		$lines[] = 'AddEncoding gzip .gz';
		$lines[] = '</IfModule>';
		$lines[] = '</FilesMatch>';
		$lines[] = '<FilesMatch "^index-[md](-[a-z0-9_]+)?\.html$">';
		$lines[] = 'AddDefaultCharset UTF-8';
		$lines[] = '</FilesMatch>';
		$lines[] = '<IfModule mod_headers.c>';
		$lines[] = '<FilesMatch "^index-[md](-[a-z0-9_]+)?\.html(\.gz)?$">';
		$lines[] = 'Header set X-ZeroConfig-Cache "HIT-HTACCESS"';
		$lines[] = 'Header set Cache-Control "no-cache, must-revalidate, max-age=0"';
		$lines[] = 'Header append Vary "Accept-Encoding, Cookie"';
		$lines[] = '</FilesMatch>';
		$lines[] = '</IfModule>';
		$lines[] = '<IfModule mod_expires.c>';
		$lines[] = 'ExpiresActive On';
		// Without mod_headers the block above is skipped and cached HTML would carry no Cache-Control at
		// all; browsers would then keep it by guesswork. Expire it at once, as the PHP paths do.
		$lines[] = '<FilesMatch "^index-[md](-[a-z0-9_]+)?\.html(\.gz)?$">';
		$lines[] = 'ExpiresDefault A0';
		$lines[] = '</FilesMatch>';
		$lines[] = 'ExpiresByType image/webp "access plus 1 year"';
		$lines[] = 'ExpiresByType image/avif "access plus 1 year"';
		$lines[] = 'ExpiresByType image/jpeg "access plus 1 year"';
		$lines[] = 'ExpiresByType image/png "access plus 1 year"';
		$lines[] = 'ExpiresByType image/svg+xml "access plus 1 year"';
		$lines[] = 'ExpiresByType text/css "access plus 1 year"';
		$lines[] = 'ExpiresByType application/javascript "access plus 1 year"';
		$lines[] = 'ExpiresByType font/woff2 "access plus 1 year"';
		$lines[] = '</IfModule>';
		$lines[] = self::END;
		return implode( "\n", $lines ) . "\n";
	}

	private static function host_re() {
		$re = array();
		foreach ( ZeroConfig_Page_Cache::hosts() as $h ) {
			if ( ! preg_match( '/^[a-z0-9.-]+(:\d+)?$/', $h ) ) {
				continue; // anything else in a host name cannot be a real address of this site
			}
			$re[] = str_replace( '\:', ':', preg_quote( $h, '#' ) ); // preg_quote also escapes the port's colon
		}
		return $re ? implode( '|', $re ) : '__never__';
	}

	public static function install() {
		if ( ! self::supported() ) {
			return false;
		}
		self::remove_stale();
		return self::write( self::rules() );
	}

	/** Older versions wrote into ABSPATH/.htaccess even when the site root is the folder above: take that block out. */
	private static function remove_stale() {
		$old = trailingslashit( wp_normalize_path( ABSPATH ) ) . '.htaccess';
		if ( $old !== self::file() && is_file( $old ) && false !== strpos( (string) file_get_contents( $old ), self::BEGIN ) ) {
			self::write( '', $old );
		}
	}

	/**
	 * Hourly from the heartbeat: rewrite our block when it is already there, even when this run cannot
	 * tell the server is Apache (system cron runs PHP from the command line). A write that failed once
	 * (file locked or read-only for a moment) must not leave old rules in place for good. A no-op when
	 * the text is unchanged.
	 */
	public static function refresh() {
		if ( ! self::installed() ) {
			return false;
		}
		self::remove_stale();
		return self::write( self::rules() );
	}

	public static function remove() {
		self::remove_stale();
		return self::write( '' );
	}

	/** Our block is in the site root .htaccess, or still in the old place (ABSPATH) from an older version. */
	public static function installed() {
		foreach ( array_unique( array( self::file(), trailingslashit( wp_normalize_path( ABSPATH ) ) . '.htaccess' ) ) as $f ) {
			if ( is_file( $f ) && false !== strpos( (string) file_get_contents( $f ), self::BEGIN ) ) {
				return true;
			}
		}
		return false;
	}

	/**
	 * Replace (or remove, when $block is '') our marker block at the top of
	 * .htaccess. Locked, atomic, and a no-op when the content would not change.
	 */
	private static function write( $block, $file = null ) {
		$file = null === $file ? self::file() : $file;
		if ( ! is_file( $file ) ) {
			if ( '' === $block ) {
				return true;
			}
			if ( ! is_writable( dirname( $file ) ) ) {
				return new WP_Error( 'zc_htaccess', 'root is not writable' );
			}
			@file_put_contents( $file, '' ); // phpcs:ignore WordPress.WP.AlternativeFunctions
		}
		if ( ! is_writable( $file ) ) {
			return new WP_Error( 'zc_htaccess', '.htaccess is not writable' );
		}
		$fh = @fopen( $file, 'c+' ); // phpcs:ignore WordPress.WP.AlternativeFunctions
		if ( ! $fh ) {
			return new WP_Error( 'zc_htaccess', 'cannot open .htaccess' );
		}
		try {
			if ( ! flock( $fh, LOCK_EX ) ) {
				return new WP_Error( 'zc_htaccess', 'cannot lock .htaccess' );
			}
			$src = stream_get_contents( $fh );
			if ( false === $src ) {
				return new WP_Error( 'zc_htaccess', 'cannot read .htaccess' );
			}
			$re      = '/' . preg_quote( self::BEGIN, '/' ) . '.*?' . preg_quote( self::END, '/' ) . '\R?/s';
			$without = preg_replace( $re, '', $src );
			if ( null === $without ) {
				$without = $src;
			}
			$new = '' === $block ? ltrim( $without, "\n" ) : $block . "\n" . ltrim( $without, "\n" );
			if ( $new === $src ) {
				return true; // unchanged: don't touch mtime, don't trigger opcache/watchers
			}
			$tmp = $file . '.' . uniqid( 'zc', true ) . '.tmp';
			if ( false === @file_put_contents( $tmp, $new ) ) { // phpcs:ignore WordPress.WP.AlternativeFunctions
				return new WP_Error( 'zc_htaccess', 'cannot write temp file' );
			}
			@chmod( $tmp, fileperms( $file ) & 0777 );
			if ( @rename( $tmp, $file ) ) {
				return true;
			}
			wp_delete_file( $tmp );
			// Windows will not replace a file that is open (we hold it locked): write through the handle.
			// Write first, cut the tail after: a short write (disk full) never leaves an empty file behind.
			if ( rewind( $fh ) && strlen( $new ) === fwrite( $fh, $new ) && ftruncate( $fh, strlen( $new ) ) && fflush( $fh ) ) {
				return true;
			}
			return new WP_Error( 'zc_htaccess', 'cannot replace .htaccess' );
		} finally {
			flock( $fh, LOCK_UN );
			fclose( $fh );
		}
	}
}