<?php
/**
 * Per-variant cache entries for LiteSpeed Cache.
 *
 * LiteSpeed stores one public copy per URL unless the response varies on a
 * cookie. Each running experiment registers wpab_assignment_{id}. A request
 * that does not already carry a matching assignment is not cached, so the
 * first visitor's HTML is not reused for everyone else.
 *
 * @package WPAB
 */

namespace WPAB\Cache;

use WPAB\Experiments\Variant_Copy;
use WPAB\Runtime;
use WPAB\Runtime\Experiment_Context;
use WPAB\Runtime\Runtime_Index;
use WPAB\Support\Local_File;
use WPAB\Support\Logger;

/**
 * Hooks LiteSpeed's vary list, cache control, and purge API.
 */
final class LiteSpeed_Cache {
	public const PLUGIN_FILE = 'litespeed-cache/litespeed-cache.php';

	public const OPTION = 'wpab_litespeed_vary';

	/**
	 * Skip assignment cookies while LiteSpeed rewrites its rules on the way out.
	 *
	 * @var bool
	 */
	private static bool $suspend = false;

	/**
	 * Register hooks when LiteSpeed Cache is loaded.
	 */
	public function register(): void {
		if ( ! self::is_active() ) {
			return;
		}

		add_filter( 'litespeed_vary_cookies', array( $this, 'vary_cookies' ) );
		add_filter( 'litespeed_vary_curr_cookies', array( $this, 'current_cookies' ) );
		add_action( 'wp', array( $this, 'control' ), 1 );
		add_action( 'init', array( $this, 'sync_rules' ), 30 );
		add_action( 'wpab_runtime_index_rebuilt', array( $this, 'sync_rules' ) );
		add_action( 'save_post', array( $this, 'purge_for_post' ), 30 );
	}

	/**
	 * Whether the LiteSpeed Cache plugin is loaded.
	 *
	 * @return bool
	 */
	public static function is_active(): bool {
		return defined( 'LSCWP_V' ) && class_exists( '\LiteSpeed\Htaccess' );
	}

	/**
	 * Cookie names written into LiteSpeed's Cache-Vary rule.
	 *
	 * @param string[] $cookies Cookie names.
	 * @return string[]
	 */
	public function vary_cookies( array $cookies ): array {
		if ( self::$suspend ) {
			return $cookies;
		}

		foreach ( self::cookie_names_for( self::index_experiments(), time() ) as $name ) {
			if ( ! in_array( $name, $cookies, true ) ) {
				$cookies[] = $name;
			}
		}

		return array_values( $cookies );
	}

	/**
	 * Vary the current response on this page's assignment cookie.
	 *
	 * @param string[] $cookies Cookie names.
	 * @return string[]
	 */
	public function current_cookies( array $cookies ): array {
		$experiment = self::experiment_for_request();
		if ( null === $experiment || self::is_preview_request() || self::has_plugin_query() ) {
			return $cookies;
		}

		$name = Runtime\assignment_cookie_name( (int) $experiment['id'] );
		if ( ! self::assignment_matches( self::cookie_value( $name ), self::variant_ids( $experiment ) ) ) {
			return $cookies;
		}

		$cookies[] = $name;
		return array_values( array_unique( array_map( 'strval', $cookies ) ) );
	}

	/**
	 * Keep the unassigned, preview, and reset responses out of the public cache.
	 */
	public function control(): void {
		if ( is_admin() || wp_doing_ajax() || wp_doing_cron() ) {
			return;
		}

		$experiment = self::experiment_for_request();
		if ( null === $experiment ) {
			return;
		}

		$name  = Runtime\assignment_cookie_name( (int) $experiment['id'] );
		$ready = self::assignment_matches( self::cookie_value( $name ), self::variant_ids( $experiment ) );
		if ( $ready && ! self::is_preview_request() && ! self::has_plugin_query() ) {
			return;
		}

		do_action( 'litespeed_control_set_nocache', 'JM Split Tester' );
	}

