<?php
/**
 * Entity Profile → homepage schema refresh.
 *
 * The site-wide business entity node (Organization / LocalBusiness / subtype)
 * is baked into the homepage's stored schema at generation time. Editing the
 * Entity Profile afterwards — locally in wp-admin, or on the SaaS dashboard
 * (pulled in by Schema_AI_Sync) — only updates the plugin's settings, so the
 * already-stored homepage node stays stale until the next full regeneration.
 *
 * This rebuilds just that one node in place whenever the profile changes,
 * with no AI call and nothing billed against the generation allowance, using
 * the exact same builder the generate endpoint uses
 * (Schema_AI_Entity_Schema_Builder), then invalidates the homepage's schema
 * cache so the new markup renders on the next page load.
 *
 * Mirrors the backend's remergeEntityIntoStoredPages() for Next.js sites.
 *
 * Limits, by design (same as the backend):
 *  - Only the homepage's full entity block. Other pages carry a lightweight
 *    publisher @id reference; its wording only changes on a legal-name change,
 *    which still needs a full "Republish" from the dashboard.
 *  - Only runs on a static front page (Settings → Reading → "A static page").
 *    A "your latest posts" homepage renders no plugin schema at all.
 *
 * @package Schema_AI
 * @since   1.0.35
 */

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

class Schema_AI_Entity_Refresh {

	/**
	 * Re-entrancy guard: a refresh fires do_action( 'schema_ai_schema_saved' ),
	 * which can schedule a sync, whose response can (rarely) apply a remote
	 * profile and write the option again.
	 *
	 * @var bool
	 */
	private static $running = false;

	/**
	 * schema_ai_settings keys that feed the homepage entity node. A change to
	 * any of them means the stored node may be out of date. Kept a touch wide
	 * on purpose — a false positive just costs one no-op rebuild, which the
	 * content-diff check below then discards without touching the cache.
	 *
	 * @var string[]
	 */
	private static $entity_keys = array(
		'entity_same_as',
		'entity_knows_about',
		'entity_legal_name',
		'entity_founding_date',
		'entity_description',
		'entity_num_employees',
		'entity_founders',
		'entity_tax_id',
		'entity_vat_id',
		'entity_company_number',
		'entity_service_area',
		'entity_has_physical_location',
		'site_type',
		'business_subtype',
		'default_organization',
		'default_org_name',
		'default_org_logo',
		'default_org_phone',
		'default_org_email',
		'default_org_address',
		'default_org_city',
		'default_org_state',
		'default_org_zip',
		'default_org_country',
	);

	/**
	 * Wire the option hooks. Registered against both add_option and
	 * update_option because a fresh install has no schema_ai_settings row yet.
	 * Priority 20 so Schema_AI_Entity_Settings::track_change() (priority 10)
	 * has already stamped the local-change timestamp.
	 */
	public static function init() {
		add_action( 'update_option_schema_ai_settings', array( __CLASS__, 'on_option_updated' ), 20, 2 );
		add_action( 'add_option_schema_ai_settings', array( __CLASS__, 'on_option_added' ), 20, 2 );
	}

	/**
	 * add_option_{$option} passes ( $option_name, $value ).
	 *
	 * @param string $option Option name.
	 * @param mixed  $value  New value.
	 */
	public static function on_option_added( $option, $value ) {
		self::maybe_refresh( array(), is_array( $value ) ? $value : array() );
	}

	/**
	 * update_option_{$option} passes ( $old_value, $new_value ).
	 *
	 * @param mixed $old_value Previous value.
	 * @param mixed $new_value New value.
	 */
	public static function on_option_updated( $old_value, $new_value ) {
		self::maybe_refresh(
			is_array( $old_value ) ? $old_value : array(),
			is_array( $new_value ) ? $new_value : array()
		);
	}

	/**
	 * Run the refresh if one of the entity-feeding keys actually changed.
	 *
	 * @param array $old
	 * @param array $new
	 */
	private static function maybe_refresh( $old, $new ) {
		if ( self::$running ) {
			return;
		}
		if ( ! self::entity_input_changed( $old, $new ) ) {
			return;
		}

		self::$running = true;
		try {
			self::refresh_homepage_entity();
		} catch ( Exception $e ) {
			// A stale node is not worth a fatal on someone's settings save.
			if ( defined( 'WP_DEBUG' ) && WP_DEBUG ) {
				error_log( 'AI Schema Gen: entity refresh failed — ' . $e->getMessage() );
			}
		}
		self::$running = false;
	}

	/**
	 * @param array $old
	 * @param array $new
	 * @return bool
	 */
	private static function entity_input_changed( $old, $new ) {
		foreach ( self::$entity_keys as $key ) {
			$o = array_key_exists( $key, $old ) ? $old[ $key ] : null;
			$n = array_key_exists( $key, $new ) ? $new[ $key ] : null;
			if ( $o !== $n ) {
				return true;
			}
		}
		return false;
	}

