<?php
/**
 * Permalinks after an import, so nobody has to visit Settings → Permalinks and save: a hard rewrite flush, then a
 * check that real URLs of the imported site answer.
 *
 * The import's finalize step deletes rewrite_rules and sets FLUSH_FLAG. run() (the verify-links step, or
 * POST /jobs/{id}/check-links) flushes hard so .htaccess is written where Apache uses it, then deletes the stored
 * rules once more: the request that ran the switch still has the source site's plugins in memory, so the rules are
 * rebuilt by the first checked URL, a request that runs the imported site's code. maybe_flush() is the fallback on
 * the next admin request when the step did not run.
 *
 * The check asks home, the latest post, page, product (WooCommerce active) and download (EDD active), expecting a
 * 2xx/3xx answer, and a made-up URL expecting 404. Rows: { label, url, status (0 when unreachable), ok }; ok is null
 * for a URL the time budget did not reach ("not checked"), which counts as neither pass nor fail. Filter
 * mench_migrate_link_check_urls( [ { label, url, expect? } ] ) adds or removes URLs; only hosts in
 * mench_migrate_link_check_hosts (this site's host) are asked. An unreachable URL is a row with status 0, never an
 * exception; callers still catch whatever a filter throws.
 *
 * Bounded: the whole check stops at min( deadline, start + BUDGET ) and each request at TIMEOUT, so it fits in the tick
 * that finishes an import even when loopback requests are dropped. Each probe carries doing_wp_cron, so the visit
 * does not spawn the imported site's overdue WP-Cron; redirects are followed by hand, and only on the same host.
 *
 * @package Mench_Migrate
 */

defined( 'ABSPATH' ) || exit;

final class Mench_Migrate_Link_Check {

	public const FLUSH_FLAG = 'mench_migrate_flush_pending';

	/** Seconds per request, and for the whole check. */
	private const TIMEOUT = 5.0;
	public const BUDGET   = 15.0;

	/** Same-host redirects followed per URL. */
	private const MAX_REDIRECTS = 3;

	/**
	 * admin_init, and wp (front-end pages): the next administrator request does the pending hard flush. Never a REST,
	 * Ajax or cron request, so a progress poll never writes .htaccess.
	 */
	public static function maybe_flush(): void {
		if ( ( defined( 'REST_REQUEST' ) && REST_REQUEST ) || wp_doing_ajax() || wp_doing_cron() ) {
			return;
		}
		$all = wp_load_alloptions(); // The flag is autoloaded when set: no extra query on ordinary requests.
		if ( empty( $all[ self::FLUSH_FLAG ] ) ) {
			return;
		}
		if ( ! is_admin() && ! current_user_can( (string) apply_filters( 'mench_migrate_capability', 'manage_options' ) ) ) {
			return;
		}
		self::hard_flush();
		delete_option( self::FLUSH_FLAG );
	}

	/**
	 * Flushes, then checks every URL until the budget runs out.
	 *
	 * @param float|null    $deadline microtime after which nothing more is asked (capped at start + BUDGET).
	 * @param callable|null $each     fn( int $done, int $total ): void before the first and after every URL.
	 * @return list<array{label:string, url:string, status:int, ok:?bool}>
	 */
	public static function run( ?float $deadline = null, ?callable $each = null ): array {
		$end = min( $deadline ?? INF, microtime( true ) + self::BUDGET );
		wp_cache_flush(); // The options the switch brought in, never values cached from the old tables.
		self::hard_flush();
		delete_option( 'rewrite_rules' ); // Rebuilt by the first request below, with the imported site's code.
		delete_option( self::FLUSH_FLAG );
		$targets = self::targets();
		$total   = count( $targets );
		$rows    = [];
		$each && $each( 0, $total );
		foreach ( $targets as $t ) {
			$left = $end - microtime( true );
			if ( $left < 0.2 ) {
				$rows[] = [ 'label' => $t['label'], 'url' => $t['url'], 'status' => 0, 'ok' => null ];
			} else {
				$status = self::status( $t['url'], min( self::TIMEOUT, $left ) );
				$away   = $status < 0; // Redirected off this site.
				$status = abs( $status );
				$cut    = 0 === $status && microtime( true ) >= $end - 0.05; // Stopped by the budget, not answered "no".
				$rows[] = [
					'label'  => $t['label'],
					'url'    => $t['url'],
					'status' => $status,
					'ok'     => $cut ? null : ( ! $away && ( 404 === $t['expect'] ? 404 === $status : ( $status >= 200 && $status < 400 ) ) ),
				];
			}
			$each && $each( count( $rows ), $total );
		}
		return $rows;
	}

	/** flush_rewrite_rules( true ) with this site's current permalink settings. */
	private static function hard_flush(): void {
		global $wp_rewrite;
		require_once ABSPATH . 'wp-admin/includes/file.php';
		require_once ABSPATH . 'wp-admin/includes/misc.php';
		if ( $wp_rewrite instanceof WP_Rewrite ) {
			$wp_rewrite->init(); // permalink_structure as stored now, not as read when this request started.
		}
		flush_rewrite_rules( true );
	}