	/**
	 * Rewrite LiteSpeed rules when the set of assignment cookies changes.
	 */
	public function sync_rules(): void {
		if ( ! self::is_active() || self::$suspend ) {
			return;
		}

		$experiments = array();
		$paths       = array();
		foreach ( self::index_experiments() as $experiment ) {
			if ( array() === self::cookie_names_for( array( $experiment ), time() ) ) {
				continue;
			}
			$experiments[] = $experiment;
			$path          = (string) ( $experiment['path'] ?? '' );
			if ( '' !== $path && ! str_contains( $path, '..' ) ) {
				$paths[] = $path;
			}
		}

		$names = self::cookie_names_for( $experiments, time() );
		sort( $paths );
		$paths = array_values( array_unique( $paths ) );
		$state = array(
			'cookies' => $names,
			'paths'   => $paths,
		);

		$stored = get_option( self::OPTION, null );
		if ( $stored === $state ) {
			return;
		}

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

		update_option( self::OPTION, $state, false );

		$previous = array();
		if ( is_array( $stored ) && isset( $stored['paths'] ) && is_array( $stored['paths'] ) ) {
			$previous = array_map( 'strval', $stored['paths'] );
		}
		foreach ( array_unique( array_merge( $previous, $paths ) ) as $path ) {
			do_action( 'litespeed_purge_url', $path );
		}
	}

	/**
	 * Drop cached copies when the original post or its variant copy is saved.
	 *
	 * @param int $post_id Post ID.
	 */
	public function purge_for_post( int $post_id ): void {
		if ( ! self::is_active() || wp_is_post_autosave( $post_id ) || wp_is_post_revision( $post_id ) ) {
			return;
		}

		$original = (int) get_post_meta( $post_id, Variant_Copy::META, true );
		$target   = $original > 0 ? $original : $post_id;
		foreach ( self::index_experiments() as $experiment ) {
			if ( (int) ( $experiment['post_id'] ?? 0 ) !== $target ) {
				continue;
			}
			$path = (string) ( $experiment['path'] ?? '' );
			if ( '' !== $path ) {
				do_action( 'litespeed_purge_url', $path );
			}
		}
	}

	/**
	 * Remove assignment cookies from LiteSpeed's rules.
	 */
	public static function uninstall(): void {
		if ( ! self::is_active() ) {
			delete_option( self::OPTION );
			return;
		}

		self::$suspend = true;
		self::write_rules();
		delete_option( self::OPTION );
	}

	/**
	 * Assignment cookie names for experiments that are inside their schedule.
	 *
	 * @param array<int, array<string, mixed>> $experiments Experiment records.
	 * @param int                              $now         Unix timestamp.
	 * @return string[]
	 */
	public static function cookie_names_for( array $experiments, int $now ): array {
		$names = array();
		foreach ( $experiments as $experiment ) {
			if ( ! is_array( $experiment ) ) {
				continue;
			}
			$id = (int) ( $experiment['id'] ?? 0 );
			if ( $id < 1 ) {
				continue;
			}
			$start = isset( $experiment['start'] ) ? (int) $experiment['start'] : null;
			$end   = isset( $experiment['end'] ) ? (int) $experiment['end'] : null;
			if ( ! Runtime\is_within_schedule( (string) ( $experiment['status'] ?? '' ), $start, $end, $now ) ) {
				continue;
			}
			$names[] = Runtime\assignment_cookie_name( $id );
		}

		$names = array_values( array_unique( $names ) );
		sort( $names );
		return $names;
	}

	/**
	 * Whether the cookie selects a variant that belongs to the experiment.
	 *
	 * @param string|null $cookie      Raw cookie value.
	 * @param int[]       $variant_ids Variant IDs.
	 * @return bool
	 */
	public static function assignment_matches( ?string $cookie, array $variant_ids ): bool {
		$parsed = Runtime\parse_assignment_cookie( $cookie );
		if ( null === $parsed ) {
			return false;
		}

		return in_array( $parsed['variant_id'], array_map( 'intval', $variant_ids ), true );
	}

