<?php
/**
 * Coexistence with JSON-LD from other plugins (Yoast, Rank Math, AIOSEO,
 * SEOPress, Schema Pro, WooCommerce built-in, page builders, etc.).
 *
 * Three modes (see smfree_get_coexistence_mode()):
 *
 *   merge                 Default. Before emitting, scan the page for
 *                         third-party JSON-LD and drop every node from OUR
 *                         graph whose @type a third party already emits.
 *                         Third-party output is never modified. References
 *                         in our remaining nodes that pointed at a dropped
 *                         node are repointed at the third-party node when
 *                         its @id uses a known fragment (#website, ...).
 *   suppress_third_party  Emit our full graph and empty Yoast's and Rank
 *                         Math's graphs via their own filters. Other plugins
 *                         are not affected.
 *   emit_alongside        Emit our full graph, touch nothing. Duplicates by
 *                         design.
 *
 * @package SchemaMonsterFree
 */

namespace SchemaMonsterFree;

if ( ! defined( 'ABSPATH' ) ) {
	exit;
}

/**
 * JSON-LD coexistence handler.
 */
final class Coexistence {

	const MODE_MERGE    = 'merge';
	const MODE_SUPPRESS = 'suppress_third_party';
	const MODE_EMIT     = 'emit_alongside';

	/**
	 * Resolve the effective coexistence mode.
	 *
	 * @return string One of the MODE_* constants.
	 */
	public static function resolve_mode(): string {
		return smfree_get_coexistence_mode();
	}

	// ------------------------------------------------------------------
	// Suppress mode.
	// ------------------------------------------------------------------

	/**
	 * Empty Yoast's and Rank Math's schema graphs for this request. Must run
	 * before wp_head, since both plugins print their JSON-LD there.
	 */
	public static function register_suppression(): void {
		add_filter( 'wpseo_schema_graph', array( __CLASS__, 'empty_graph' ), 999 );
		add_filter( 'rank_math/json_ld', array( __CLASS__, 'empty_graph' ), 999 );

		/**
		 * Action: suppress schema from additional third-party plugins. Fires
		 * on qualifying frontend requests in suppress_third_party mode, early
		 * enough (template_redirect) to register filters before wp_head.
		 */
		do_action( 'smfree_suppress_third_party_schema' );
	}

	/**
	 * Filter callback that discards a third-party graph.
	 *
	 * @return array<int,mixed>
	 */
	public static function empty_graph(): array {
		return array();
	}

	// ------------------------------------------------------------------
	// Merge mode.
	// ------------------------------------------------------------------

	/**
	 * Every @type emitted at the top level of third-party JSON-LD in a page.
	 *
	 * @param string $html Full page HTML.
	 * @return array<int,string>
	 */
	public static function detect_third_party_output( string $html ): array {
		return self::types_of( self::extract_third_party_nodes( $html ) );
	}

	/**
	 * Unique @type values across a list of nodes.
	 *
	 * @param array<int,array<string,mixed>> $nodes Nodes.
	 * @return array<int,string>
	 */
	public static function types_of( array $nodes ): array {
		$types = array();
		foreach ( $nodes as $node ) {
			$types = array_merge( $types, self::node_types( $node ) );
		}
		return array_values( array_unique( $types ) );
	}

	/**
	 * Top-level nodes from every JSON-LD script in a page except our own.
	 * Malformed scripts are skipped.
	 *
	 * @param string $html Full page HTML.
	 * @return array<int,array<string,mixed>>
	 */
	public static function extract_third_party_nodes( string $html ): array {
		$pattern = '#(<script\b[^>]*\btype\s*=\s*["\']application/ld\+json["\'][^>]*>)(.*?)</script\s*>#is';
		if ( ! preg_match_all( $pattern, $html, $matches, PREG_SET_ORDER ) ) {
			return array();
		}

		$nodes = array();
		foreach ( $matches as $match ) {
			// Never count our own script tag.
			if ( preg_match( '/\bid\s*=\s*["\']schema-monster-jsonld["\']/i', $match[1] ) ) {
				continue;
			}
			$data = json_decode( trim( $match[2] ), true );
			if ( ! is_array( $data ) ) {
				continue;
			}
			// A script may hold a list of documents, each with its own @graph.
			$documents = self::is_list( $data ) ? $data : array( $data );
			foreach ( $documents as $document ) {
				if ( is_array( $document ) ) {
					$nodes = array_merge( $nodes, self::extract_nodes( $document ) );
				}
			}
		}
		return $nodes;
	}

	/**
	 * Drop every node from our graph whose @type a third party already
	 * emits, then repoint references to dropped nodes at the matching
	 * third-party node where one can be identified.
	 *
	 * @param array<string,mixed>            $graph             Our graph (with @context/@graph).
	 * @param array<int,string>              $third_party_types Types from detect_third_party_output().
	 * @param array<int,array<string,mixed>> $third_party_nodes Nodes from extract_third_party_nodes(), used to repoint references.
	 * @return array<string,mixed> Filtered graph, or an empty array when nothing remains.
	 */
	public static function filter_graph_merge( array $graph, array $third_party_types, array $third_party_nodes = array() ): array {
		if ( empty( $graph['@graph'] ) || ! is_array( $graph['@graph'] ) || empty( $third_party_types ) ) {
			return $graph;
		}

		$kept    = array();
		$dropped = array();
		foreach ( $graph['@graph'] as $node ) {
			if ( is_array( $node ) && ! empty( array_intersect( self::node_types( $node ), $third_party_types ) ) ) {
				$dropped[] = $node;
				continue;
			}
			$kept[] = $node;
		}

		if ( empty( $kept ) ) {
			return array();
		}

		$replacements = self::reference_replacements( $dropped, $third_party_nodes );
		if ( ! empty( $replacements ) ) {
			foreach ( $kept as $i => $node ) {
				if ( is_array( $node ) ) {
					$kept[ $i ] = self::rewrite_references( $node, $replacements, true );
				}
			}
		}

		$graph['@graph'] = $kept;
		return $graph;
	}

