metasync / includes / class-metasync-opengraph.php

class-metasync-opengraph.php in Search Atlas SEO – OTTO AI SEO Automation for WordPress 2.7.2, at includes/class-metasync-opengraph.php

2,438 lines 107.6 KB

Raw Download Zip

1	<?php
2
3	/**
4	* The Open Graph functionality of the plugin.
5	*
6	* @package MetaSync
7	* @subpackage MetaSync/includes
8	* @since 1.0.0
9	*/
10
11	# Prevent direct access
12	if (!defined('ABSPATH')) {
13	exit;
14	}
15
16	/**
17	* Open Graph Tags Generator Class
18	*
19	* This class handles the generation and management of Open Graph and Twitter Card tags
20	* for WordPress posts and pages.
21	*/
22	class Metasync_OpenGraph {
23
24	/**
25	* The ID of this plugin.
26	*/
27	private $plugin_name;
28
29	/**
30	* The version of this plugin.
31	*/
32	private $version;
33
34	/**
35	* Most recently constructed instance, for cross-class reuse of the value
36	* resolvers (e.g. the OTTO buffer needs the same default OG values the meta
37	* box pre-fills, to tell an auto-filled default from a user-customized value).
38	*
39	* @var Metasync_OpenGraph\|null
40	*/
41	private static $instance;
42
43	/**
44	* Per-request memo for get_default_og_values(), keyed on post ID. See that
45	* method for why the defaults are worth memoizing and where the memo is
46	* dropped.
47	*
48	* @var array<int, array{title:string,description:string,image:string}>
49	*/
50	private static $default_og_values_memo = [];
51
52	/**
53	* Meta box ID
54	*/
55	const META_BOX_ID = 'metasync_opengraph_meta_box';
56
57	/**
58	* The social title/description keys the meta box pre-fills from the post
59	* title/excerpt and persists on save. These are the keys that can capture the
60	* "Auto Draft" placeholder WordPress gives a brand-new, still-untitled post.
61	*/
62	const AUTO_DRAFT_PRONE_KEYS = [
63	'_metasync_og_title',
64	'_metasync_og_description',
65	'_metasync_twitter_title',
66	'_metasync_twitter_description',
67	];
68
69	/**
70	* The social title keys whose meta box default is the post title itself.
71	* Unlike the description keys — whose pre-fill (the excerpt) is content the
72	* editor curates separately — these mirror the title verbatim, so a stored
73	* value equal to it carries no information of its own: it is the pre-fill
74	* snapshot, not a customization. Reads collapse such rows to '' so the live
75	* title (which a rename keeps fresh) applies instead.
76	*/
77	const TITLE_DEFAULTED_KEYS = [
78	'_metasync_og_title',
79	'_metasync_twitter_title',
80	];
81
82	/**
83	* The social description keys whose meta box default is the resolved
84	* description (the excerpt the emitter would derive). The pre-fill persisted
85	* that default verbatim on save, so rows exist where these keys hold a copy
86	* of the excerpt as it was on save day — stale the moment the excerpt or the
87	* content it is generated from changes. Reads collapse such rows to '' so
88	* the live default applies instead. A value that differs from the default is
89	* untouched: only text the editor genuinely typed survives.
90	*/
91	const DESCRIPTION_DEFAULTED_KEYS = [
92	'_metasync_og_description',
93	'_metasync_twitter_description',
94	];
95
96	/**
97	* Site option holding every "Auto Draft" placeholder variant this install
98	* has actually seen, keyed by nothing, de-duplicated, capped. Core fills a
99	* new post's title with __( 'Auto Draft' ) in the creating admin user's
100	* locale, and that translation is not loaded on front-end requests, so no
101	* render-time literal/translation list can be complete. The registry is the
102	* locale-free source of truth: captured verbatim at creation time in admin,
103	* where the translation does resolve, and re-read anywhere.
104	*/
105	const AUTO_DRAFT_PLACEHOLDER_OPTION = 'metasync_auto_draft_placeholders';
106
107	/**
108	* Upper bound on registered placeholder variants. Locales change rarely;
109	* the cap keeps the site option tiny no matter how many editors come and
110	* go with different locales.
111	*/
112	const AUTO_DRAFT_PLACEHOLDER_CAP = 20;
113
114	/**
115	* Upper bound on posts held in the get_default_og_values() memo. One
116	* front-end render touches one or two posts; a back-end loop (an importer,
117	* a bulk action, a resync walking every post) would otherwise grow the
118	* memo — and the excerpt-derivation results it caches — without end for
119	* the life of the request. When full the oldest entry is dropped first:
120	* insertion order is the only order the memo has, and a dropped post
121	* simply re-derives on its next read.
122	*/
123	const DEFAULT_OG_VALUES_MEMO_CAP = 10;
124
125	/**
126	* Per-post flag marking "this post was saved while its title was still the
127	* untitled placeholder". Stores the exact placeholder string that was
128	* recognized at save time, so the render path can suppress by state (flag
129	* present + title still equals it) rather than by string matching alone —
130	* a genuinely-titled post never carries the flag.
131	*/
132	const UNTITLED_FLAG_META = '_metasync_untitled_placeholder';
133
134	/**
135	* Initialize the class and set its properties.
136	*/
137	public function __construct($plugin_name, $version) {
138	$this->plugin_name = $plugin_name;
139	$this->version = $version;
140	self::$instance = $this;
141	}
142
143	/**
144	* Get the most recently constructed instance (null if none yet).
145	*
146	* @return Metasync_OpenGraph\|null
147	*/
148	public static function get_instance() {
149	return self::$instance;
150	}
151
152	/**
153	* Whether a value is the placeholder title WordPress assigns to a brand-new,
154	* still-untitled post.
155	*
156	* Core creates the row with a translated title —
157	* wp-admin/includes/post.php: 'post_title' => __( 'Auto Draft' ) — so matching
158	* only the English literal misses every localized site. Compare against the
159	* literal and the current locale's translation, so both an English install and
160	* a translated one are covered, as is a value stored before a locale switch.
161	* A third arm checks the captured-variant registry, because the translation
162	* only resolves in admin: on front-end requests __( 'Auto Draft' ) stays
163	* English even on a localized site, and a stored de_DE placeholder would
164	* otherwise pass every check above.
165	*
166	* Exact match after trim, never fuzzy: an editor who legitimately titles a post
167	* "Auto Draft" on purpose is a caller-side concern, and only the four social
168	* keys in AUTO_DRAFT_PRONE_KEYS are ever routed through here.
169	*
170	* @param mixed $value
171	* @return bool
172	*/
173	public static function is_auto_draft_title($value) {
174	if (!is_string($value)) {
175	return false;
176	}
177	$value = trim($value);
178	if ($value === '') {
179	return false;
180	}
181	# 'default' text domain, matching the __() call core itself uses.
182	if ($value === 'Auto Draft' \|\| $value === trim(__('Auto Draft', 'default'))) { // phpcs:ignore WordPress.WP.I18n.TextDomainMismatch -- resolves core's own 'Auto Draft' placeholder, which only exists in core's 'default' domain; the plugin text domain cannot reproduce it
183	return true;
184	}
185	# Registry arm: a variant captured in another locale's admin request.
186	# Without it the guard above is English-only on every non-admin request,
187	# because core never loads the 'default' MO files out there.
188	return in_array($value, self::known_auto_draft_placeholders(), true);
189	}
190
191	/**
192	* Every placeholder variant known to this install: the English literal plus
193	* whatever has been captured into the site option so far.
194	*
195	* @return string[]
196	*/
197	public static function known_auto_draft_placeholders() {
198	$stored = get_option(self::AUTO_DRAFT_PLACEHOLDER_OPTION, []);
199	if (!is_array($stored)) {
200	$stored = [];
201	}
202	$variants = ['Auto Draft'];
203	foreach ($stored as $variant) {
204	if (is_string($variant) && trim($variant) !== '' && !in_array(trim($variant), $variants, true)) {
205	$variants[] = trim($variant);
206	}
207	}
208	return $variants;
209	}
210
211	/**
212	* Capture a placeholder variant into the site option. Called from the
213	* admin save path, where the creating request's own __( 'Auto Draft' )
214	* has already verified the title is core's placeholder — so no
215	* translation is needed here, only de-duplication and capping.
216	*
217	* @param mixed $title Verbatim post title recognized as the placeholder.
218	* @return void
219	*/
220	public static function remember_auto_draft_placeholder($title) {
221	$title = is_string($title) ? trim($title) : '';
222	if ($title === '' \|\| $title === 'Auto Draft') {
223	return;
224	}
225	$known = self::known_auto_draft_placeholders();
226	if (in_array($title, $known, true)) {
227	return;
228	}
229	# Persist captured variants only: the English literal is seeded
230	# code-side by known_auto_draft_placeholders(), so storing it would be
231	# redundant state.
232	$captured = array_values(array_diff($known, ['Auto Draft']));
233	$captured[] = $title;
234	update_option(self::AUTO_DRAFT_PLACEHOLDER_OPTION, array_slice($captured, -self::AUTO_DRAFT_PLACEHOLDER_CAP), false);
235	}
236
237	/**
238	* admin_init callback: register the placeholder variant the current admin
239	* request's translation resolves to. remember_auto_draft_placeholder()
240	* de-duplicates, so repeated requests only cost one cached option read.
241	*
242	* @return void
243	*/
244	public static function seed_auto_draft_placeholder() {
245	self::remember_auto_draft_placeholder(__('Auto Draft', 'default')); // phpcs:ignore WordPress.WP.I18n.TextDomainMismatch -- resolves core's own 'Auto Draft' placeholder, which only exists in core's 'default' domain; the plugin text domain cannot reproduce it
246	}
247
248	/**
249	* Read a persisted social meta value, collapsing the "Auto Draft" placeholder
250	* to an empty string.
251	*
252	* Every consumer resolves these fields through a "first non-empty wins" chain
253	* (persisted key -> OTTO staging key -> real post title). A stored placeholder
254	* is truthy, so the chain would keep it; returning '' lets the chain fall
255	* through to the real title. That fixes rows already polluted before this fix
256	* shipped, at render time, without a DB migration.
257	*
258	* Public and static because the three consumers that actually emit or forward
259	* these values live in different classes: this emitter,
260	* Otto_html_class::apply_metabox_og_precedence(), and Metasync_Plugin_Sync's
261	* mirror into Yoast/RankMath/AIOSEO storage. Follows the same
262	* sanitize-at-the-source pattern as Metasync_Canonical_Sanitizer::sanitize().
263	*
264	* @param mixed $value Raw stored meta value.
265	* @return string
266	*/
267	public static function strip_auto_draft_title($value) {
268	if (self::is_auto_draft_title($value)) {
269	return '';
270	}
271	return is_scalar($value) ? (string) $value : '';
272	}
273
274	/**
275	* Read one of the AUTO_DRAFT_PRONE_KEYS for a post with the placeholder
276	* collapsed to '' — and, for the title keys, a stored snapshot of the
277	* title default the pre-fill showed (the post title, or the og title for
278	* the twitter twin), and for the description keys a stored snapshot of
279	* the resolved description, collapsed too.
280	*
281	* @param int $post_id
282	* @param string $key
283	* @return string
284	*/
285	public static function get_social_meta($post_id, $key) {
286	return self::strip_description_snapshot(
287	$post_id,
288	$key,
289	self::strip_title_snapshot(
290	$post_id,
291	$key,
292	self::strip_auto_draft_title(get_post_meta($post_id, $key, true))
293	)
294	);
295	}
296
297	/**
298	* Collapse a stored social title that merely mirrors the post's own title.
299	*
300	* The meta box used to pre-fill Title from the post title as a real value
301	* and persist it on save, so rows exist where `_metasync_og_title` (and the
302	* twitter twin) hold a verbatim copy of the title as it was on save day.
303	* Renaming the post then left that snapshot stale with nothing to tell it
304	* apart from a typed title. Collapsing it here — at the read, the same
305	* place the "Auto Draft" placeholder collapses — makes such a row read as
306	* unset, and the render-time fallback to the live title keeps the social
307	* title in step with every rename. A value that differs from the title is
308	* untouched: only text the editor genuinely typed survives.
309	*
310	* The twitter twin compares against what the og title field showed when
311	* the pre-fill was rendered — a stored og title if one is set, otherwise
312	* the same live post title — since that is exactly what the pre-fill
313	* echoed into the twitter field. Without that chain, a twitter row echoed
314	* from a typed og title would read as a deliberate override and stop
315	* following the og title it always rendered.
316	*
317	* Compared after trim on both sides: stored values pass through
318	* sanitize_text_field, which trims, so only the post title side can carry
319	* surrounding whitespace.
320	*
321	* Public and static for the same reason strip_auto_draft_title() is: the
322	* consumers live in different classes (this emitter, the precedence
323	* resolver, the plugin sync mirror, the SEO suite).
324	*
325	* @param int $post_id
326	* @param string $key One of TITLE_DEFAULTED_KEYS; others pass through.
327	* @param mixed $value Stored meta value, already placeholder-collapsed.
328	* @return string
329	*/
330	public static function strip_title_snapshot($post_id, $key, $value) {
331	$value = is_scalar($value) ? (string) $value : '';
332	if ($value === '' \|\| !in_array($key, self::TITLE_DEFAULTED_KEYS, true)) {
333	return $value;
334	}
335
336	$default = self::default_social_title($post_id, $key);
337	if ($default === '') {
338	return $value;
339	}
340
341	return trim($value) === trim($default) ? '' : $value;
342	}
343
344	/**
345	* The default a title key renders when its own field is blank: the live
346	* post title for the og key, and for the twitter key whatever the og field
347	* would show (a stored og title if one is set, otherwise the same live
348	* title) — the exact chain the meta box fallback used to pre-fill as a
349	* value and still shows as the twitter field's placeholder.
350	*
351	* social_post_title() — not the raw post_title — is what the pre-fill ever
352	* stored, and it returns '' for a still-untitled post, where there is no
353	* meaningful default to compare against anyway (such rows are the
354	* placeholder case strip_auto_draft_title() already handles).
355	*
356	* @param int $post_id
357	* @param string $key
358	* @return string
359	*/
360	private static function default_social_title($post_id, $key) {
361	$title = self::social_post_title(get_post($post_id));
362	if ($key === '_metasync_og_title') {
363	return $title;
364	}
365
366	$og = self::get_social_meta($post_id, '_metasync_og_title');
367	return $og !== '' ? $og : $title;
368	}
369
370	/**
371	* Collapse a stored social description that merely mirrors the default the
372	* meta box pre-filled.
373	*
374	* The meta box pre-filled Description from the resolved description (the
375	* manual excerpt, or one generated from the content) as a real value and
376	* persisted it on save, so rows exist where `_metasync_og_description` (and
377	* the twitter twin) hold a copy of the excerpt as it was on save day.
378	* Changing the excerpt — or the content the excerpt is generated from — then
379	* left that snapshot stale with nothing to tell it apart from a typed
380	* description. Collapsing it here — at the read, the same place the "Auto
381	* Draft" placeholder and title snapshots collapse — makes such a row read as
382	* unset, and the render-time fallback to the live excerpt keeps the social
383	* description in step. A value that differs from the default is untouched:
384	* only text the editor genuinely typed survives.
385	*
386	* The twitter twin compares against what the og description field showed
387	* when the pre-fill was rendered — a stored og description if one is set,
388	* otherwise the same resolved default — since that is exactly what the
389	* pre-fill echoed into the twitter field.
390	*
391	* Compared after whitespace normalization on both sides: descriptions pass
392	* through sanitize_textarea_field, which preserves line breaks, and a manual
393	* excerpt can carry them while the generated default cannot, so a snapshot
394	* and its default must be compared with runs of whitespace treated as one
395	* space rather than byte-for-byte.
396	*
397	* Public and static for the same reason strip_title_snapshot() is: the
398	* consumers live in different classes (this emitter, the precedence
399	* resolver, the plugin sync mirror, the SEO suite).
400	*
401	* @param int $post_id
402	* @param string $key One of DESCRIPTION_DEFAULTED_KEYS; others pass through.
403	* @param mixed $value Stored meta value, already placeholder-collapsed.
404	* @return string
405	*/
406	public static function strip_description_snapshot($post_id, $key, $value) {
407	$value = is_scalar($value) ? (string) $value : '';
408	if ($value === '' \|\| !in_array($key, self::DESCRIPTION_DEFAULTED_KEYS, true)) {
409	return $value;
410	}
411
412	$default = self::default_social_description($post_id, $key);
413	if ($default === '') {
414	return $value;
415	}
416
417	return self::normalize_description_compare($value) === self::normalize_description_compare($default)
418	? ''
419	: $value;
420	}
421
422	/**
423	* The default a description key renders when its own field is blank: the
424	* resolved description for the og key, and for the twitter key whatever the
425	* og field would show (a stored og description if one is set, otherwise the
426	* same resolved default — even when that default is empty) — the exact
427	* chain the meta box fallback used to pre-fill as a value.
428	*
429	* Resolved through the emitter's own instance so it matches what actually
430	* renders; when no instance is available the default cannot be proven, so ''
431	* is returned and the caller keeps the stored value rather than risk
432	* discarding text the editor typed.
433	*
434	* @param int $post_id
435	* @param string $key
436	* @return string
437	*/
438	private static function default_social_description($post_id, $key) {
439	$instance = self::get_instance();
440	if (!$instance) {
441	return '';
442	}
443
444	$default = (string) $instance->get_default_og_values($post_id)['description'];
445	if ($key === '_metasync_og_description') {
446	return $default;
447	}
448
449	# The og chain runs for the twitter twin even when the resolved default
450	# is empty: the pre-fill echoed the og description into the twitter
451	# field whenever the og field carried a value, so that — not the empty
452	# excerpt — is the default a stored twitter echo must match to collapse.
453	$og = self::get_social_meta($post_id, '_metasync_og_description');
454	return $og !== '' ? $og : $default;
455	}
456
457	/**
458	* Normalize a description for equality comparison: trimmed, with runs of
459	* whitespace collapsed to a single space. Falls back to a plain trim when
460	* the value is not valid UTF-8 and the /u pattern therefore fails.
461	*
462	* @param string $value
463	* @return string
464	*/
465	private static function normalize_description_compare($value) {
466	$normalized = preg_replace('/\s+/u', ' ', trim((string) $value));
467	return is_string($normalized) ? $normalized : trim((string) $value);
468	}
469
470	/**
471	* A post's title for social use, suppressing only WordPress's own placeholder.
472	*
473	* Distinct from strip_auto_draft_title(), which is for stored meta values:
474	* there the string is all we have, since a legacy row carries no clue about the
475	* status it was written under. A live post gives us both signals, so require
476	* both — the post is still an auto-draft AND its title is the placeholder. An
477	* editor who genuinely titles a published post "Auto Draft" (an article about
478	* the placeholder itself, say) keeps it as their og:title.
479	*
480	* @param WP_Post\|mixed $post
481	* @return string
482	*/
483	public static function social_post_title($post) {
484	if (!$post instanceof WP_Post) {
485	return '';
486	}
487	if ($post->post_status === 'auto-draft' && self::is_auto_draft_title($post->post_title)) {
488	return '';
489	}
490	# State-based arm: the post was saved while still untitled (flag set at
491	# save time, where translations resolve) and its title is still that
492	# flagged placeholder. This is what catches a placeholder-titled post
493	# that went on to be published — the status check above no longer
494	# matches it, and on a localized site the string checks cannot either.
495	$flagged = get_post_meta($post->ID, self::UNTITLED_FLAG_META, true);
496	if (is_string($flagged) && trim($flagged) !== '' && trim((string) $post->post_title) === trim($flagged)) {
497	return '';
498	}
499	return (string) $post->post_title;
500	}
501
502	/**
503	* Whether MetaSync social output is disabled for a post.
504	*
505	* The site-wide switch and the per-post switch both disable only MetaSync's
506	* social output; callers must leave third-party SEO output untouched.
507	*
508	* @param int $post_id Post ID.
509	* @return bool
510	*/
511	public static function is_social_output_disabled($post_id = 0) {
512	if (Metasync_Feature_Flags::is_disabled(Metasync_Feature_Flags::SOCIAL_OG)) {
513	return true;
514	}
515
516	return $post_id > 0 && get_post_meta($post_id, '_metasync_og_enabled', true) === '0';
517	}
518
519	/**
520	* The default OG values the meta box pre-fills for a post: post title,
521	* generated excerpt, and featured image. Computed with the same helpers the
522	* meta box/emitter use, so a caller can compare a stored _metasync_og_* value
523	* against the default and tell whether the user genuinely customized it (the
524	* meta box persists these defaults on save, so a non-empty value alone does
525	* not prove user intent).
526	*
527	* The title is returned empty on a still-untitled post rather than as the
528	* "Auto Draft" placeholder, so the meta box pre-fills nothing and callers
529	* comparing a stored value against this default don't read the placeholder as
530	* a deliberate override.
531	*
532	* Memoized per request: the values are pure functions of the post, and one
533	* front-end render resolves them several times (every collapsed description
534	* read asks for the default, and the OTTO precedence walk asks again) — on
535	* page-builder content the excerpt pass alone re-runs the whole
536	* shortcode-strip pipeline each time. The save handler drops the memo
537	* before its comparisons, since save_post fires after the post row write
538	* and the comparison must see the new title/excerpt. Capped at
539	* DEFAULT_OG_VALUES_MEMO_CAP posts for loops that walk many posts in one
540	* request.
541	*
542	* @param int $post_id
543	* @return array{title:string,description:string,image:string}
544	*/
545	public function get_default_og_values($post_id) {
546	$post_id = (int) $post_id;
547	// No real post: get_post(0) answers with the global post, which would
548	// then be memoized under key 0 and served for every later bogus id.
549	if ($post_id <= 0) {
550	return ['title' => '', 'description' => '', 'image' => ''];
551	}
552	if (isset(self::$default_og_values_memo[$post_id])) {
553	return self::$default_og_values_memo[$post_id];
554	}
555
556	$post = get_post($post_id);
557	if (!$post instanceof WP_Post) {
558	return ['title' => '', 'description' => '', 'image' => ''];
559	}
560
561	if (count(self::$default_og_values_memo) >= self::DEFAULT_OG_VALUES_MEMO_CAP) {
562	// unset() on the first key, NOT array_shift(): the memo is keyed by
563	// post id, and array_shift() reindexes integer keys from zero —
564	// after one eviction the survivors would live under 0..8 and any
565	// post with a low id would be served another post's defaults.
566	unset(self::$default_og_values_memo[array_key_first(self::$default_og_values_memo)]);
567	}
568	return self::$default_og_values_memo[$post_id] = [
569	'title' => self::social_post_title($post),
570	'description' => (string) $this->get_post_excerpt($post),
571	'image' => (string) $this->get_featured_image_url($post->ID),
572	];
573	}
574
575	/**
576	* Drop the get_default_og_values() memo. Called on the save path, where the
577	* just-written post row must be re-read rather than served from a memo
578	* populated earlier in the request; also the seam long-lived processes
579	* (tests, CLI) use to simulate a fresh request. Mirrors
580	* Metasync_Otto_Config::clear_cache().
581	*/
582	public static function clear_default_og_values_memo() {
583	self::$default_og_values_memo = [];
584	}
585
586	/**
587	* Register all hooks for this class
588	*/
589	public function init() {
590	# Admin hooks
591	add_action('add_meta_boxes', [$this, 'add_meta_box']);
592	# Runs before save_meta_box_data so the untitled flag it maintains is
593	# already current when the meta box save guard consults it.
594	add_action('save_post', [$this, 'track_untitled_post'], 5, 2);
595	add_action('save_post', [$this, 'save_meta_box_data']);
596	add_action('admin_enqueue_scripts', [$this, 'enqueue_admin_scripts']);
597
598	# Alternative script loading for post edit screens
599	add_action('admin_print_scripts-post.php', [$this, 'force_enqueue_scripts']);
600	add_action('admin_print_scripts-post-new.php', [$this, 'force_enqueue_scripts']);
601
602	# Frontend hooks
603	add_action('wp_head', [$this, 'output_opengraph_tags'], 5);
604	add_action('wp_head', [$this, 'output_article_tags'], 6);
605
606	# Update OpenGraph URL when post is published/updated
607	add_action('save_post', [$this, 'update_opengraph_url'], 20);
608
609	# Update OpenGraph URL when post permalink changes
610	add_action('post_updated', [$this, 'check_permalink_change'], 10, 3);
611
612	# Also check on transition_post_status for status changes
613	add_action('transition_post_status', [$this, 'check_status_change'], 10, 3);
614
615	# Check when post slug is updated via edit slug functionality
616	add_action('wp_ajax_sample-permalink', [$this, 'check_slug_change'], 5);
617
618	# AJAX hooks for preview
619	add_action('wp_ajax_metasync_og_preview', [$this, 'ajax_generate_preview']);
620
621	# Register cross-plugin dedup filters (Yoast / Rank Math) when their plugins are active
622	$this->register_dedup_filters();
623
624	# Keep the localized "Auto Draft" placeholder out of SEO-plugin titles
625	# for posts published while still untitled.
626	$this->register_untitled_title_filters();
627
628	# Seed the placeholder registry with this admin user's locale variant,
629	# so localized values are recognized everywhere even before any new
630	# post is created on a localized install.
631	if (is_admin()) {
632	add_action('admin_init', [self::class, 'seed_auto_draft_placeholder']);
633	}
634
635	# Shared predicate so the legacy emitter (Metasync_Seo_Output::hook_metasync_metatags)
636	# can suppress its own OG/Twitter blocks whenever this class will emit for the post
637	add_filter('metasync_opengraph_will_emit', [$this, 'will_emit']);
638	}
639
640	/**
641	* Shared predicate: returns true when output_opengraph_tags() will emit
642	* the consolidated OG/Twitter block for the current request.
643	*
644	* Mirrors the early-return guards in output_opengraph_tags() so this
645	* canonical emitter and the legacy emitter stay mutually exclusive —
646	* exactly one fires per page, and neither stays silent on a
647	* MetaSync-only site.
648	*
649	* @param bool $default Filter default (ignored; the real answer is computed).
650	* @return bool
651	*/
652	public function will_emit($default = false) {
653	# Feature switched off, so this emitter stays silent. The legacy emitter
654	# checks the same switch independently, so reporting false here cannot
655	# hand it the work.
656	if (Metasync_Feature_Flags::is_disabled(Metasync_Feature_Flags::SOCIAL_OG)) {
657	return false;
658	}
659
660	if (!is_singular($this->get_supported_post_types())) {
661	return false;
662	}
663
664	global $post;
665	if (!$post instanceof WP_Post) {
666	return false;
667	}
668
669	# Only an explicit '0' opt-out disables output; unset/empty counts as enabled
670	$og_enabled = get_post_meta($post->ID, '_metasync_og_enabled', true);
671	if ($og_enabled === '0') {
672	return false;
673	}
674
675	# OTTO active with persisted OG data owns the page (legacy emitter suppresses too)
676	if ($this->otto_owns_og($post->ID)) {
677	return false;
678	}
679
680	# Third-party SEO plugin active: yield entirely, legacy emitter keeps its original behavior
681	if (apply_filters('metasync_opengraph_check_conflicts', true) && $this->has_seo_plugin_conflicts()) {
682	return false;
683	}
684
685	return true;
686	}
687
688	/**
689	* Whether OTTO owns this page's Open Graph / Twitter output.
690	*
691	* When OTTO is enabled and has persisted OG data for the post, OTTO's
692	* dynamically-injected tags (and the buffer-level dedup) take precedence, so
693	* the per-post OG meta box values are not emitted on the frontend. Shared by
694	* the frontend emitter (to suppress duplicate output) and the admin meta box
695	* (to warn the user their values won't apply on an OTTO-managed page).
696	*
697	* @param int $post_id
698	* @return bool
699	*/
700	private function otto_owns_og($post_id) {
701	if (!class_exists('Metasync_Otto_Config') \|\| !Metasync_Otto_Config::is_otto_enabled()) {
702	return false;
703	}
704	$otto_og_title = get_post_meta($post_id, '_metasync_otto_og_title', true);
705	$otto_og_desc = get_post_meta($post_id, '_metasync_otto_og_description', true);
706	return !empty($otto_og_title) \|\| !empty($otto_og_desc);
707	}
708
709	/**
710	* Add the Open Graph meta box to post and page editors
711	*/
712	public function add_meta_box() {
713	# Don't show meta box if user's role doesn't have plugin access
714	if (!Metasync::current_user_has_plugin_access()) {
715	return;
716	}
717
718	# Check if user has permission to edit posts
719	if (!current_user_can('edit_posts')) {
720	return;
721	}
722
723	# Meta title and description are always enabled by default
724	$general_settings = Metasync::get_option('general', []);
725
726	# Check if Social Media & Open Graph meta box is disabled
727	if (!empty($general_settings['disable_social_opengraph_metabox'])) {
728	return;
729	}
730
731	# LPS / custom-HTML pages bake their own OG/social tags into their HTML bundle,
732	# served before wp_head — so this box does nothing on them. Hide it; the SEO
733	# read-only notice covers the messaging.
734	$lps_post_id = isset($_GET['post']) ? intval($_GET['post']) : (isset($_POST['post_ID']) ? intval($_POST['post_ID']) : 0); // phpcs:ignore WordPress.Security.NonceVerification.Missing, WordPress.Security.NonceVerification.Recommended -- read-only post ID to pick meta boxes
735	if (function_exists('metasync_is_custom_or_lps_page') && $lps_post_id > 0 && metasync_is_custom_or_lps_page($lps_post_id)) {
736	return;
737	}
738
739	# Get supported post types (allow filtering)
740	$post_types = $this->get_supported_post_types();
741	$plugin_name = Metasync::get_effective_plugin_name();
742
743	foreach ($post_types as $post_type) {
744	add_meta_box(
745	self::META_BOX_ID,
746	/* translators: %s: effective plugin name (whitelabel-aware). */
747	sprintf(esc_html__('Social Media & Open Graph by %s', 'metasync'), $plugin_name),
748	[$this, 'render_meta_box'],
749	$post_type,
750	'normal',
751	'high'
752	);
753	}
754	}
755
756	/**
757	* Render the meta box content
758	*/
759	public function render_meta_box($post) {
760	# Add nonce for security
761	wp_nonce_field('metasync_opengraph_nonce', 'metasync_opengraph_nonce');
762
763	# Get existing values. The four social title/description keys are read through
764	# get_social_meta(), which collapses the "Auto Draft" placeholder, a stored
765	# snapshot of the post title, and a stored snapshot of the resolved
766	# description to '' — so a polluted legacy row shows an empty field (the
767	# default lives in the placeholder) and re-saving clears it.
768	$og_enabled = get_post_meta($post->ID, '_metasync_og_enabled', true);
769	$og_title = self::get_social_meta($post->ID, '_metasync_og_title');
770	$og_description = self::get_social_meta($post->ID, '_metasync_og_description');
771	$og_image = get_post_meta($post->ID, '_metasync_og_image', true);
772	$og_url = get_post_meta($post->ID, '_metasync_og_url', true);
773	$og_type = get_post_meta($post->ID, '_metasync_og_type', true);
774
775	# Twitter Card fields
776	$twitter_card = get_post_meta($post->ID, '_metasync_twitter_card', true);
777	$twitter_site = get_post_meta($post->ID, '_metasync_twitter_site', true);
778	$twitter_title = self::get_social_meta($post->ID, '_metasync_twitter_title');
779	$twitter_description = self::get_social_meta($post->ID, '_metasync_twitter_description');
780	$twitter_image = get_post_meta($post->ID, '_metasync_twitter_image', true);
781	$twitter_image_alt = get_post_meta($post->ID, '_metasync_twitter_image_alt', true);
782
783	# Twitter App Card fields
784	$twitter_app_id_iphone = get_post_meta($post->ID, '_metasync_twitter_app_id_iphone', true);
785	$twitter_app_id_ipad = get_post_meta($post->ID, '_metasync_twitter_app_id_ipad', true);
786	$twitter_app_id_googleplay = get_post_meta($post->ID, '_metasync_twitter_app_id_googleplay', true);
787	$twitter_app_url_iphone = get_post_meta($post->ID, '_metasync_twitter_app_url_iphone', true);
788	$twitter_app_url_ipad = get_post_meta($post->ID, '_metasync_twitter_app_url_ipad', true);
789	$twitter_app_url_googleplay = get_post_meta($post->ID, '_metasync_twitter_app_url_googleplay', true);
790	$twitter_app_country = get_post_meta($post->ID, '_metasync_twitter_app_country', true);
791
792	# Twitter Player Card fields
793	$twitter_player = get_post_meta($post->ID, '_metasync_twitter_player', true);
794	$twitter_player_width = get_post_meta($post->ID, '_metasync_twitter_player_width', true);
795	$twitter_player_height = get_post_meta($post->ID, '_metasync_twitter_player_height', true);
796
797	# Set default values
798	# Note: Check for empty string specifically, not just empty(), since '0' is a valid value
799	if ($og_enabled === '') {
800	# For new posts, default to enabled
801	$og_enabled = '1';
802	}
803	# The post title is the default social title, but it is shown as a
804	# placeholder, never as the field's value. Submitting a page carries
805	# every value attribute to the save handler, so pre-filling the title
806	# persisted a verbatim snapshot of it — one a later rename left stale
807	# (and indistinguishable from a typed title). An empty field plus a
808	# placeholder keeps the default visible while storing nothing, and the
809	# render-time fallback to the live title tracks renames on its own.
810	# social_post_title() suppresses WordPress's own "Auto Draft"
811	# placeholder, so a brand-new post shows no misleading hint either.
812	$title_placeholder = self::social_post_title($post);
813	# What twitter:title actually renders when its own field is blank: the
814	# OG title if one is set, otherwise the same live post title. Shown as
815	# the twitter field's placeholder for the same reason as above.
816	$twitter_title_placeholder = ($og_title !== '') ? $og_title : $title_placeholder;
817	# The resolved description (the manual excerpt, or one generated from
818	# the content) is the default social description, and like the title it
819	# is shown as a placeholder, never as the field's value. Pre-filling it
820	# persisted a snapshot of the excerpt as of save day — one a later
821	# excerpt or content edit left stale, and indistinguishable from a
822	# typed description. An empty field plus a placeholder keeps the
823	# default visible while storing nothing, and the render-time fallback
824	# to the live excerpt tracks edits on its own.
825	$description_placeholder = $this->get_post_excerpt($post);
826	# What twitter:description actually renders when its own field is
827	# blank: the OG description if one is set, otherwise the same resolved
828	# default. Shown as the twitter field's placeholder for the same
829	# reason as above.
830	$twitter_description_placeholder = ($og_description !== '') ? $og_description : $description_placeholder;
831	if (empty($og_url)) {
832	$og_url = $this->get_canonical_url($post);
833	}
834	if (empty($og_type)) {
835	$og_type = 'article';
836	}
837	if (empty($og_image)) {
838	$og_image = $this->get_featured_image_url($post->ID);
839	}
840
841	# Twitter defaults
842	if (empty($twitter_card)) {
843	$twitter_card = 'summary_large_image';
844	}
845	if (empty($twitter_image)) {
846	$twitter_image = $og_image;
847	}
848
849	# Whether OTTO is managing this page's OG output (values below won't apply on the frontend)
850	$otto_owns_og = $this->otto_owns_og($post->ID);
851
852	# Include the meta box template
853	include plugin_dir_path(__FILE__) . '../admin/partials/metasync-opengraph-meta-box.php';
854	}
855
856	/**
857	* Save meta box data
858	*/
859	public function save_meta_box_data($post_id) {
860	# Drop the defaults memo before anything below can bail. This handler is
861	# hooked to save_post, so it runs for EVERY save of the post — including
862	# ones initiated by another meta box, a bulk action, or a sync flow that
863	# carries no OG nonce and would have returned early above the old flush
864	# position. Without this clear, a memo seeded earlier in the same request
865	# (a metabox render, a sync read) survives the post-row write and serves
866	# the pre-save title/excerpt to the snapshot comparisons in later
867	# save_post subscribers — the Yoast re-sync on shutdown among them.
868	self::clear_default_og_values_memo();
869
870	# Check if nonce is valid
871	if (!isset($_POST['metasync_opengraph_nonce']) \|\|
872	!wp_verify_nonce($_POST['metasync_opengraph_nonce'], 'metasync_opengraph_nonce')) {
873	return;
874	}
875
876	# Check if user has permission to edit
877	if (!current_user_can('edit_post', $post_id)) {
878	return;
879	}
880
881	# Check if this is an autosave
882	if (defined('DOING_AUTOSAVE') && DOING_AUTOSAVE) {
883	return;
884	}
885
886	# Handle the checkbox field separately (unchecked checkboxes don't send POST data)
887	# Meta title and description are always enabled by default
888	if (isset($_POST['_metasync_og_enabled'])) {
889	# User checked the box
890	update_post_meta($post_id, '_metasync_og_enabled', '1');
891	} else {
892	# User unchecked the box
893	update_post_meta($post_id, '_metasync_og_enabled', '0');
894	}
895
896	# Save Open Graph data (excluding the enabled field which is handled above)
897	$og_fields = [
898	'_metasync_og_title' => 'sanitize_text_field',
899	'_metasync_og_description' => 'sanitize_textarea_field',
900	'_metasync_og_image' => 'esc_url_raw',
901	'_metasync_og_url' => 'esc_url_raw',
902	'_metasync_og_type' => 'sanitize_text_field',
903	];
904
905	# Save Twitter Card data
906	$twitter_fields = [
907	'_metasync_twitter_card' => 'sanitize_text_field',
908	'_metasync_twitter_site' => 'sanitize_text_field',
909	'_metasync_twitter_title' => 'sanitize_text_field',
910	'_metasync_twitter_description' => 'sanitize_textarea_field',
911	'_metasync_twitter_image' => 'esc_url_raw',
912	'_metasync_twitter_image_alt' => 'sanitize_text_field',
913	];
914
915	# Save Twitter App Card data
916	$twitter_app_fields = [
917	'_metasync_twitter_app_id_iphone' => 'sanitize_text_field',
918	'_metasync_twitter_app_id_ipad' => 'sanitize_text_field',
919	'_metasync_twitter_app_id_googleplay' => 'sanitize_text_field',
920	'_metasync_twitter_app_url_iphone' => 'esc_url_raw',
921	'_metasync_twitter_app_url_ipad' => 'esc_url_raw',
922	'_metasync_twitter_app_url_googleplay' => 'esc_url_raw',
923	'_metasync_twitter_app_country' => 'sanitize_text_field',
924	];
925
926	# Save Twitter Player Card data
927	$twitter_player_fields = [
928	'_metasync_twitter_player' => 'esc_url_raw',
929	'_metasync_twitter_player_width' => 'absint',
930	'_metasync_twitter_player_height' => 'absint',
931	];
932
933	$all_fields = array_merge($og_fields, $twitter_fields, $twitter_app_fields, $twitter_player_fields);
934
935	foreach ($all_fields as $field => $sanitize_callback) {
936	if (isset($_POST[$field])) {
937	$value = call_user_func($sanitize_callback, $_POST[$field]);
938
939	# The meta box pre-fills empty social title/description fields from the
940	# post title, and on a brand-new post that title is the "Auto Draft"
941	# placeholder. Persisting it ships "Auto Draft" as the post's social
942	# title and description forever, so store empty instead and let the
943	# render-time fallback chain resolve the real title once one is set.
944	if (in_array($field, self::AUTO_DRAFT_PRONE_KEYS, true)
945	&& $this->is_auto_draft_prefill_echo($post_id, $value)
946	) {
947	$value = '';
948	}
949
950	# A social title identical to the post's title is the default, not a
951	# customization — whether the editor left an older pre-filled form
952	# untouched or typed the title back verbatim. Store empty so the
953	# render-time fallback to the live title applies, which is what keeps
954	# a rename from leaving a stale snapshot behind. Text that differs
955	# from the title passes through untouched. save_post fires after the
956	# post row is written, so the comparison is against the new title.
957	if (in_array($field, self::TITLE_DEFAULTED_KEYS, true)) {
958	$value = self::strip_title_snapshot($post_id, $field, $value);
959	}
960
961	# A social description identical to its rendered default — the
962	# resolved excerpt the older pre-filled form carried, or the
963	# same text typed back verbatim — is the default, not a
964	# customization. Store empty so the render-time fallback to the
965	# live excerpt applies, which is what keeps an excerpt or
966	# content edit from leaving a stale snapshot behind. Text that
967	# differs from the default passes through untouched. save_post
968	# fires after the post row is written, so the comparison is
969	# against the new excerpt and content.
970	if (in_array($field, self::DESCRIPTION_DEFAULTED_KEYS, true)) {
971	$value = self::strip_description_snapshot($post_id, $field, $value);
972	}
973
974	# An empty value means "no value" for every field in this box,
975	# and must not be stored as one: update_post_meta(..., '') keeps
976	# a row with an empty meta_value in the table (visible only to
977	# metadata_exists, EXISTS queries and exports, which would then
978	# report a customization where the field is merely blank). The
979	# plain read answers '' for a missing row too, so deleting is
980	# behaviour-preserving for every reader. Same pattern the
981	# untitled-flag write below has always used.
982	if ($value === '') {
983	delete_post_meta($post_id, $field);
984	} else {
985	update_post_meta($post_id, $field, $value);
986	}
987	}
988	}
989	}
990
991	/**
992	* Whether a submitted social field value is the meta box echoing back a
993	* placeholder pre-fill rather than something the editor typed.
994	*
995	* Two cases, both narrow on purpose so genuinely typed text is never discarded:
996	* - the value is the "Auto Draft" placeholder itself; or
997	* - the post is still an auto-draft and the value is just its title echoed
998	* back, which is what the pre-fill submits when the editor never touched
999	* the field.
1000	*
1001	* @param int $post_id
1002	* @param mixed $value Sanitized submitted value.
1003	* @return bool
1004	*/
1005	/**
1006	* save_post tracker maintaining the untitled state this class suppresses by.
1007	*
1008	* Two jobs, both anchored at save time — the only place the "Auto Draft"
1009	* translation reliably resolves — so the render path never has to guess:
1010	*
1011	* 1. Capture: when core creates an auto-draft, its title is
1012	* __( 'Auto Draft' ) in the creating request's locale (admin requests
1013	* carry the creating user's locale). Verified against that same __()
1014	* call here, then remembered verbatim, so every locale variant this
1015	* install ever uses is known to all contexts.
1016	* 2. Flag: mark posts saved while still placeholder-titled (recognized via
1017	* literal + translation + the registry above, so REST/CLI saves — where
1018	* the translation stays English — still recognize a registry hit), and
1019	* clear the mark as soon as a real title arrives.
1020	*
1021	* @param int $post_id
1022	* @param WP_Post\|mixed $post
1023	* @return void
1024	*/
1025	public function track_untitled_post($post_id, $post) {
1026	if (wp_is_post_revision($post_id) \|\| wp_is_post_autosave($post_id)) {
1027	return;
1028	}
1029	if (!$post instanceof WP_Post) {
1030	$post = get_post($post_id);
1031	}
1032	if (!$post instanceof WP_Post \|\| $post->post_type === 'revision' \|\| $post->post_status === 'trash') {
1033	return;
1034	}
1035	if (!in_array($post->post_type, $this->get_supported_post_types(), true)) {
1036	return;
1037	}
1038
1039	$title = trim((string) $post->post_title);
1040
1041	# Capture: an auto-draft's title is core's placeholder in whatever
1042	# locale resolved for the saving request — admin requests carry the
1043	# creating user's locale; on untranslated requests (front end, REST,
1044	# CLI) the equality below degenerates to the English literal, which
1045	# remember_auto_draft_placeholder() already skips. Verified against
1046	# __( 'Auto Draft' ), never trusted as a bare string, so a builder's
1047	# custom-seeded auto-draft title is never captured.
1048	if ($post->post_status === 'auto-draft'
1049	&& $title !== '' && $title === trim(__('Auto Draft', 'default'))) { // phpcs:ignore WordPress.WP.I18n.TextDomainMismatch -- resolves core's own 'Auto Draft' placeholder, which only exists in core's 'default' domain; the plugin text domain cannot reproduce it
1050	self::remember_auto_draft_placeholder($title);
1051	}
1052
1053	# Flag maintenance: recognition is context-independent thanks to the
1054	# registry (an untranslated REST/CLI save still matches a captured
1055	# variant), so the flag can never go stale in either direction.
1056	if (self::is_auto_draft_title($title)) {
1057	update_post_meta($post_id, self::UNTITLED_FLAG_META, $title);
1058	} else {
1059	delete_post_meta($post_id, self::UNTITLED_FLAG_META);
1060	}
1061	}
1062
1063	private function is_auto_draft_prefill_echo($post_id, $value) {
1064	if (self::is_auto_draft_title($value)) {
1065	return true;
1066	}
1067	if (!is_string($value) \|\| trim($value) === '') {
1068	return false;
1069	}
1070	$post = get_post($post_id);
1071	if (!$post instanceof WP_Post \|\| trim($value) !== trim((string) $post->post_title)) {
1072	return false;
1073	}
1074	if (get_post_status($post_id) === 'auto-draft') {
1075	return true;
1076	}
1077	# State arm: the submitted value echoes a title that was flagged as the
1078	# placeholder at save time. Covers a value the string checks above
1079	# missed — e.g. a localized placeholder stored under an admin user
1080	# whose locale differs from the one that created the post.
1081	$flagged = get_post_meta($post_id, self::UNTITLED_FLAG_META, true);
1082	return is_string($flagged) && trim($flagged) !== '' && trim($flagged) === trim($value);
1083	}
1084
1085	/**
1086	* Enqueue admin scripts and styles
1087	*/
1088	public function enqueue_admin_scripts($hook) {
1089	global $post_type;
1090
1091	# Only load on post edit screens for supported post types
1092	if (!in_array($hook, ['post.php', 'post-new.php']) \|\|
1093	!in_array($post_type, $this->get_supported_post_types())) {
1094	return;
1095	}
1096
1097	wp_enqueue_media();
1098
1099	wp_enqueue_script(
1100	'metasync-opengraph-admin',
1101	plugin_dir_url(__FILE__) . '../admin/js/metasync-opengraph.js',
1102	['jquery', 'wp-util'],
1103	$this->version,
1104	true
1105	);
1106
1107	wp_enqueue_style(
1108	'metasync-opengraph-admin',
1109	plugin_dir_url(__FILE__) . '../admin/css/metasync-opengraph.css',
1110	[],
1111	$this->version
1112	);
1113
1114	# Get the current post permalink for preview
1115	global $post;
1116	$current_permalink = '';
1117	if ($post && $post->ID) {
1118	$current_permalink = $this->get_canonical_url($post);
1119	}
1120
1121	# Localize script for AJAX
1122	wp_localize_script('metasync-opengraph-admin', 'metasync_og', [
1123	'ajax_url' => admin_url('admin-ajax.php'),
1124	'nonce' => wp_create_nonce('metasync_og_preview_nonce'),
1125	'current_permalink' => $current_permalink,
1126	'strings' => [
1127	'select_image' => esc_html__('Select Image', 'metasync'),
1128	'use_image' => esc_html__('Use This Image', 'metasync'),
1129	'remove_image' => esc_html__('Remove Image', 'metasync'),
1130	]
1131	]);
1132	}
1133
1134	/**
1135	* Force enqueue scripts for post edit screens (backup method)
1136	*/
1137	public function force_enqueue_scripts() {
1138	global $post_type;
1139
1140	if (!in_array($post_type, $this->get_supported_post_types())) {
1141	return;
1142	}
1143
1144	# Check if already enqueued
1145	if (wp_script_is('metasync-opengraph-admin', 'enqueued')) {
1146	return;
1147	}
1148
1149	wp_enqueue_media();
1150	wp_enqueue_script(
1151	'metasync-opengraph-admin',
1152	plugin_dir_url(__FILE__) . '../admin/js/metasync-opengraph.js',
1153	['jquery', 'wp-util'],
1154	$this->version,
1155	true
1156	);
1157
1158	wp_enqueue_style(
1159	'metasync-opengraph-admin',
1160	plugin_dir_url(__FILE__) . '../admin/css/metasync-opengraph.css',
1161	[],
1162	$this->version
1163	);
1164
1165	# Get the current post permalink for preview
1166	global $post;
1167	$current_permalink = '';
1168	if ($post && $post->ID) {
1169	$current_permalink = $this->get_canonical_url($post);
1170	}
1171
1172	wp_localize_script('metasync-opengraph-admin', 'metasync_og', [
1173	'ajax_url' => admin_url('admin-ajax.php'),
1174	'nonce' => wp_create_nonce('metasync_og_preview_nonce'),
1175	'current_permalink' => $current_permalink,
1176	'strings' => [
1177	'select_image' => esc_html__('Select Image', 'metasync'),
1178	'use_image' => esc_html__('Use This Image', 'metasync'),
1179	'remove_image' => esc_html__('Remove Image', 'metasync'),
1180	]
1181	]);
1182	}
1183
1184	/**
1185	* Output Open Graph and Twitter Card tags in wp_head
1186	*/
1187	public function output_opengraph_tags() {
1188	# Social Media & Open Graph switched off — emit nothing.
1189	if (Metasync_Feature_Flags::is_disabled(Metasync_Feature_Flags::SOCIAL_OG)) {
1190	return;
1191	}
1192
1193	if (!is_singular($this->get_supported_post_types())) {
1194	return;
1195	}
1196
1197	global $post;
1198
1199	# Ensure post is a valid object
1200	if (!$post instanceof WP_Post) {
1201	return;
1202	}
1203
1204	# Check if Open Graph is enabled for this post.
1205	# Only an explicit '0' opt-out suppresses output; unset/empty counts as enabled
1206	# so a MetaSync-only site gets one consolidated set whether or not the meta
1207	# box was ever saved. Must stay in sync with will_emit().
1208	if (self::is_social_output_disabled($post->ID)) {
1209	return;
1210	}
1211
1212	# When OTTO owns this page's OG (enabled + persisted OG data), skip legacy
1213	# OG output. For cases where OTTO's pixel injects OG tags dynamically
1214	# (without persisting to _metasync_otto_og_* meta), the buffer-level dedup
1215	# in Otto_html_class::deduplicate_og_twitter_tags() handles cleanup.
1216	if ($this->otto_owns_og($post->ID)) {
1217	return;
1218	}
1219
1220	# Check for conflicts with other SEO plugins (allow override via filter)
1221	if (apply_filters('metasync_opengraph_check_conflicts', true) && $this->has_seo_plugin_conflicts()) {
1222	return;
1223	}
1224
1225	# Open Graph data. The tier order — what the customer set, then OTTO, then
1226	# a value brought in from another SEO plugin — comes from
1227	# Metasync_Seo_Precedence so this emitter and the conflict handler cannot
1228	# disagree about which value the page should carry. The resolver collapses a
1229	# stored "Auto Draft" placeholder, a snapshot of the post title, and a
1230	# snapshot of the resolved description to '' as it walks the chain, so a
1231	# row polluted by the meta box pre-fill falls through to the live
1232	# fallback (or OTTO's tier) rather than outranking it. The literal
1233	# fallbacks below the chain (post title, excerpt, featured image) stay
1234	# here: they are derived at render time, not stored.
1235	$og_title = Metasync_Seo_Precedence::value($post->ID, Metasync_Seo_Precedence::FIELD_OG_TITLE)
1236	?: self::social_post_title($post);
1237	$og_description = Metasync_Seo_Precedence::value($post->ID, Metasync_Seo_Precedence::FIELD_OG_DESCRIPTION)
1238	?: $this->get_post_excerpt($post);
1239	$og_image = Metasync_Seo_Precedence::value($post->ID, Metasync_Seo_Precedence::FIELD_OG_IMAGE)
1240	?: $this->get_featured_image_url($post->ID);
1241	$canonical_override = '';
1242	if (class_exists('Metasync_Headless_Config') && Metasync_Headless_Config::is_active()) {
1243	# The two manual keys of the canonical chain, in the same order the
1244	# canonical tag resolves them. OTTO's volatile staging tier is
1245	# deliberately left out: headless rehosts derived WordPress URLs,
1246	# and an OTTO suggestion is not the author's answer about where
1247	# content lives — a staged cross-domain canonical must not flow
1248	# into headless og:url. The two can therefore disagree with the
1249	# WordPress-render canonical tag only when OTTO is staging a
1250	# canonical and no manual value exists; that is the documented
1251	# scope split. meta_canonical is not a legacy alias: the REST sync
1252	# and the classic-editor Canonical box both still write it, and
1253	# the GraphQL surface reads both keys as well.
1254	foreach (array('_metasync_canonical_url', 'meta_canonical') as $canonical_key) {
1255	$canonical_override = Metasync_Canonical_Sanitizer::sanitize(
1256	get_post_meta($post->ID, $canonical_key, true)
1257	);
1258	if ($canonical_override !== '') {
1259	break;
1260	}
1261	}
1262	}
1263
1264	# A validated canonical override is the author's final answer. It may
1265	# deliberately name another host, so it bypasses headless rehosting.
1266	if ($canonical_override !== '') {
1267	$og_url = esc_url($canonical_override);
1268	} else {
1269	$og_url = get_post_meta($post->ID, '_metasync_og_url', true) ?: $this->get_canonical_url($post);
1270
1271	# On a headless site the rendered page is not the public page, so
1272	# an own-host og:url must name the frontend. Applied at the single
1273	# emission source so update_opengraph_url() continues to persist
1274	# the WordPress URL used outside headless mode.
1275	$og_url = $this->maybe_build_headless_url($og_url, $post->post_type);
1276	}
1277	$og_type = get_post_meta($post->ID, '_metasync_og_type', true) ?: 'article';
1278
1279	# Get Twitter Card data — check persisted key first, fall back to OTTO staging key
1280	$twitter_card = get_post_meta($post->ID, '_metasync_twitter_card', true) ?: 'summary_large_image';
1281	$twitter_site = get_post_meta($post->ID, '_metasync_twitter_site', true);
1282
1283	# Fall back to the site-wide Twitter username (Social Meta settings) so the
1284	# twitter:site / twitter:creator tags the legacy emitter produced are not lost
1285	# now that this emitter is the single canonical OG/Twitter source
1286	$twitter_username = Metasync::get_option('social_meta')['twitter_username'] ?? '';
1287	if (empty($twitter_site) && !empty($twitter_username)) {
1288	$twitter_site = '@' . $twitter_username;
1289	}
1290	$twitter_creator = !empty($twitter_username) ? '@' . $twitter_username : '';
1291	$twitter_title = Metasync_Seo_Precedence::value($post->ID, Metasync_Seo_Precedence::FIELD_TWITTER_TITLE)
1292	?: $og_title;
1293	$twitter_description = Metasync_Seo_Precedence::value($post->ID, Metasync_Seo_Precedence::FIELD_TWITTER_DESCRIPTION)
1294	?: $og_description;
1295	$twitter_image = Metasync_Seo_Precedence::value($post->ID, Metasync_Seo_Precedence::FIELD_TWITTER_IMAGE)
1296	?: $og_image;
1297	$twitter_image_alt = get_post_meta($post->ID, '_metasync_twitter_image_alt', true);
1298
1299	# Resolve OG image attachment ID once for reuse (twitter:image:alt fallback + og:image dimensions)
1300	$og_image_attachment_id = 0;
1301	if (!empty($og_image)) {
1302	$og_image_attachment_id = attachment_url_to_postid($og_image);
1303	}
1304
1305	# Fall back to the OG image's WP attachment alt text when no explicit twitter:image:alt is set
1306	if (empty($twitter_image_alt) && $og_image_attachment_id > 0) {
1307	$attachment_alt = get_post_meta($og_image_attachment_id, '_wp_attachment_image_alt', true);
1308	if (!empty($attachment_alt)) {
1309	$twitter_image_alt = $attachment_alt;
1310	}
1311	}
1312
1313	# Per-field toggles from common_meta_settings (default enabled when unset)
1314	$common_meta_settings = Metasync::get_option('common_meta_settings');
1315	if (!is_array($common_meta_settings)) {
1316	$common_meta_settings = [];
1317	}
1318	$og_image_dimensions_enabled = ($common_meta_settings['og_image_dimensions'] ?? 'true') !== 'false';
1319	$twitter_image_alt_enabled = ($common_meta_settings['twitter_image_alt'] ?? 'true') !== 'false';
1320
1321	# Get Twitter App Card data
1322	$twitter_app_id_iphone = get_post_meta($post->ID, '_metasync_twitter_app_id_iphone', true);
1323	$twitter_app_id_ipad = get_post_meta($post->ID, '_metasync_twitter_app_id_ipad', true);
1324	$twitter_app_id_googleplay = get_post_meta($post->ID, '_metasync_twitter_app_id_googleplay', true);
1325	$twitter_app_url_iphone = get_post_meta($post->ID, '_metasync_twitter_app_url_iphone', true);
1326	$twitter_app_url_ipad = get_post_meta($post->ID, '_metasync_twitter_app_url_ipad', true);
1327	$twitter_app_url_googleplay = get_post_meta($post->ID, '_metasync_twitter_app_url_googleplay', true);
1328	$twitter_app_country = get_post_meta($post->ID, '_metasync_twitter_app_country', true);
1329
1330	# Get Twitter Player Card data
1331	$twitter_player = get_post_meta($post->ID, '_metasync_twitter_player', true);
1332	$twitter_player_width = get_post_meta($post->ID, '_metasync_twitter_player_width', true);
1333	$twitter_player_height = get_post_meta($post->ID, '_metasync_twitter_player_height', true);
1334
1335	# Output Open Graph tags
1336	echo "\n<!-- MetaSync Open Graph Tags -->\n";
1337	echo '<meta property="og:locale" content="' . esc_attr(get_locale()) . '">' . "\n";
1338	if ($og_title) {
1339	echo '<meta property="og:title" content="' . esc_attr($og_title) . '">' . "\n";
1340	}
1341	if ($og_description) {
1342	echo '<meta property="og:description" content="' . esc_attr($og_description) . '">' . "\n";
1343	}
1344	if ($og_image) {
1345	echo '<meta property="og:image" content="' . esc_url($og_image) . '">' . "\n";
1346
1347	if ($og_image_dimensions_enabled) {
1348	$og_image_dims = $this->get_og_image_dimensions($og_image, $og_image_attachment_id);
1349	if (is_array($og_image_dims)) {
1350	if (!empty($og_image_dims['width'])) {
1351	echo '<meta property="og:image:width" content="' . esc_attr((string) $og_image_dims['width']) . '">' . "\n";
1352	}
1353	if (!empty($og_image_dims['height'])) {
1354	echo '<meta property="og:image:height" content="' . esc_attr((string) $og_image_dims['height']) . '">' . "\n";
1355	}
1356	if (!empty($og_image_dims['mime'])) {
1357	echo '<meta property="og:image:type" content="' . esc_attr($og_image_dims['mime']) . '">' . "\n";
1358	}
1359	}
1360	}
1361	}
1362	if ($og_url) {
1363	echo '<meta property="og:url" content="' . esc_url($og_url) . '">' . "\n";
1364	}
1365	if ($og_type) {
1366	echo '<meta property="og:type" content="' . esc_attr($og_type) . '">' . "\n";
1367	}
1368	$site_name = get_bloginfo('name');
1369	if ($site_name) {
1370	echo '<meta property="og:site_name" content="' . esc_attr($site_name) . '">' . "\n";
1371	}
1372	if (!empty($post->post_modified)) {
1373	echo '<meta property="og:updated_time" content="' . esc_attr($post->post_modified) . '">' . "\n";
1374	}
1375
1376	# Output Twitter Card tags
1377	echo "<!-- MetaSync Twitter Card Tags -->\n";
1378	if ($twitter_card) {
1379	echo '<meta name="twitter:card" content="' . esc_attr($twitter_card) . '">' . "\n";
1380	}
1381	if ($twitter_site) {
1382	echo '<meta name="twitter:site" content="' . esc_attr($twitter_site) . '">' . "\n";
1383	}
1384	if ($twitter_creator) {
1385	echo '<meta name="twitter:creator" content="' . esc_attr($twitter_creator) . '">' . "\n";
1386	}
1387	if ($twitter_title) {
1388	echo '<meta name="twitter:title" content="' . esc_attr($twitter_title) . '">' . "\n";
1389	}
1390	if ($twitter_description) {
1391	echo '<meta name="twitter:description" content="' . esc_attr($twitter_description) . '">' . "\n";
1392	}
1393	if ($twitter_image) {
1394	echo '<meta name="twitter:image" content="' . esc_url($twitter_image) . '">' . "\n";
1395	}
1396	if ($twitter_image_alt && $twitter_image_alt_enabled) {
1397	echo '<meta name="twitter:image:alt" content="' . esc_attr($twitter_image_alt) . '">' . "\n";
1398	}
1399
1400	# Output Twitter App Card tags (only if card type is 'app')
1401	if ($twitter_card === 'app') {
1402	if ($twitter_app_id_iphone) {
1403	echo '<meta name="twitter:app:id:iphone" content="' . esc_attr($twitter_app_id_iphone) . '">' . "\n";
1404	}
1405	if ($twitter_app_id_ipad) {
1406	echo '<meta name="twitter:app:id:ipad" content="' . esc_attr($twitter_app_id_ipad) . '">' . "\n";
1407	}
1408	if ($twitter_app_id_googleplay) {
1409	echo '<meta name="twitter:app:id:googleplay" content="' . esc_attr($twitter_app_id_googleplay) . '">' . "\n";
1410	}
1411	if ($twitter_app_url_iphone) {
1412	echo '<meta name="twitter:app:url:iphone" content="' . esc_url($twitter_app_url_iphone) . '">' . "\n";
1413	}
1414	if ($twitter_app_url_ipad) {
1415	echo '<meta name="twitter:app:url:ipad" content="' . esc_url($twitter_app_url_ipad) . '">' . "\n";
1416	}
1417	if ($twitter_app_url_googleplay) {
1418	echo '<meta name="twitter:app:url:googleplay" content="' . esc_url($twitter_app_url_googleplay) . '">' . "\n";
1419	}
1420	if ($twitter_app_country) {
1421	echo '<meta name="twitter:app:country" content="' . esc_attr($twitter_app_country) . '">' . "\n";
1422	}
1423	}
1424
1425	# Output Twitter Player Card tags (only if card type is 'player')
1426	if ($twitter_card === 'player') {
1427	if ($twitter_player) {
1428	echo '<meta name="twitter:player" content="' . esc_url($twitter_player) . '">' . "\n";
1429	}
1430	if ($twitter_player_width) {
1431	echo '<meta name="twitter:player:width" content="' . esc_attr($twitter_player_width) . '">' . "\n";
1432	}
1433	if ($twitter_player_height) {
1434	echo '<meta name="twitter:player:height" content="' . esc_attr($twitter_player_height) . '">' . "\n";
1435	}
1436	}
1437
1438	echo "<!-- End MetaSync Social Media Tags -->\n\n";
1439	}
1440
1441	/**
1442	* Resolve OG image dimensions + MIME without making remote HTTP calls.
1443	*
1444	* Returns an array with 'width', 'height', and 'mime' when available,
1445	* or null when no dimensions are known. For WP-hosted attachments the
1446	* data comes from attachment metadata. For external URLs we only read
1447	* a pre-seeded transient (metasync_og_img_dims_{md5(url)}).
1448	*
1449	* @param string $url
1450	* @param int $attachment_id Pre-resolved attachment ID (0 = auto-detect).
1451	* @return array\|null
1452	*/
1453	private function get_og_image_dimensions($url, $attachment_id = 0) {
1454	if (empty($url) \|\| !is_string($url)) {
1455	return null;
1456	}
1457
1458	if ($attachment_id <= 0) {
1459	$attachment_id = attachment_url_to_postid($url);
1460	}
1461	if ($attachment_id > 0) {
1462	$meta = wp_get_attachment_metadata($attachment_id);
1463	$width = isset($meta['width']) ? (int) $meta['width'] : 0;
1464	$height = isset($meta['height']) ? (int) $meta['height'] : 0;
1465	$mime = get_post_mime_type($attachment_id) ?: '';
1466	if ($width > 0 \|\| $height > 0 \|\| $mime !== '') {
1467	return [
1468	'width' => $width,
1469	'height' => $height,
1470	'mime' => $mime,
1471	];
1472	}
1473	return null;
1474	}
1475
1476	# External URLs: only read the pre-seeded transient, never make remote HTTP calls here.
1477	$cached = get_transient('metasync_og_img_dims_' . md5($url));
1478	if (is_array($cached)) {
1479	return [
1480	'width' => isset($cached['width']) ? (int) $cached['width'] : 0,
1481	'height' => isset($cached['height']) ? (int) $cached['height'] : 0,
1482	'mime' => isset($cached['mime']) ? (string) $cached['mime'] : '',
1483	];
1484	}
1485
1486	return null;
1487	}
1488
1489	/**
1490	* Output article:* Open Graph tags for article-type singular views.
1491	*
1492	* Runs independently of has_seo_plugin_conflicts() so we can still emit
1493	* complete article metadata while other SEO plugins handle og:title/description.
1494	* Cross-plugin dedup is handled via register_dedup_filters() instead.
1495	*/
1496	public function output_article_tags() {
1497	# article:* tags are part of the same Open Graph block, so they follow
1498	# the same switch as output_opengraph_tags().
1499	if (Metasync_Feature_Flags::is_disabled(Metasync_Feature_Flags::SOCIAL_OG)) {
1500	return;
1501	}
1502
1503	if (!is_singular()) {
1504	return;
1505	}
1506
1507	global $post;
1508	if (!$post instanceof WP_Post) {
1509	return;
1510	}
1511
1512	if (self::is_social_output_disabled($post->ID)) {
1513	return;
1514	}
1515
1516	$og_type = get_post_meta($post->ID, '_metasync_og_type', true) ?: 'article';
1517	if ($og_type !== 'article') {
1518	return;
1519	}
1520
1521	$article_post_types = apply_filters('metasync_og_article_post_types', ['post']);
1522	if (!is_array($article_post_types) \|\| !in_array($post->post_type, $article_post_types, true)) {
1523	return;
1524	}
1525
1526	$settings = Metasync::get_option('common_meta_settings');
1527	if (!is_array($settings)) {
1528	$settings = [];
1529	}
1530
1531	$article_timestamps_enabled = ($settings['article_timestamps'] ?? 'true') !== 'false';
1532	$article_author_enabled = ($settings['article_author'] ?? 'true') !== 'false';
1533	$article_section_enabled = ($settings['article_section'] ?? 'true') !== 'false';
1534	$article_tags_enabled = ($settings['article_tags'] ?? 'true') !== 'false';
1535
1536	echo "<!-- MetaSync Article Tags -->\n";
1537
1538	# article:published_time / article:modified_time
1539	if ($article_timestamps_enabled) {
1540	if (!empty($post->post_date_gmt) && $post->post_date_gmt !== '0000-00-00 00:00:00') {
1541	$published_ts = strtotime($post->post_date_gmt);
1542	if ($published_ts) {
1543	echo '<meta property="article:published_time" content="' . esc_attr(gmdate('c', $published_ts)) . '">' . "\n";
1544	}
1545	}
1546	if (!empty($post->post_modified_gmt) && $post->post_modified_gmt !== '0000-00-00 00:00:00') {
1547	$modified_ts = strtotime($post->post_modified_gmt);
1548	if ($modified_ts) {
1549	echo '<meta property="article:modified_time" content="' . esc_attr(gmdate('c', $modified_ts)) . '">' . "\n";
1550	}
1551	}
1552	}
1553
1554	# article:author
1555	if ($article_author_enabled) {
1556	$author_url = get_post_meta($post->ID, '_metasync_og_article_author', true);
1557	if (empty($author_url)) {
1558	$author_url = get_the_author_meta('url', $post->post_author);
1559	}
1560	if (empty($author_url)) {
1561	$author_url = get_author_posts_url($post->post_author);
1562	}
1563	if (!empty($author_url)) {
1564	echo '<meta property="article:author" content="' . esc_url($author_url) . '">' . "\n";
1565	}
1566	}
1567
1568	# article:section – prefer explicit primary category, fall back to first category
1569	if ($article_section_enabled) {
1570	$section_name = '';
1571	$primary_category_id = (int) get_post_meta($post->ID, '_metasync_primary_category', true);
1572	if ($primary_category_id > 0) {
1573	$category = get_category($primary_category_id);
1574	if ($category && !is_wp_error($category) && !empty($category->name)) {
1575	$section_name = $category->name;
1576	}
1577	}
1578	if (empty($section_name)) {
1579	$categories = get_the_category($post->ID);
1580	if (!empty($categories) && isset($categories[0]->name)) {
1581	$section_name = $categories[0]->name;
1582	}
1583	}
1584	if (!empty($section_name)) {
1585	echo '<meta property="article:section" content="' . esc_attr($section_name) . '">' . "\n";
1586	}
1587	}
1588
1589	# article:tag – one tag per WP post tag
1590	if ($article_tags_enabled) {
1591	$post_tags = get_the_tags($post->ID);
1592	if (!empty($post_tags) && !is_wp_error($post_tags)) {
1593	foreach ($post_tags as $tag) {
1594	if (!empty($tag->name)) {
1595	echo '<meta property="article:tag" content="' . esc_attr($tag->name) . '">' . "\n";
1596	}
1597	}
1598	}
1599	}
1600
1601	echo "<!-- End MetaSync Article Tags -->\n";
1602	}
1603
1604	/**
1605	* Register cross-plugin dedup filters so Yoast / Rank Math don't double-emit
1606	* article:* tags alongside our own output.
1607	*/
1608	private function register_dedup_filters() {
1609	# Ensure is_plugin_active() is available on the frontend too.
1610	if (!function_exists('is_plugin_active')) {
1611	require_once ABSPATH . 'wp-admin/includes/plugin.php';
1612	}
1613
1614	$settings = Metasync::get_option('common_meta_settings');
1615	if (!is_array($settings)) {
1616	$settings = [];
1617	}
1618
1619	$yoast_active = is_plugin_active('wordpress-seo/wp-seo.php')
1620	\|\| is_plugin_active('wordpress-seo-premium/wp-seo-premium.php');
1621	$rank_math_active = is_plugin_active('seo-by-rank-math/rank-math.php');
1622
1623	# The article:* tags these filters suppress are emitted by
1624	# output_article_tags(), which stands down when the Social Media & Open
1625	# Graph feature is switched off. Treat every article feature as disabled
1626	# in that case so the third party keeps rendering its own tags — pulling
1627	# ours without releasing theirs would leave the page with none.
1628	$social_enabled = Metasync_Feature_Flags::is_enabled(Metasync_Feature_Flags::SOCIAL_OG);
1629
1630	$article_timestamps_enabled = $social_enabled && ($settings['article_timestamps'] ?? 'true') !== 'false';
1631	$article_author_enabled = $social_enabled && ($settings['article_author'] ?? 'true') !== 'false';
1632	$article_section_enabled = $social_enabled && ($settings['article_section'] ?? 'true') !== 'false';
1633	$article_tags_enabled = $social_enabled && ($settings['article_tags'] ?? 'true') !== 'false';
1634
1635	# Yoast: remove individual presenters based on which MetaSync features are enabled
1636	if ($yoast_active && ($article_timestamps_enabled \|\| $article_author_enabled)) {
1637	add_filter('wpseo_frontend_presenters', function( $presenters ) use ( $article_timestamps_enabled, $article_author_enabled ) {
1638	$post_id = function_exists('get_queried_object_id') ? (int) get_queried_object_id() : 0;
1639	if (self::is_social_output_disabled($post_id)) {
1640	return $presenters;
1641	}
1642	foreach ( $presenters as $key => $presenter ) {
1643	if ( $article_timestamps_enabled && (
1644	$presenter instanceof \Yoast\WP\SEO\Presenters\Open_Graph\Article_Published_Time_Presenter \|\|
1645	$presenter instanceof \Yoast\WP\SEO\Presenters\Open_Graph\Article_Modified_Time_Presenter
1646	)) {
1647	unset( $presenters[ $key ] );
1648	}
1649	if ( $article_author_enabled &&
1650	$presenter instanceof \Yoast\WP\SEO\Presenters\Open_Graph\Article_Author_Presenter ) {
1651	unset( $presenters[ $key ] );
1652	}
1653	}
1654	return array_values( $presenters );
1655	}, 999 );
1656	}
1657
1658	# Rank Math: suppress individual article:* tags via content filters.
1659	# Rank Math's tag() method passes content through rank_math/opengraph/facebook/{property}
1660	# where {property} is the OG property with colons replaced by underscores.
1661	# Returning false causes tag() to skip output (empty($content) check).
1662	if ($rank_math_active) {
1663	$keep_third_party = function ($value) {
1664	$post_id = function_exists('get_queried_object_id') ? (int) get_queried_object_id() : 0;
1665	return self::is_social_output_disabled($post_id) ? $value : false;
1666	};
1667	if ($article_timestamps_enabled) {
1668	add_filter('rank_math/opengraph/facebook/article_published_time', $keep_third_party, 999);
1669	add_filter('rank_math/opengraph/facebook/article_modified_time', $keep_third_party, 999);
1670	}
1671	if ($article_tags_enabled) {
1672	add_filter('rank_math/opengraph/facebook/article_tag', $keep_third_party, 999);
1673	}
1674	if ($article_author_enabled) {
1675	add_filter('rank_math/opengraph/facebook/article_author', $keep_third_party, 999);
1676	}
1677	if ($article_section_enabled) {
1678	add_filter('rank_math/opengraph/facebook/article_section', $keep_third_party, 999);
1679	}
1680	}
1681	}
1682
1683	/**
1684	* Hook the untitled-placeholder suppression into the title pipelines of
1685	* the SEO plugins that can own the <title>/og:title/twitter:title output
1686	* when MetaSync's own emitter stands down due to a conflict.
1687	*
1688	* Rank Math funnels <title>, og:title and twitter:title through one filter
1689	* (rank_math/frontend/title wraps Paper::get_title()), so one hook covers
1690	* all three. Yoast builds them from separate presenters, so it needs the
1691	* title filter plus the og/twitter title filters.
1692	*
1693	* The hooks are registered unconditionally: each only fires while its
1694	* plugin is actually generating a title, and the callback no-ops unless
1695	* the current post carries the untitled flag.
1696	*
1697	* @return void
1698	*/
1699	private function register_untitled_title_filters() {
1700	add_filter('rank_math/frontend/title', [$this, 'strip_untitled_from_seo_title'], 99);
1701	add_filter('wpseo_title', [$this, 'strip_untitled_from_seo_title'], 99);
1702	add_filter('wpseo_opengraph_title', [$this, 'strip_untitled_from_seo_title'], 99);
1703	add_filter('wpseo_twitter_title', [$this, 'strip_untitled_from_seo_title'], 99);
1704	}
1705
1706	/**
1707	* Remove the flagged placeholder from an SEO plugin's assembled title.
1708	*
1709	* The incoming value is the finished template output ("placeholder -
1710	* Site name"), so the placeholder segment is cut out and any dangling
1711	* separator tidied. An empty result (title was the placeholder alone)
1712	* cannot be returned as-is: both plugins treat an empty value as "do
1713	* nothing" and re-use their own generated title, so the site name is the
1714	* replacement of last resort.
1715	*
1716	* @param mixed $title Assembled title from the SEO plugin.
1717	* @return string
1718	*/
1719	public function strip_untitled_from_seo_title($title) {
1720	if (!is_string($title) \|\| trim($title) === '') {
1721	return $title;
1722	}
1723	$post = get_post();
1724	if (!$post instanceof WP_Post) {
1725	return $title;
1726	}
1727	$flagged = get_post_meta($post->ID, self::UNTITLED_FLAG_META, true);
1728	if (!is_string($flagged) \|\| trim($flagged) === '') {
1729	return $title;
1730	}
1731	# Same state check as social_post_title(): only while the live title
1732	# still is the flagged placeholder.
1733	if (trim((string) $post->post_title) !== trim($flagged)) {
1734	return $title;
1735	}
1736	if (strpos($title, $flagged) === false) {
1737	return $title;
1738	}
1739	$remainder = trim(str_replace($flagged, '', $title));
1740	# Tidy the separator(s) that flanked the removed segment.
1741	$remainder = trim((string) preg_replace('/^[\s\-–—\|·»•]+\|[\s\-–—\|·»•]+$/u', '', $remainder));
1742	if ($remainder === '') {
1743	$remainder = trim((string) get_bloginfo('name'));
1744	}
1745	if ($remainder === '') {
1746	# A space, not '': an empty return is a no-op for these filters.
1747	$remainder = ' ';
1748	}
1749	return $remainder;
1750	}
1751
1752	/**
1753	* AJAX handler for generating social media preview
1754	*/
1755	public function ajax_generate_preview() {
1756
1757	try {
1758	# Check nonce
1759	if (!check_ajax_referer('metasync_og_preview_nonce', 'nonce', false)) {
1760	wp_send_json_error(['message' => 'Security check failed']);
1761	return;
1762	}
1763
1764	# Get and sanitize data
1765	$title = sanitize_text_field($_POST['title'] ?? '');
1766	$description = sanitize_textarea_field($_POST['description'] ?? '');
1767	$image = esc_url_raw($_POST['image'] ?? '');
1768	$url = esc_url_raw($_POST['url'] ?? '');
1769
1770	# Get Twitter Card data
1771	$twitter_title = sanitize_text_field($_POST['twitter_title'] ?? '');
1772	$twitter_description = sanitize_textarea_field($_POST['twitter_description'] ?? '');
1773	$twitter_image = esc_url_raw($_POST['twitter_image'] ?? '');
1774
1775	# Generate preview HTML
1776	$preview_html = $this->generate_preview_html($title, $description, $image, $url, $twitter_title, $twitter_description, $twitter_image);
1777
1778	if (empty($preview_html)) {
1779	wp_send_json_error(['message' => 'Failed to generate preview HTML']);
1780	}
1781
1782	wp_send_json_success(['preview' => $preview_html]);
1783
1784	} catch (Exception $e) {
1785	wp_send_json_error(['message' => 'Server error: ' . $e->getMessage()]);
1786	}
1787	}
1788
1789	/**
1790	* Generate HTML for social media preview
1791	*/
1792	private function generate_preview_html($title, $description, $image, $url, $twitter_title = '', $twitter_description = '', $twitter_image = '') {
1793	# Parse domain from URL
1794	$domain = '';
1795	if (!empty($url)) {
1796	$parsed = wp_parse_url($url);
1797	$domain = $parsed['host'] ?? '';
1798	}
1799
1800	# Fallback to site URL if no domain found
1801	if (empty($domain)) {
1802	$site_url = get_site_url();
1803	$parsed = wp_parse_url($site_url);
1804	$domain = $parsed['host'] ?? 'your-site.com';
1805	}
1806
1807	# Provide fallbacks for empty values
1808	if (empty($title)) {
1809	$title = 'Your Post Title';
1810	}
1811	if (empty($description)) {
1812	$description = 'Your post description will appear here when shared on social media platforms.';
1813	}
1814
1815	# Use Twitter Card data for Twitter preview, fallback to Open Graph
1816	$twitter_display_title = !empty($twitter_title) ? $twitter_title : $title;
1817	$twitter_display_description = !empty($twitter_description) ? $twitter_description : $description;
1818	$twitter_display_image = !empty($twitter_image) ? $twitter_image : $image;
1819
1820	# Get site name for avatars
1821	$site_name = get_bloginfo('name') ?: 'Your Site';
1822	$site_initial = strtoupper(substr($site_name, 0, 1));
1823
1824	ob_start();
1825	?>
1826	<div class="metasync-preview-tabs">
1827	<button class="metasync-preview-tab facebook active" data-platform="facebook">
1828	Facebook
1829	</button>
1830	<button class="metasync-preview-tab twitter" data-platform="twitter">
1831	Twitter/X
1832	</button>
1833	<button class="metasync-preview-tab linkedin" data-platform="linkedin">
1834	LinkedIn
1835	</button>
1836	</div>
1837
1838	<div class="metasync-preview-content">
1839	<!-- Facebook Preview -->
1840	<div class="metasync-preview-panel facebook active" data-platform="facebook">
1841	<div class="facebook-preview">
1842	<div class="facebook-post-header">
1843	<div class="facebook-avatar"><?php echo esc_html($site_initial); ?></div>
1844	<div class="facebook-post-info">
1845	<h4><?php echo esc_html($site_name); ?></h4>
1846	<p>2 hours ago • 🌍</p>
1847	</div>
1848	</div>
1849	<div class="facebook-link-preview">
1850	<?php if (!empty($image)): ?>
1851	<div class="facebook-preview-image">
1852	<img src="<?php echo esc_url($image); ?>" alt="<?php echo esc_attr($title); ?>" onerror="this.style.display='none'; this.nextElementSibling.style.display='block';">
1853	<div class="preview-placeholder" style="display: none;">
1854	<span>📷</span>
1855	<p>Image failed to load</p>
1856	</div>
1857	</div>
1858	<?php else: ?>
1859	<div class="facebook-preview-image preview-no-image">
1860	<div class="preview-placeholder">
1861	<span>📷</span>
1862	<p>No image selected</p>
1863	</div>
1864	</div>
1865	<?php endif; ?>
1866	<div class="facebook-preview-content">
1867	<div class="facebook-preview-domain"><?php echo esc_html(strtoupper($domain)); ?></div>
1868	<div class="facebook-preview-title"><?php echo esc_html($title); ?></div>
1869	<div class="facebook-preview-description"><?php echo esc_html($description); ?></div>
1870	</div>
1871	</div>
1872	</div>
1873	</div>
1874
1875	<!-- Twitter Preview -->
1876	<div class="metasync-preview-panel twitter" data-platform="twitter">
1877	<div class="twitter-preview">
1878	<div class="twitter-post-header">
1879	<div class="twitter-avatar"><?php echo esc_html($site_initial); ?></div>
1880	<div class="twitter-user-info">
1881	<h4><?php echo esc_html($site_name); ?></h4>
1882	<p>@<?php echo esc_html(strtolower(str_replace(' ', '', $site_name ?? ''))); ?> • 2h</p>
1883	</div>
1884	</div>
1885	<div class="twitter-post-text">
1886	Check out this amazing content! 🚀
1887	</div>
1888	<div class="twitter-card">
1889	<?php if (!empty($twitter_display_image)): ?>
1890	<div class="twitter-card-image">
1891	<img src="<?php echo esc_url($twitter_display_image); ?>" alt="<?php echo esc_attr($twitter_display_title); ?>" onerror="this.style.display='none'; this.nextElementSibling.style.display='block';">
1892	<div class="preview-placeholder" style="display: none;">
1893	<span>📷</span>
1894	<p>Image failed to load</p>
1895	</div>
1896	</div>
1897	<?php else: ?>
1898	<div class="twitter-card-image preview-no-image">
1899	<div class="preview-placeholder">
1900	<span>📷</span>
1901	<p>No image selected</p>
1902	</div>
1903	</div>
1904	<?php endif; ?>
1905	<div class="twitter-card-content">
1906	<div class="twitter-card-domain"><?php echo esc_html($domain); ?></div>
1907	<div class="twitter-card-title"><?php echo esc_html($twitter_display_title); ?></div>
1908	<div class="twitter-card-description"><?php echo esc_html($twitter_display_description); ?></div>
1909	</div>
1910	</div>
1911	</div>
1912	</div>
1913
1914	<!-- LinkedIn Preview -->
1915	<div class="metasync-preview-panel linkedin" data-platform="linkedin">
1916	<div class="linkedin-preview">
1917	<div class="linkedin-post-header">
1918	<div class="linkedin-avatar"><?php echo esc_html($site_initial); ?></div>
1919	<div class="linkedin-user-info">
1920	<h4><?php echo esc_html($site_name); ?></h4>
1921	<p>2 hours ago</p>
1922	</div>
1923	</div>
1924	<div class="linkedin-link-preview">
1925	<?php if (!empty($image)): ?>
1926	<div class="linkedin-preview-image">
1927	<img src="<?php echo esc_url($image); ?>" alt="<?php echo esc_attr($title); ?>" onerror="this.style.display='none'; this.nextElementSibling.style.display='block';">
1928	<div class="preview-placeholder" style="display: none;">
1929	<span>📷</span>
1930	<p>Image failed to load</p>
1931	</div>
1932	</div>
1933	<?php else: ?>
1934	<div class="linkedin-preview-image preview-no-image">
1935	<div class="preview-placeholder">
1936	<span>📷</span>
1937	<p>No image selected</p>
1938	</div>
1939	</div>
1940	<?php endif; ?>
1941	<div class="linkedin-preview-content">
1942	<div class="linkedin-preview-title"><?php echo esc_html($title); ?></div>
1943	<div class="linkedin-preview-description"><?php echo esc_html($description); ?></div>
1944	<div class="linkedin-preview-domain"><?php echo esc_html($domain); ?></div>
1945	</div>
1946	</div>
1947	</div>
1948	</div>
1949	</div>
1950	<?php
1951	return ob_get_clean();
1952	}
1953
1954	/**
1955	* Get post excerpt for Open Graph description
1956	*/
1957	private function get_post_excerpt($post) {
1958	if (!empty($post->post_excerpt)) {
1959	return $post->post_excerpt;
1960	}
1961
1962	# Generate excerpt from content
1963	$content = $post->post_content;
1964
1965	# Do NOT run do_shortcode()/apply_filters('the_content') here.
1966	# This method runs on wp_head (priority 5, before the body renders) to build
1967	# og:description. On page-builder pages (Elementor, etc.) the_content fully
1968	# renders the page — including widgets like Elementor Loop Grid — which makes
1969	# the builder mark those widgets' per-request inline CSS as "already printed".
1970	# When the real widget renders later in the body, the builder's dedup then
1971	# OMITS its inline <style> (e.g. <style id="loop-NNNN"> carrying the loop
1972	# card's flex/width vars), collapsing the layout (stacked cards, full-width
1973	# images). We only need plain text for a meta description, so strip instead of
1974	# render — matching how Metasync_Seo_Output builds its description safely.
1975	$content = strip_shortcodes($content);
1976
1977	# Page builders (Divi, Elementor, WPBakery) store content as shortcodes.
1978	# do_shortcode() only renders shortcodes whose handlers are registered, and when
1979	# this runs server-side (REST/cron/CLI) or before the builder loads the [et_pb_*]
1980	# tags are never expanded. strip_shortcodes() only removes registered shortcodes
1981	# too, so any leftover shortcode-style tags are removed by pattern below — otherwise
1982	# raw builder markup leaks into the og:description.
1983	$content = $this->strip_shortcode_markup($content);
1984
1985	# Remove HTML tags to get clean text
1986	$content = wp_strip_all_tags($content);
1987
1988	# Remove extra whitespace, line breaks, and special characters
1989	$content = preg_replace('/\s+/', ' ', $content);
1990	$content = trim($content);
1991
1992	# If content is still empty or too short, fallback to post title. A brand-new
1993	# post has no content and its title is the "Auto Draft" placeholder, which
1994	# must not become the og:/twitter:description — strip it so the caller's
1995	# fallback chain resolves to something real instead.
1996	if (empty($content) \|\| strlen($content) < 20) {
1997	$content = self::social_post_title($post);
1998	}
1999
2000	if ($content === '') {
2001	return '';
2002	}
2003
2004	# Generate excerpt
2005	$excerpt = wp_trim_words($content, 30, '...');
2006
2007	return $excerpt;
2008	}
2009
2010	/**
2011	* Strip shortcode markup from a string.
2012	*
2013	* Removes registered shortcodes via strip_shortcodes(), then strips any
2014	* leftover shortcode-style tags (e.g. unregistered page-builder tags such
2015	* as [et_pb_section ...] / [/et_pb_section]) by pattern. The pattern is
2016	* anchored to a leading letter so legitimate bracketed prose like
2017	* "[2026 Guide]" is preserved.
2018	*
2019	* @param string $content
2020	* @return string
2021	*/
2022	private function strip_shortcode_markup($content) {
2023	if (empty($content) \|\| !is_string($content)) {
2024	return (string) $content;
2025	}
2026
2027	$content = strip_shortcodes($content);
2028	$content = preg_replace('/\[\/?[a-zA-Z][^\]]*\]/', '', $content);
2029
2030	return $content;
2031	}
2032
2033	/**
2034	* Get featured image URL
2035	*/
2036	private function get_featured_image_url($post_id) {
2037	$thumbnail_id = get_post_thumbnail_id($post_id);
2038	if ($thumbnail_id) {
2039	$image_url = wp_get_attachment_image_url($thumbnail_id, 'large');
2040	return $image_url;
2041	}
2042	return '';
2043	}
2044
2045	/**
2046	* Get supported post types
2047	*/
2048	public function get_supported_post_types() {
2049	$post_types = array_values(get_post_types(['public' => true], 'names'));
2050	$post_types = array_diff($post_types, ['attachment']);
2051	return apply_filters('metasync_opengraph_post_types', $post_types);
2052	}
2053
2054	/**
2055	* Add debug menu for testing
2056	*/
2057	private function has_seo_plugin_conflicts() {
2058	// Ensure is_plugin_active() is available on the frontend
2059	if (!function_exists('is_plugin_active')) {
2060	require_once ABSPATH . 'wp-admin/includes/plugin.php';
2061	}
2062
2063	# List of SEO plugins that might output Open Graph tags
2064	$seo_plugins = [
2065	'wordpress-seo/wp-seo.php', # Yoast SEO
2066	'seo-by-rank-math/rank-math.php', # RankMath
2067	'all-in-one-seo-pack/all_in_one_seo_pack.php', # AIOSEO Free
2068	'all-in-one-seo-pack-pro/all_in_one_seo_pack.php', # AIOSEO Pro
2069	'seopress/seopress.php', # SEOPress
2070	'the-seo-framework/autodescription.php', # The SEO Framework
2071	];
2072
2073	foreach ($seo_plugins as $plugin) {
2074	if (is_plugin_active($plugin)) {
2075	return true;
2076	}
2077	}
2078
2079	return false;
2080	}
2081
2082	/**
2083	* Check if a specific SEO plugin is handling Open Graph for current post
2084	*/
2085	private function seo_plugin_has_og_data($post_id) {
2086	# Check if Yoast SEO has Open Graph data
2087	if (is_plugin_active('wordpress-seo/wp-seo.php')) {
2088	$yoast_title = get_post_meta($post_id, '_yoast_wpseo_title', true);
2089	$yoast_desc = get_post_meta($post_id, '_yoast_wpseo_metadesc', true);
2090	if (!empty($yoast_title) \|\| !empty($yoast_desc)) {
2091	return true;
2092	}
2093	}
2094
2095	# Check if RankMath has Open Graph data
2096	if (is_plugin_active('seo-by-rank-math/rank-math.php')) {
2097	$rm_title = get_post_meta($post_id, 'rank_math_title', true);
2098	$rm_desc = get_post_meta($post_id, 'rank_math_description', true);
2099	if (!empty($rm_title) \|\| !empty($rm_desc)) {
2100	return true;
2101	}
2102	}
2103
2104	return false;
2105	}
2106
2107	/**
2108	* Get the canonical URL for a post
2109	*/
2110	public function get_canonical_url($post) {
2111	# Try to get the permalink using WordPress function
2112	$permalink = get_permalink($post->ID);
2113
2114	# If permalink is not available or is the default query URL, try alternative methods
2115	if (!$permalink \|\| strpos($permalink, '?p=') !== false \|\| strpos($permalink, '?page_id=') !== false) {
2116	# Force WordPress to generate the proper permalink by temporarily setting post status
2117	$original_status = $post->post_status;
2118	if ($post->post_status === 'auto-draft') {
2119	$post->post_status = 'publish';
2120	}
2121
2122	# Try get_permalink again with the updated status
2123	$permalink = get_permalink($post->ID);
2124
2125	# Restore original status
2126	$post->post_status = $original_status;
2127	}
2128
2129	# If still not working, use WordPress core functions to build proper permalink
2130	if (!$permalink \|\| strpos($permalink, '?p=') !== false \|\| strpos($permalink, '?page_id=') !== false) {
2131	# Use WordPress core function that respects permalink structure
2132	# This properly handles custom structures, hierarchies, and post types
2133	# Load admin function if not already available
2134	if (!function_exists('get_sample_permalink')) {
2135	require_once ABSPATH . 'wp-admin/includes/post.php';
2136	}
2137	$permalink = get_sample_permalink($post->ID);
2138
2139	if (is_array($permalink)) {
2140	# get_sample_permalink returns array with template and slug
2141	# Replace %postname% or %pagename% with actual slug
2142	$permalink = str_replace(
2143	array('%pagename%', '%postname%'),
2144	$post->post_name,
2145	$permalink[0]
2146	);
2147	}
2148
2149	# Final fallback: if still problematic, construct URL respecting post type structure
2150	if (!$permalink \|\| strpos($permalink, '?p=') !== false \|\| strpos($permalink, '?page_id=') !== false) {
2151	if (!empty($post->post_name)) {
2152	# For pages, check if there's a parent hierarchy
2153	if ($post->post_type === 'page' && $post->post_parent) {
2154	# Get parent page path for proper hierarchy
2155	$parent = get_post($post->post_parent);
2156	$parent_path = '';
2157
2158	# Build full path including all parent pages
2159	while ($parent) {
2160	$parent_path = $parent->post_name . '/' . $parent_path;
2161	$parent = $parent->post_parent ? get_post($parent->post_parent) : null;
2162	}
2163
2164	$permalink = home_url('/' . $parent_path . $post->post_name . '/');
2165	} else {
2166	# For posts and pages without parents, use post type archive base
2167	$post_type_obj = get_post_type_object($post->post_type);
2168	$slug = $post_type_obj->rewrite['slug'] ?? '';
2169
2170	if ($slug && $post->post_type !== 'page') {
2171	$permalink = home_url('/' . $slug . '/' . $post->post_name . '/');
2172	} else {
2173	$permalink = home_url('/' . $post->post_name . '/');
2174	}
2175	}
2176	} else {
2177	# Fallback to post ID format if no slug available
2178	$permalink = home_url('/?p=' . $post->ID);
2179	}
2180	}
2181	}
2182
2183	return $permalink;
2184	}
2185
2186	/**
2187	* Rehost a URL onto the public frontend when headless mode is active.
2188	*
2189	* Unlike the derived-URL callers elsewhere, the value handed here can be a
2190	* stored one an editor typed, which may legitimately point at a third-party
2191	* host. Only a URL on this site's own host is rewritten; anything else is
2192	* returned untouched. A builder failure is returned as an empty string so
2193	* the emitter cannot advertise the WordPress host on an active headless site.
2194	*
2195	* @param mixed $url URL to consider rehosting.
2196	* @param string $post_type Post type, for the frontend path prefix.
2197	* @return mixed Original URL when inactive or foreign; public URL or empty
2198	* string for an own-host URL while active.
2199	*/
2200	private function maybe_build_headless_url($url, $post_type = '') {
2201	if (!class_exists('Metasync_Headless_Config') \|\| !Metasync_Headless_Config::is_active() \|\| !$this->is_own_host_url($url)) {
2202	return $url;
2203	}
2204
2205	return Metasync_Headless_Url_Builder::from_wp_url($url, $post_type);
2206	}
2207
2208	/**
2209	* Whether a URL addresses this WordPress site rather than a foreign host.
2210	*
2211	* Accepts only HTTP(S) URLs on the exact site host, protocol-relative URLs
2212	* on that host, and genuine site-relative paths beginning with one slash.
2213	*
2214	* @param mixed $url URL to test.
2215	* @return bool
2216	*/
2217	private function is_own_host_url($url) {
2218	if (!is_string($url) \|\| $url === '' \|\| preg_match('/\s/', $url)) {
2219	return false;
2220	}
2221
2222	if ($url[0] === '/' && (!isset($url[1]) \|\| $url[1] !== '/')) {
2223	return true;
2224	}
2225
2226	$is_protocol_relative = strpos($url, '//') === 0;
2227	$scheme = strtolower((string) wp_parse_url($url, PHP_URL_SCHEME));
2228	if (!$is_protocol_relative && !in_array($scheme, array('http', 'https'), true)) {
2229	return false;
2230	}
2231
2232	$url_host = wp_parse_url($url, PHP_URL_HOST);
2233	$site_host = wp_parse_url(home_url('/'), PHP_URL_HOST);
2234
2235	return !empty($url_host)
2236	&& !empty($site_host)
2237	&& strcasecmp((string) $url_host, (string) $site_host) === 0;
2238	}
2239
2240	/**
2241	* Update OpenGraph URL when post is saved
2242	*/
2243	public function update_opengraph_url($post_id) {
2244	# Only update for supported post types
2245	if (!in_array(get_post_type($post_id), $this->get_supported_post_types())) {
2246	return;
2247	}
2248
2249	# Skip autosaves and revisions
2250	if (defined('DOING_AUTOSAVE') && DOING_AUTOSAVE) {
2251	return;
2252	}
2253
2254	if (wp_is_post_revision($post_id)) {
2255	return;
2256	}
2257
2258	# Get the post object
2259	$post = get_post($post_id);
2260	if (!$post) {
2261	return;
2262	}
2263
2264	# Check if OpenGraph is enabled
2265	$og_enabled = get_post_meta($post_id, '_metasync_og_enabled', true);
2266	if (empty($og_enabled) \|\| $og_enabled !== '1') {
2267	return;
2268	}
2269
2270	# Get the current OpenGraph URL
2271	$current_og_url = get_post_meta($post_id, '_metasync_og_url', true);
2272
2273	# Generate the proper canonical URL
2274	$canonical_url = $this->get_canonical_url($post);
2275
2276	# Update the OpenGraph URL for new posts or if it's empty/incorrect
2277	# This ensures the URL is populated after first save (even as draft)
2278	if (empty($current_og_url) \|\|
2279	strpos($current_og_url, '?p=') !== false) {
2280
2281	update_post_meta($post_id, '_metasync_og_url', $canonical_url);
2282	}
2283	}
2284
2285	/**
2286	* Check if post permalink changed and update og:url if needed
2287	*/
2288	public function check_permalink_change($post_id, $post_after, $post_before) {
2289	# Only check for supported post types
2290	if (!in_array(get_post_type($post_id), $this->get_supported_post_types())) {
2291	return;
2292	}
2293
2294	# Skip autosaves and revisions
2295	if (defined('DOING_AUTOSAVE') && DOING_AUTOSAVE) {
2296	return;
2297	}
2298
2299	if (wp_is_post_revision($post_id)) {
2300	return;
2301	}
2302
2303	# Check if OpenGraph is enabled
2304	$og_enabled = get_post_meta($post_id, '_metasync_og_enabled', true);
2305	if (empty($og_enabled) \|\| $og_enabled !== '1') {
2306	return;
2307	}
2308
2309	# Get current og:url
2310	$current_og_url = get_post_meta($post_id, '_metasync_og_url', true);
2311	if (empty($current_og_url)) {
2312	return;
2313	}
2314
2315	# Check if the permalink actually changed by comparing post_name (slug)
2316	if ($post_before->post_name === $post_after->post_name) {
2317	return;
2318	}
2319
2320	# Generate the old and new permalinks
2321	$old_permalink = $this->get_canonical_url($post_before);
2322	$new_permalink = $this->get_canonical_url($post_after);
2323
2324	# If permalinks are the same, no need to update
2325	if ($old_permalink === $new_permalink) {
2326	return;
2327	}
2328
2329	# Check if the current og:url matches the old permalink
2330	# This means the og:url was set to the post permalink (not a custom URL)
2331	if ($current_og_url === $old_permalink) {
2332	# Update og:url to the new permalink
2333	update_post_meta($post_id, '_metasync_og_url', $new_permalink);
2334	}
2335	}
2336
2337	/**
2338	* Check if post status changed and update og:url if needed
2339	*/
2340	public function check_status_change($new_status, $old_status, $post) {
2341	# Only check for supported post types
2342	if (!in_array(get_post_type($post->ID), $this->get_supported_post_types())) {
2343	return;
2344	}
2345
2346	# Skip autosaves and revisions
2347	if (defined('DOING_AUTOSAVE') && DOING_AUTOSAVE) {
2348	return;
2349	}
2350
2351	if (wp_is_post_revision($post->ID)) {
2352	return;
2353	}
2354
2355	# Only check when transitioning to published status
2356	if ($new_status !== 'publish' \|\| $old_status === 'publish') {
2357	return;
2358	}
2359
2360	# Check if OpenGraph is enabled
2361	$og_enabled = get_post_meta($post->ID, '_metasync_og_enabled', true);
2362	if (empty($og_enabled) \|\| $og_enabled !== '1') {
2363	return;
2364	}
2365
2366	# Get current og:url
2367	$current_og_url = get_post_meta($post->ID, '_metasync_og_url', true);
2368
2369	# Generate the current permalink
2370	$current_permalink = $this->get_canonical_url($post);
2371
2372	# If og:url is empty or matches the old format, update it
2373	if (empty($current_og_url) \|\| strpos($current_og_url, '?p=') !== false) {
2374	update_post_meta($post->ID, '_metasync_og_url', $current_permalink);
2375	}
2376	}
2377
2378	/**
2379	* Check if post slug changed via edit slug functionality
2380	*/
2381	public function check_slug_change() {
2382	# Fires on the same admin-ajax request as core's sample-permalink
2383	# handler, but at priority 5 — before core validates the nonce and
2384	# capability at its own priority-10 callback. Verify them ourselves
2385	# before any post-meta write. Return (not die) so core still serves
2386	# the preview request normally.
2387	if (!check_ajax_referer('samplepermalink', 'samplepermalinknonce', false)) {
2388	return;
2389	}
2390
2391	# Get the post ID from the request
2392	$post_id = isset($_POST['post_id']) ? intval($_POST['post_id']) : 0;
2393	if (!$post_id \|\| !current_user_can('edit_post', $post_id)) {
2394	return;
2395	}
2396
2397	# Only check for supported post types
2398	if (!in_array(get_post_type($post_id), $this->get_supported_post_types())) {
2399	return;
2400	}
2401
2402	# Check if OpenGraph is enabled
2403	$og_enabled = get_post_meta($post_id, '_metasync_og_enabled', true);
2404	if (empty($og_enabled) \|\| $og_enabled !== '1') {
2405	return;
2406	}
2407
2408	# Get current og:url
2409	$current_og_url = get_post_meta($post_id, '_metasync_og_url', true);
2410	if (empty($current_og_url)) {
2411	return;
2412	}
2413
2414	# Get the post object
2415	$post = get_post($post_id);
2416	if (!$post) {
2417	return;
2418	}
2419
2420	# Generate the current permalink
2421	$current_permalink = $this->get_canonical_url($post);
2422
2423	# Check if the current og:url matches the old permalink format
2424	# This means the og:url was set to the post permalink (not a custom URL)
2425	if ($current_og_url !== $current_permalink && strpos($current_og_url, '?p=') === false) {
2426	# Check if the og:url was the old permalink by comparing with a generated old permalink
2427	$old_post = clone $post;
2428	$old_slug = isset($_POST['new_slug']) ? sanitize_title(wp_unslash($_POST['new_slug'])) : $post->post_name;
2429
2430	# If the og:url doesn't match the current permalink, it might be the old one
2431	# We'll update it to the new permalink
2432	if ($current_og_url !== $current_permalink) {
2433	update_post_meta($post_id, '_metasync_og_url', $current_permalink);
2434	}
2435	}
2436	}
2437	}
2438