	/** @return list<array{label:string, url:string, expect:int}> */
	private static function targets(): array {
		$list = [ [ 'label' => __( 'Home page', 'mench-migrate' ), 'url' => home_url( '/' ) ] ];
		foreach ( [ 'post' => __( 'Latest post', 'mench-migrate' ), 'page' => __( 'Latest page', 'mench-migrate' ) ] as $type => $label ) {
			$url = self::latest( $type );
			if ( '' !== $url ) {
				$list[] = [ 'label' => $label, 'url' => $url ];
			}
		}
		$active = array_map( 'strval', (array) get_option( 'active_plugins', [] ) );
		$has    = static fn( string $folder ): bool => (bool) array_filter( $active, static fn( string $p ): bool => 0 === strpos( $p, $folder ) );
		if ( $has( 'woocommerce/' ) && '' !== ( $url = self::latest( 'product' ) ) ) { // phpcs:ignore WordPress.CodeAnalysis.AssignmentInCondition
			$list[] = [ 'label' => __( 'A product', 'mench-migrate' ), 'url' => $url ];
		}
		if ( $has( 'easy-digital-downloads' ) && '' !== ( $url = self::latest( 'download' ) ) ) { // phpcs:ignore WordPress.CodeAnalysis.AssignmentInCondition
			$list[] = [ 'label' => __( 'A download', 'mench-migrate' ), 'url' => $url ];
		}
		$missing = 'mench-migrate-check-' . Mench_Migrate_Paths::random_suffix( 12 );
		$list[]  = [
			'label'  => __( 'A missing page', 'mench-migrate' ),
			// Plain permalinks route every path to the front page, so there a missing post id stands in.
			'url'    => '' === (string) get_option( 'permalink_structure' ) ? add_query_arg( 'p', 2147483000 + wp_rand( 0, 600 ), home_url( '/' ) ) : home_url( '/' . $missing . '/' ),
			'expect' => 404,
		];

		$list  = apply_filters( 'mench_migrate_link_check_urls', $list );
		$hosts = array_map( 'strtolower', (array) apply_filters( 'mench_migrate_link_check_hosts', [ self::home_host() ] ) );
		$out   = [];
		foreach ( is_array( $list ) ? $list : [] as $t ) {
			if ( ! is_array( $t ) || ! is_string( $t['url'] ?? null ) || ! preg_match( '#^https?://#i', $t['url'] ) ) {
				continue;
			}
			if ( ! in_array( strtolower( (string) wp_parse_url( $t['url'], PHP_URL_HOST ) ), $hosts, true ) ) {
				continue; // Only this site is asked.
			}
			$out[] = [
				'label'  => sanitize_text_field( (string) ( $t['label'] ?? $t['url'] ) ),
				'url'    => esc_url_raw( $t['url'] ),
				'expect' => 404 === (int) ( $t['expect'] ?? 200 ) ? 404 : 200,
			];
		}
		return $out;
	}

	/** Permalink of the latest published item of a post type, or ''. Read from the table: the type may not be registered by this request's code. */
	private static function latest( string $type ): string {
		global $wpdb;
		$id = (int) $wpdb->get_var( $wpdb->prepare( "SELECT ID FROM {$wpdb->posts} WHERE post_type = %s AND post_status = 'publish' ORDER BY post_date DESC, ID DESC LIMIT 1", $type ) ); // phpcs:ignore WordPress.DB.DirectDatabaseQuery
		if ( $id <= 0 ) {
			return '';
		}
		if ( post_type_exists( $type ) ) {
			$url = get_permalink( $id );
			return is_string( $url ) ? $url : '';
		}
		return add_query_arg( [ 'post_type' => $type, 'p' => $id ], home_url( '/' ) ); // WordPress redirects it to the pretty URL.
	}

	private static function home_host(): string {
		return strtolower( (string) wp_parse_url( home_url(), PHP_URL_HOST ) );
	}

	/**
	 * HTTP status of a URL (HEAD, GET when HEAD is refused), 0 when it cannot be reached in $timeout seconds.
	 * Redirects are followed by hand, up to MAX_REDIRECTS and only to the same host; one that leaves the host is not
	 * followed and makes the URL fail (its status comes back negated).
	 */
	private static function status( string $url, float $timeout ): int {
		$start = microtime( true );
		$host  = strtolower( (string) wp_parse_url( $url, PHP_URL_HOST ) );
		$local = in_array( $host, [ 'localhost', '127.0.0.1', '::1', '[::1]' ], true ) || (bool) preg_match( '/\.(test|local|localhost|invalid|example)$/', $host );
		try {
			for ( $hop = 0; $hop <= self::MAX_REDIRECTS; $hop++ ) {
				$left = $timeout - ( microtime( true ) - $start );
				if ( $left <= 0.05 ) {
					return 0;
				}
				$args  = [ 'timeout' => $left, 'redirection' => 0, 'sslverify' => ! $local, 'user-agent' => 'Mench Migrate link check; ' . home_url( '/' ) ];
				$probe = add_query_arg( 'doing_wp_cron', sprintf( '%.4F', microtime( true ) ), $url ); // No WP-Cron spawn from this visit.
				$res   = wp_remote_head( $probe, $args );
				$code  = is_wp_error( $res ) ? 0 : (int) wp_remote_retrieve_response_code( $res );
				if ( 405 === $code || 501 === $code ) {
					$res  = wp_remote_get( $probe, $args + [ 'limit_response_size' => 65536 ] );
					$code = is_wp_error( $res ) ? 0 : (int) wp_remote_retrieve_response_code( $res );
				}
				$location = $code >= 300 && $code < 400 ? (string) wp_remote_retrieve_header( $res, 'location' ) : '';
				if ( '' === $location ) {
					return $code;
				}
				$next = WP_Http::make_absolute_url( $location, $url );
				$next = remove_query_arg( 'doing_wp_cron', $next );
				if ( strtolower( (string) wp_parse_url( $next, PHP_URL_HOST ) ) !== $host ) {
					return -$code; // Off this site: not followed.
				}
				$url = $next;
			}
			return 0; // Too many redirects.
		} catch ( Throwable $e ) {
			return 0;
		}
	}
}