	/**
	 * Ask LiteSpeed to rewrite its rules with the current vary filter.
	 *
	 * @return bool
	 */
	private static function write_rules(): bool {
		if ( ! class_exists( '\LiteSpeed\Conf' ) || ! class_exists( '\LiteSpeed\Htaccess' ) || ! class_exists( '\LiteSpeed\Base' ) ) {
			return false;
		}

		$conf = \LiteSpeed\Conf::cls();
		if ( ! $conf->has_conf( \LiteSpeed\Base::O_CACHE ) ) {
			return false;
		}

		try {
			$options = $conf->get_options();
			if ( ! is_array( $options ) ) {
				return false;
			}
			\LiteSpeed\Htaccess::cls()->update( $options );
		} catch ( \Throwable $error ) {
			Logger::exception( $error );
			return false;
		}

		return true;
	}

	/**
	 * Live experiment whose public path is this request, if any.
	 *
	 * @return array<string, mixed>|null
	 */
	private static function experiment_for_request(): ?array {
		$uri  = isset( $_SERVER['REQUEST_URI'] ) ? sanitize_text_field( wp_unslash( (string) $_SERVER['REQUEST_URI'] ) ) : '';
		$path = Runtime\normalize_path( (string) wp_parse_url( $uri, PHP_URL_PATH ) );

		foreach ( self::index_experiments() as $experiment ) {
			$experiment_path = (string) ( $experiment['path'] ?? '' );
			if ( $experiment_path !== $path && $experiment_path . '/' !== $path ) {
				continue;
			}
			$names = self::cookie_names_for( array( $experiment ), time() );
			if ( array() === $names ) {
				return null;
			}
			return $experiment;
		}

		return null;
	}

	/**
	 * Variant IDs stored on an index record.
	 *
	 * @param array<string, mixed> $experiment Experiment record.
	 * @return int[]
	 */
	private static function variant_ids( array $experiment ): array {
		$ids = array();
		if ( ! isset( $experiment['variants'] ) || ! is_array( $experiment['variants'] ) ) {
			return $ids;
		}
		foreach ( $experiment['variants'] as $variant ) {
			if ( is_array( $variant ) ) {
				$ids[] = (int) ( $variant['id'] ?? 0 );
			}
		}
		return $ids;
	}

	/**
	 * Experiments stored in the runtime index.
	 *
	 * @return array<int, array<string, mixed>>
	 */
	private static function index_experiments(): array {
		$file = Runtime_Index::path();
		if ( ! is_readable( $file ) ) {
			return array();
		}
		$index = json_decode( Local_File::read( $file ), true );
		if ( ! is_array( $index ) || ! isset( $index['experiments'] ) || ! is_array( $index['experiments'] ) ) {
			return array();
		}

		$experiments = array();
		foreach ( $index['experiments'] as $experiment ) {
			if ( is_array( $experiment ) ) {
				$experiments[] = $experiment;
			}
		}
		return $experiments;
	}

	/**
	 * Read one cookie.
	 *
	 * @param string $name Cookie name.
	 * @return string
	 */
	private static function cookie_value( string $name ): string {
		if ( ! isset( $_COOKIE[ $name ] ) ) {
			return '';
		}
		return sanitize_text_field( wp_unslash( (string) $_COOKIE[ $name ] ) );
	}

	/**
	 * Preview requests must not be stored.
	 *
	 * @return bool
	 */
	private static function is_preview_request(): bool {
		$context = Experiment_Context::current();
		if ( $context instanceof Experiment_Context && $context->is_preview() ) {
			return true;
		}
		return '' !== self::cookie_value( Runtime\PREVIEW_COOKIE );
	}

	/**
	 * Preview and reset query arguments stay dynamic.
	 *
	 * @return bool
	 */
	private static function has_plugin_query(): bool {
		$query = isset( $_SERVER['QUERY_STRING'] ) ? sanitize_text_field( wp_unslash( (string) $_SERVER['QUERY_STRING'] ) ) : '';
		return 1 === preg_match( '/(^|&)wpab_/', $query );
	}
}