<?php
/**
 * Glob_Matcher — translate user-friendly glob patterns to PCRE for the
 * cache engine's exclusion checks.
 *
 * Supported syntax (shell-style glob, NOT full PCRE):
 *   *     → match any run of characters (greedy), including '/'
 *   ?     → match exactly one character
 *   [abc] → character class
 *   \*    → literal asterisk (escape)
 *
 * Compiles each user pattern once, caches the compiled regex in a
 * static array for the request, then matches with a single preg_match.
 *
 * A bare substring (no glob metacharacters) keeps the legacy "contains"
 * semantics: `/cart` matches `/cart`, `/cart/items`, `/foo/cart/bar`.
 * Adding ANY of `* ? [` switches the pattern to anchored glob mode:
 * `/cart/*` matches `/cart/items` but NOT `/foo/cart/bar`.
 *
 * @package XSpeed
 */

declare(strict_types=1);

namespace XSpeed;

defined( 'ABSPATH' ) || exit;

final class Glob_Matcher {

	/**
	 * @var array<string,string> pattern => compiled regex
	 */
	private static $compiled = array();

	/**
	 * Does any of `$patterns` match `$subject`?
	 *
	 * @param string[] $patterns
	 */
	public static function any_match( array $patterns, string $subject ): bool {
		foreach ( $patterns as $p ) {
			$p = (string) $p;
			if ( '' === $p ) {
				continue;
			}
			if ( self::matches( $p, $subject ) ) {
				return true;
			}
		}
		return false;
	}

	public static function matches( string $pattern, string $subject ): bool {
		$regex = self::compile( $pattern );
		// Anchored glob (regex returned starts with '#^') vs substring
		// (regex returned starts with '#'). Both use preg_match the
		// same way; the anchoring is baked into the pattern.
		return 1 === preg_match( $regex, $subject );
	}

	/**
	 * Compile a user pattern to a PCRE delimited with `#`. Cached
	 * for the request lifetime.
	 */
	public static function compile( string $pattern ): string {
		if ( isset( self::$compiled[ $pattern ] ) ) {
			return self::$compiled[ $pattern ];
		}
		// Decide mode based on UNESCAPED glob metacharacters only.
		// `\*` alone keeps the pattern in substring mode (with escapes
		// resolved); `/cart/*` flips to anchored glob mode.
		$has_unescaped_glob = (bool) preg_match( '/(?<!\\\\)[*?\[]/', $pattern );
		if ( $has_unescaped_glob ) {
			$regex = '#^' . self::glob_to_regex( $pattern ) . '$#';
		} else {
			// Substring "contains" mode. Resolve `\X` → `X` first so
			// `\*` matches a literal asterisk anywhere in the subject.
			$resolved = preg_replace( '/\\\\(.)/', '$1', $pattern );
			$regex    = '#' . preg_quote( (string) $resolved, '#' ) . '#';
		}
		self::$compiled[ $pattern ] = $regex;
		return $regex;
	}

	/**
	 * Translate glob syntax → regex body (no delimiters, no anchors).
	 * Mirrors fnmatch's FNM_PATHNAME-disabled semantics: `*` matches
	 * across `/` so `/cart/*` correctly catches `/cart/items/sub`.
	 */
	private static function glob_to_regex( string $glob ): string {
		$out      = '';
		$in_class = false;
		$len      = strlen( $glob );
		$escape   = false;

		for ( $i = 0; $i < $len; $i++ ) {
			$ch = $glob[ $i ];

			if ( $escape ) {
				$out   .= preg_quote( $ch, '#' );
				$escape = false;
				continue;
			}

			if ( '\\' === $ch ) {
				$escape = true;
				continue;
			}

			if ( $in_class ) {
				if ( ']' === $ch ) {
					$out     .= ']';
					$in_class = false;
				} else {
					// Inside a character class, dash + letters are passed
					// through; we still preg_quote dangerous chars.
					$out .= preg_quote( $ch, '#' );
				}
				continue;
			}

			switch ( $ch ) {
				case '*':
					$out .= '.*';
					break;
				case '?':
					$out .= '.';
					break;
				case '[':
					$out     .= '[';
					$in_class = true;
					break;
				default:
					$out .= preg_quote( $ch, '#' );
			}
		}

		return $out;
	}

	/**
	 * Test-only: clear the compile cache. Production code never needs
	 * this (PHP request lifetime handles it).
	 */
	public static function reset_cache(): void {
		self::$compiled = array();
	}
}