	/**
	 * Map each dropped node's @id to the @id of a third-party node of the
	 * same @type, when the third-party @id ends in a known fragment for that
	 * type. Non-standard fragments are left unmapped (our reference stays as
	 * it was).
	 *
	 * @param array<int,array<string,mixed>> $dropped           Our dropped nodes.
	 * @param array<int,array<string,mixed>> $third_party_nodes Third-party nodes.
	 * @return array<string,string> Old @id => new @id.
	 */
	private static function reference_replacements( array $dropped, array $third_party_nodes ): array {
		/**
		 * Filter: @id fragments that identify a node's type, used to repoint
		 * references when Merge mode drops one of our nodes in favour of a
		 * third-party node. Keys are fragments including '#'; values are
		 * schema.org types.
		 *
		 * @param array<string,string> $fragments Fragment => @type.
		 */
		$fragments = (array) apply_filters(
			'smfree_known_fragments',
			array(
				'#webpage'      => 'WebPage',
				'#website'      => 'WebSite',
				'#organization' => 'Organization',
				'#breadcrumb'   => 'BreadcrumbList',
				'#person'       => 'Person',
			)
		);
		$fragments = array_change_key_case( $fragments, CASE_LOWER );

		// Type => first third-party @id whose fragment is known for that type.
		$targets = array();
		foreach ( $third_party_nodes as $node ) {
			$id = isset( $node['@id'] ) && is_string( $node['@id'] ) ? trim( $node['@id'] ) : '';
			if ( '' === $id ) {
				continue;
			}
			$fragment = wp_parse_url( $id, PHP_URL_FRAGMENT );
			if ( ! is_string( $fragment ) || '' === $fragment ) {
				continue;
			}
			$fragment_type = $fragments[ '#' . strtolower( $fragment ) ] ?? '';
			if ( '' !== $fragment_type && in_array( $fragment_type, self::node_types( $node ), true ) && ! isset( $targets[ $fragment_type ] ) ) {
				$targets[ $fragment_type ] = $id;
			}
		}

		$replacements = array();
		foreach ( $dropped as $node ) {
			$old = isset( $node['@id'] ) && is_string( $node['@id'] ) ? $node['@id'] : '';
			if ( '' === $old ) {
				continue;
			}
			foreach ( self::node_types( $node ) as $type ) {
				if ( isset( $targets[ $type ] ) ) {
					$replacements[ $old ] = $targets[ $type ];
					break;
				}
			}
		}
		return $replacements;
	}

	/**
	 * Recursively replace nested @id values. The top-level node's own @id is
	 * left alone.
	 *
	 * @param array<int|string,mixed> $value        Node or nested value.
	 * @param array<string,string>    $replacements Old @id => new @id.
	 * @param bool                    $is_root      True for the top-level node.
	 * @return array<int|string,mixed>
	 */
	private static function rewrite_references( array $value, array $replacements, bool $is_root = false ): array {
		foreach ( $value as $key => $item ) {
			if ( is_array( $item ) ) {
				$value[ $key ] = self::rewrite_references( $item, $replacements );
			} elseif ( ! $is_root && '@id' === $key && is_string( $item ) && isset( $replacements[ $item ] ) ) {
				$value[ $key ] = $replacements[ $item ];
			}
		}
		return $value;
	}

	// ------------------------------------------------------------------
	// Internals.
	// ------------------------------------------------------------------

	/**
	 * Normalize a graph document into a flat list of nodes.
	 *
	 * @param array<string,mixed> $data Decoded JSON-LD.
	 * @return array<int,array<string,mixed>>
	 */
	private static function extract_nodes( array $data ): array {
		if ( isset( $data['@graph'] ) && is_array( $data['@graph'] ) ) {
			return array_values( array_filter( $data['@graph'], 'is_array' ) );
		}
		return isset( $data['@type'] ) || isset( $data['@id'] ) ? array( $data ) : array();
	}

	/**
	 * Normalize a node's @type into a flat string array.
	 *
	 * @param array<string,mixed> $node A JSON-LD node.
	 * @return array<int,string>
	 */
	private static function node_types( array $node ): array {
		$types = $node['@type'] ?? array();
		return array_values( array_filter( is_array( $types ) ? $types : array( $types ), 'is_string' ) );
	}

	/**
	 * True for a sequential 0-indexed array.
	 *
	 * @param array<int|string,mixed> $value Array to test.
	 */
	private static function is_list( array $value ): bool {
		return array_keys( $value ) === range( 0, count( $value ) - 1 );
	}
}