<?php

declare( strict_types=1 );

namespace AcezSeo\Schema;

use AcezSeo\Data\MetaFields;
use AcezSeo\Data\PostMetaRepositoryInterface;

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

/**
 * Assembles the final `@graph` array from every schema type that applies to a
 * post, then layers on per-post customization (in order of precedence):
 * 1. A full raw-JSON override (MetaFields::SCHEMA_JSON) replaces everything.
 * 2. Otherwise, custom nodes (MetaFields::CUSTOM_SCHEMAS) are merged in
 *    alongside the auto-generated ones.
 */
final class SchemaGraphBuilder
{
	private SchemaRegistry $registry;
	private PostMetaRepositoryInterface $post_meta;

	public function __construct( SchemaRegistry $registry, PostMetaRepositoryInterface $post_meta )
	{
		$this->registry  = $registry;
		$this->post_meta = $post_meta;
	}

	/**
	 * @return array<string, mixed>
	 */
	public function build( \WP_Post $post ): array
	{
		return $this->resolve_shortcodes( $this->assemble( $post ) );
	}

	/**
	 * @return array<string, mixed>
	 */
	private function assemble( \WP_Post $post ): array
	{
		$override = $this->full_override( $post );

		if ( null !== $override )
		{
			return $override;
		}

		$graph = array();

		foreach ( $this->registry->all() as $type )
		{
			if ( ! $type instanceof SchemaTypeInterface || ! $type->applies_to( $post ) )
			{
				continue;
			}

			$graph[] = $type->build( $post );
		}

		$graph = array_merge( $graph, $this->custom_nodes( $post ) );

		// inLanguage on every node (BCP 47, e.g. "pl-PL") — the post's own
		// language when a multilingual plugin is active (a translation is a
		// separate WP_Post), otherwise the site locale. Nodes that already
		// set it (e.g. custom user nodes) are left untouched.
		$language = \AcezSeo\Support\MultilingualPluginDetector::post_language( $post );

		foreach ( $graph as $index => $node )
		{
			if ( is_array( $node ) && ! isset( $node['inLanguage'] ) )
			{
				$graph[ $index ]['inLanguage'] = $language;
			}
		}

		/**
		 * Filters the assembled @graph nodes before output.
		 *
		 * @param array<int, array<string, mixed>> $graph
		 * @param \WP_Post                          $post
		 */
		$graph = (array) apply_filters( 'acez_seo_graph', $graph, $post );

		return array(
			'@context' => 'https://schema.org',
			'@graph'   => $this->strip_dangling_publisher( array_values( $graph ) ),
		);
	}

	/**
	 * Reference integrity for the Organization scope (and filter removals):
	 * WebSite/Article point at the Organization node via publisher @id — when
	 * that node is absent from THIS page's graph (narrowed organization_scope,
	 * node removed by a developer filter), the dangling reference must go too.
	 *
	 * @param array<int, mixed> $nodes
	 *
	 * @return array<int, mixed>
	 */
	private function strip_dangling_publisher( array $nodes ): array
	{
		$organization_id = SchemaIds::organization();

		foreach ( $nodes as $node )
		{
			if ( is_array( $node ) && ( $node['@id'] ?? '' ) === $organization_id )
			{
				return $nodes; // Organization present — references are valid.
			}
		}

		foreach ( $nodes as $index => $node )
		{
			if ( is_array( $node ) && ( $node['publisher']['@id'] ?? '' ) === $organization_id )
			{
				unset( $nodes[ $index ]['publisher'] );
			}
		}

		return array_values( $nodes );
	}

	/**
	 * Runs shortcodes in every string value of the graph — covers auto types,
	 * custom repeater nodes, the full raw-JSON override and filter-injected
	 * nodes alike. Shortcode output is stripped of HTML (JSON-LD wants plain
	 * text). Values with a literal `[` that match no registered shortcode come
	 * back from do_shortcode() unchanged and are left byte-for-byte untouched;
	 * `@…` keys (@id/@type/@context) are never rewritten.
	 *
	 * @param array<int|string, mixed> $graph
	 * @return array<int|string, mixed>
	 */
	private function resolve_shortcodes( array $graph ): array
	{
		foreach ( $graph as $key => $value )
		{
			if ( is_array( $value ) )
			{
				$graph[ $key ] = $this->resolve_shortcodes( $value );
				continue;
			}

			if ( is_string( $key ) && str_starts_with( $key, '@' ) )
			{
				continue;
			}

			if ( ! is_string( $value ) || ! str_contains( $value, '[' ) )
			{
				continue;
			}

			$resolved = do_shortcode( $value );

			if ( $resolved !== $value )
			{
				$graph[ $key ] = wp_strip_all_tags( $resolved );
			}
		}

		return $graph;
	}

	/**
	 * @return array<string, mixed>|null
	 */
	private function full_override( \WP_Post $post ): ?array
	{
		$raw = (string) $this->post_meta->get( $post->ID, MetaFields::SCHEMA_JSON );

		if ( '' === $raw )
		{
			return null;
		}

		$decoded = json_decode( $raw, true );

		if ( ! is_array( $decoded ) || JSON_ERROR_NONE !== json_last_error() )
		{
			return null;
		}

		// Equivalent of array_is_list() written out by hand: Plugin Check's
		// WP-function-compatibility scanner flags array_is_list() as requiring
		// WP 6.5 because core only added a *polyfill* for it then — but it's a
		// native PHP 8.1 function, and 8.1 is this plugin's PHP floor, so the
		// polyfill (and the version claim) doesn't apply here.
		if ( array_values( $decoded ) === $decoded )
		{
			return array(
				'@context' => 'https://schema.org',
				'@graph'   => $decoded,
			);
		}

		if ( isset( $decoded['@graph'] ) )
		{
			return array_merge( array( '@context' => 'https://schema.org' ), $decoded );
		}

		return array(
			'@context' => 'https://schema.org',
			'@graph'   => array( $decoded ),
		);
	}

	/**
	 * @return array<int, array<string, mixed>>
	 */
	private function custom_nodes( \WP_Post $post ): array
	{
		$raw = (string) $this->post_meta->get( $post->ID, MetaFields::CUSTOM_SCHEMAS );

		if ( '' === $raw )
		{
			return array();
		}

		$items = json_decode( $raw, true );

		if ( ! is_array( $items ) )
		{
			return array();
		}

		$nodes = array();

		foreach ( $items as $item )
		{
			if ( is_array( $item ) && isset( $item['node'] ) && is_array( $item['node'] ) )
			{
				$nodes[] = $item['node'];
			}
		}

		return $nodes;
	}
}