	/**
	 * Rebuild the homepage's stored entity node from current settings and
	 * invalidate its cache.
	 */
	private static function refresh_homepage_entity() {
		if ( ! class_exists( 'Schema_AI_Entity_Schema_Builder' ) ) {
			return;
		}

		// Schema is only ever rendered on a static front page.
		if ( 'page' !== get_option( 'show_on_front' ) ) {
			return;
		}
		$home_id = (int) get_option( 'page_on_front' );
		if ( $home_id <= 0 ) {
			return;
		}

		// Nothing configured yet → generation wouldn't inject an entity node
		// either, so there is nothing to keep in sync.
		if ( ! Schema_AI_Entity_Schema_Builder::should_inject( $home_id ) ) {
			return;
		}

		$fresh = Schema_AI_Entity_Schema_Builder::build( $home_id );
		if ( empty( $fresh['@type'] ) || empty( $fresh['@id'] ) || empty( $fresh['name'] ) ) {
			// build() returns a bare stub when the homepage post has no usable
			// data (trashed / draft). Never overwrite a good stored node with
			// that.
			return;
		}

		global $wpdb;
		$table    = esc_sql( $wpdb->prefix . 'schema_ai_schemas' );
		$new_type = is_array( $fresh['@type'] ) ? $fresh['@type'][0] : $fresh['@type'];
		$new_json = wp_json_encode( $fresh, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE );

		// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- custom table, no WP API alternative.
		$rows = $wpdb->get_results(
			$wpdb->prepare(
				// phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- table name sanitized via esc_sql().
				"SELECT id, schema_type, schema_data FROM {$table} WHERE post_id = %d",
				$home_id
			)
		);

		// Locate the stored entity row: the one whose decoded @id is the
		// site-wide entity @id. Type-independent, so it survives a retype
		// (e.g. Organization → WebApplication when a subtype is configured).
		$target        = null;
		$entity_at_id  = $fresh['@id'];
		$entity_types  = array( 'Organization', 'LocalBusiness', 'Corporation' );
		if ( class_exists( 'Schema_AI_Business_Subtype' ) ) {
			$entity_types[] = Schema_AI_Business_Subtype::get_type_from_settings();
		}

		foreach ( (array) $rows as $row ) {
			$decoded = json_decode( $row->schema_data, true );
			if ( ! is_array( $decoded ) ) {
				continue;
			}
			if ( isset( $decoded['@id'] ) && $decoded['@id'] === $entity_at_id ) {
				$target = $row;
				break;
			}
		}
		// Fallback for older rows that may predate a stable @id: match on an
		// entity-like @type, or the tell-tale PostalAddress.
		if ( null === $target ) {
			foreach ( (array) $rows as $row ) {
				$decoded = json_decode( $row->schema_data, true );
				if ( ! is_array( $decoded ) ) {
					continue;
				}
				$type = isset( $decoded['@type'] )
					? ( is_array( $decoded['@type'] ) ? $decoded['@type'][0] : $decoded['@type'] )
					: '';
				if ( in_array( $type, $entity_types, true )
					|| ( isset( $decoded['address']['@type'] ) && 'PostalAddress' === $decoded['address']['@type'] ) ) {
					$target = $row;
					break;
				}
			}
		}

		$now    = current_time( 'mysql' );
		$status = Schema_AI_Entity_Schema_Builder::validation_status( $fresh );

		if ( null !== $target ) {
			// Byte-identical → nothing to do. Don't churn the cache or nudge sync.
			if ( (string) $target->schema_data === (string) $new_json ) {
				return;
			}
			// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- custom table.
			$wpdb->update(
				$table,
				array(
					'schema_type'       => sanitize_text_field( $new_type ),
					'schema_data'       => $new_json,
					'validation_status' => $status,
					'updated_at'        => $now,
				),
				array( 'id' => (int) $target->id ),
				array( '%s', '%s', '%s', '%s' ),
				array( '%d' )
			);
		} else {
			// No entity row yet (business info just configured for the first
			// time, homepage generated before that). Add one.
			// phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- custom table.
			$wpdb->insert(
				$table,
				array(
					'post_id'           => $home_id,
					'schema_type'       => sanitize_text_field( $new_type ),
					'schema_data'       => $new_json,
					'is_auto_generated' => 1,
					'validation_status' => $status,
					'created_at'        => $now,
					'updated_at'        => $now,
				),
				array( '%d', '%s', '%s', '%d', '%s', '%s', '%s' )
			);
		}

		if ( class_exists( 'Schema_AI_Schema_Cache' ) ) {
			$cache = new Schema_AI_Schema_Cache();
			$cache->invalidate( $home_id );
		}

		// Let the sync engine report the change to the dashboard, same as a
		// real generation would.
		do_action( 'schema_ai_schema_saved', $home_id );
	}
}