<?php
/**
 * MetaForge Engine — Options Page Manager
 *
 * Allows admins to create custom WordPress admin pages and assign
 * MetaForge field groups to them (e.g., "Theme Settings", "Footer Config").
 *
 * Values are stored as individual post meta keys under a dedicated options post.
 * Use `metaforge_get_option($field_name)` to retrieve values in templates.
 */

if ( ! defined( 'ABSPATH' ) ) {
	exit;
}

class MetaForge_OptionsPageManager {

	/** The option key storing user-defined options pages config. */
	const OPTION_KEY = 'metaforge_options_pages';

	/** Hidden WP post type used to store options values. */
	const STORAGE_POST_TYPE = 'metaforge_options';

	public function __construct() {
		add_action( 'admin_menu', array( $this, 'register_options_manager_page' ), 35 );
		add_action( 'admin_menu', array( $this, 'register_options_pages' ), 40 );
		add_action( 'admin_init', array( $this, 'handle_options_page_config_save' ) );
	}

	/**
	 * Add the "Options Pages" management page under MetaForge menu.
	 */
	public function register_options_manager_page() {
		$hook = add_submenu_page(
			'metaforge',
			'Options Pages',
			'Options Pages',
			'manage_metaforge',
			'metaforge_options_pages',
			array( $this, 'render_manager_page' )
		);

		add_action( "load-{$hook}", array( $this, 'load_screen' ) );

		add_submenu_page(
			null,
			'Add Options',
			'Add Options',
			'manage_metaforge',
			'metaforge_options_pages_add',
			'__return_null'
		);
	}

	public function load_screen() {
        // phpcs:ignore WordPress.Security.NonceVerification.Recommended
		$action = isset( $_GET['action'] ) ? sanitize_key( wp_unslash( $_GET['action'] ) ) : '';
		if ( $action !== 'add' && $action !== 'edit' ) {
			require_once METAFORGE_PATH . 'admin/OptionsPageListTable.php';
			$this->list_table = new MetaForge_OptionsPageListTable();

			$screen = get_current_screen();
			if ( $screen ) {
				register_column_headers( $screen, $this->list_table->get_columns() );
			}
		}
	}

	/**
	 * Dynamically register each user-configured options page in the WP sidebar.
	 */
	public function register_options_pages() {
		$pages = get_option( self::OPTION_KEY, array() );
		if ( empty( $pages ) ) {
			return;
		}

		foreach ( $pages as $page ) {
			$slug   = sanitize_key( $page['slug'] ?? '' );
			$title  = sanitize_text_field( $page['title'] ?? 'Options' );
			$parent = $page['parent'] ?? 'metaforge_options_pages';
			if ( ! $slug ) {
				continue;
			}

			$wp_parent = ( $parent === 'metaforge_options_pages' || $parent === 'mfe_options_pages' ) ? 'metaforge' : $parent;

			if ( $wp_parent === 'none' ) {
				// Register as a new top-level menu page
				add_menu_page(
					$title,
					$title,
					'manage_metaforge',
					'metaforge_opts_' . $slug,
					function () use ( $page ) {
						$this->render_options_page( $page );
					},
					'dashicons-admin-generic'
				);
				// Also add a submenu item pointing to itself so the parent name is inherited properly
				add_submenu_page(
					'metaforge_opts_' . $slug,
					$title,
					$title,
					'manage_metaforge',
					'metaforge_opts_' . $slug,
					null
				);
			} else {
				add_submenu_page(
					$wp_parent,
					$title,
					$title,
					'manage_metaforge',
					'metaforge_opts_' . $slug,
					function () use ( $page ) {
						$this->render_options_page( $page );
					}
				);
			}
		}
	}

	/**
	 * Render the Options Pages management screen (where you add/edit option pages).
	 */
	public function render_manager_page() {
        // phpcs:ignore WordPress.Security.NonceVerification.Recommended -- Read-only UI action parameter.
		$action = isset( $_GET['action'] ) ? sanitize_key( wp_unslash( $_GET['action'] ) ) : '';

		if ( $action === 'add' || $action === 'edit' ) {
			$this->render_form();
			return;
		}

		$this->render_list();
	}

	private function render_list() {
		if ( isset( $this->list_table ) ) {
			$list_table = $this->list_table;
		} else {
			require_once METAFORGE_PATH . 'admin/OptionsPageListTable.php';
			$list_table = new MetaForge_OptionsPageListTable();
		}
		$list_table->prepare_items();

		$add_url = admin_url( 'admin.php?page=metaforge_options_pages&action=add' );
        // phpcs:ignore WordPress.Security.NonceVerification.Recommended -- Read-only search query string parameter.
		$s_val    = isset( $_REQUEST['s'] ) ? sanitize_text_field( wp_unslash( $_REQUEST['s'] ) ) : '';
		$is_empty = empty( $list_table->items ) && empty( $s_val );
		?>
		<div class="wrap mfe-wrap">
			<?php MetaForge_AdminHeader::render_top_bar( 'options_pages' ); ?>
			<?php
			ob_start();
			?>
			<form method="get" class="mfe-search-form">
				<input type="hidden" name="page" value="metaforge_options_pages">
				<div class="mfe-search-wrap">
					<span class="mfe-search-icon"><span class="dashicons dashicons-search"></span></span>
					<input type="search" name="s" value="<?php echo esc_attr( $s_val ); ?>" placeholder="Search options pages...">
					<button type="submit">Search</button>
				</div>
			</form>
			<?php
			$search_html = ob_get_clean();
			MetaForge_AdminHeader::render_sub_header( 'Options Pages', $add_url, $search_html );

            // phpcs:disable WordPress.Security.NonceVerification.Recommended -- Read-only error notice flag.
			if ( isset( $_GET['metaforge_error'] ) && sanitize_text_field( wp_unslash( $_GET['metaforge_error'] ) ) === 'duplicate' ) :
				?>
				<div class="mfe-notice-error">
					<p>Error: An options page with that slug already exists.</p>
				</div>
				<?php
			endif;
            // phpcs:enable WordPress.Security.NonceVerification.Recommended
			?>

			<?php if ( $is_empty ) : ?>
				<?php MetaForge_AdminHeader::render_empty_state( 'options_pages', $add_url ); ?>
			<?php else : ?>
				<form method="get" class="mfe-list-form">
					<input type="hidden" name="page" value="metaforge_options_pages">
					<?php wp_nonce_field( 'metaforge_bulk_options_pages', 'metaforge_bulk_options_pages_nonce' ); ?>
					<?php $list_table->views(); ?>
					<?php $list_table->display(); ?>
				</form>
			<?php endif; ?>
			<?php MetaForge_AdminHeader::render_footer(); ?>
		</div>
		<?php
	}

	private function render_form() {
        // phpcs:disable WordPress.Security.NonceVerification.Recommended -- Read-only UI parameters.
		$action     = isset( $_GET['action'] ) ? sanitize_key( wp_unslash( $_GET['action'] ) ) : 'add';
		$edit_index = ( $action === 'edit' && isset( $_GET['index'] ) ) ? intval( wp_unslash( $_GET['index'] ) ) : null;
        // phpcs:enable WordPress.Security.NonceVerification.Recommended

		$title   = '';
		$slug    = '';
		$parent  = 'metaforge_options_pages';
		$is_edit = $edit_index !== null;

		if ( $is_edit ) {
			$pages = get_option( self::OPTION_KEY, array() );
			if ( isset( $pages[ $edit_index ] ) ) {
				$title  = $pages[ $edit_index ]['title'] ?? '';
				$slug   = $pages[ $edit_index ]['slug'] ?? '';
				$parent = $pages[ $edit_index ]['parent'] ?? 'metaforge_options_pages';
			}
		}

		$all_pages      = get_option( self::OPTION_KEY, array() );
		$existing_slugs = array();
		foreach ( $all_pages as $idx => $p ) {
			if ( $is_edit && intval( $edit_index ) === $idx ) {
				continue;
			}
			if ( ! empty( $p['slug'] ) ) {
				$existing_slugs[] = $p['slug'];
			}
		}
		?>
		<div class="wrap mfe-wrap">
			<?php MetaForge_AdminHeader::render_top_bar( 'options_pages' ); ?>
			<form method="post" action="" data-existing-slugs="<?php echo esc_attr( wp_json_encode( $existing_slugs ) ); ?>">
				<?php wp_nonce_field( 'metaforge_save_opts_page', 'metaforge_opts_page_nonce' ); ?>
				<input type="hidden" name="metaforge_action" value="save_options_page">
				<?php if ( $is_edit ) : ?>
					<input type="hidden" name="metaforge_edit_index" value="<?php echo intval( $edit_index ); ?>">
					<input type="hidden" name="metaforge_old_slug" value="<?php echo esc_attr( $slug ); ?>">
				<?php endif; ?>

				<div class="mfe-top-bar">
					<div class="mfe-top-bar-left">
						<h1><?php echo $is_edit ? 'Edit Options Page' : 'Add Options Page'; ?></h1>
						<?php
                        // phpcs:ignore WordPress.Security.NonceVerification.Recommended -- Read-only notice query parameter.
						if ( isset( $_GET['metaforge_error'] ) && sanitize_text_field( wp_unslash( $_GET['metaforge_error'] ) ) === 'duplicate' ) :
							?>
							<span class="mfe-badge-warn">
								<span class="dashicons dashicons-warning"></span>
								An options page with that slug already exists.
							</span>
						<?php endif; ?>
					</div>
					<div class="mfe-top-bar-right">
						<a href="admin.php?page=metaforge_options_pages" class="mfe-btn-secondary">← Back</a>
						<button type="submit" class="mfe-btn-primary">
							<span class="dashicons dashicons-saved"></span> <?php echo $is_edit ? 'Save Changes' : 'Save Options Page'; ?>
						</button>
					</div>
				</div>

				<div class="mfe-builder-wrap mfe-mt-20">
					<div class="mfe-card">
						<div class="mfe-card-header">
							<div class="mfe-card-header-left">
								<span class="dashicons dashicons-admin-generic"></span>
								<strong>Options Page Settings</strong>
							</div>
						</div>
						<div class="mfe-card-body">
							<div class="mfe-setting-row">
								<div class="mfe-setting-label">Page Title <small>e.g. Theme Settings</small></div>
								<div class="mfe-setting-input">
									<input id="metaforge_opts_title" type="text" name="metaforge_opts_title" value="<?php echo esc_attr( $title ); ?>"
										placeholder="e.g. Theme Settings" required>
								</div>
							</div>
							<div class="mfe-setting-row">
								<div class="mfe-setting-label">Page Slug <small>e.g. theme_settings</small></div>
								<div class="mfe-setting-input">
									<input id="metaforge_opts_slug" type="text" name="metaforge_opts_slug" value="<?php echo esc_attr( $slug ); ?>"
										placeholder="e.g. theme_settings" required>
									<p class="description">Lowercase, underscores only. Used as the menu slug.</p>
								</div>
							</div>
							<div class="mfe-setting-row mfe-border-none">
								<div class="mfe-setting-label">Parent Menu <small>Where this page appears in the WordPress sidebar</small></div>
								<div class="mfe-setting-input">
									<select name="metaforge_opts_parent" id="metaforge_opts_parent">
										<option value="metaforge_options_pages" <?php selected( $parent, 'metaforge_options_pages' ); ?>>MetaForge Menu</option>
										<option value="none" <?php selected( $parent, 'none' ); ?>>Top-level Menu Page (Standalone)</option>
										<option value="options-general.php" <?php selected( $parent, 'options-general.php' ); ?>>Settings Menu</option>
										<option value="tools.php" <?php selected( $parent, 'tools.php' ); ?>>Tools Menu</option>
										<option value="edit.php" <?php selected( $parent, 'edit.php' ); ?>>Posts Menu</option>
										<option value="edit.php?post_type=page" <?php selected( $parent, 'edit.php?post_type=page' ); ?>>Pages Menu</option>
									</select>
								</div>
							</div>
						</div>
					</div>
				</div>
			</form>
			<?php MetaForge_AdminHeader::render_footer(); ?>
		</div>
		<?php
	}

	/**
	 * Handle adding/editing/deleting an options page from the manager.
	 */
	public function handle_options_page_config_save() {
		if ( ! is_admin() || ! current_user_can( 'manage_metaforge' ) ) {
			return;
		}

		if ( isset( $_POST['metaforge_action'] ) && $_POST['metaforge_action'] === 'save_options_page' ) {
			check_admin_referer( 'metaforge_save_opts_page', 'metaforge_opts_page_nonce' );

			$title  = sanitize_text_field( wp_unslash( $_POST['metaforge_opts_title'] ?? '' ) );
			$slug   = sanitize_key( wp_unslash( $_POST['metaforge_opts_slug'] ?? '' ) );
			$parent = sanitize_text_field( wp_unslash( $_POST['metaforge_opts_parent'] ?? 'metaforge_options_pages' ) );

			$edit_index = isset( $_POST['metaforge_edit_index'] ) ? absint( wp_unslash( $_POST['metaforge_edit_index'] ) ) : null;
			$old_slug   = isset( $_POST['metaforge_old_slug'] ) ? sanitize_key( wp_unslash( $_POST['metaforge_old_slug'] ) ) : '';

			if ( $title && $slug ) {
				$pages = get_option( self::OPTION_KEY, array() );

				foreach ( $pages as $idx => $existing ) {
					if ( $edit_index !== null && $edit_index === $idx ) {
						continue;
					}
					if ( ( $existing['slug'] ?? '' ) === $slug ) {
						wp_safe_redirect( admin_url( 'admin.php?page=metaforge_options_pages&metaforge_error=duplicate' ) );
						exit;
					}
				}

				$page_data = array(
					'title'  => $title,
					'slug'   => $slug,
					'parent' => $parent,
				);

				if ( $edit_index !== null && isset( $pages[ $edit_index ] ) ) {
					$pages[ $edit_index ] = $page_data;
				} else {
					$pages[] = $page_data;
				}

				update_option( self::OPTION_KEY, $pages );
				$this->get_or_create_store_post( $slug, $title );

				if ( $old_slug && $old_slug !== $slug ) {
					$this->update_field_groups_options_page_slug( $old_slug, $slug );
				}
			}
			wp_safe_redirect( admin_url( 'admin.php?page=metaforge_options_pages' ) );
			exit;
		}

		if ( isset( $_GET['action'] ) && $_GET['action'] === 'delete' && isset( $_GET['index'] ) ) {
			check_admin_referer( 'metaforge_delete_opts_page' );
			if ( ! current_user_can( 'manage_metaforge' ) ) {
				wp_die( esc_html__( 'You do not have sufficient permissions to access this page.', 'metaforge-engine' ) );
			}

			$pages = get_option( self::OPTION_KEY, array() );
			$index = intval( $_GET['index'] );
			if ( isset( $pages[ $index ] ) ) {
				unset( $pages[ $index ] );
				update_option( self::OPTION_KEY, array_values( $pages ) );
			}
			wp_safe_redirect( admin_url( 'admin.php?page=metaforge_options_pages' ) );
			exit;
		}
	}

	private function update_field_groups_options_page_slug( $old_slug, $new_slug ) {
		$posts = get_posts(
			array(
				'post_type'      => 'metaforge_group',
				'posts_per_page' => -1,
				'post_status'    => 'any',
			)
		);

		foreach ( $posts as $post ) {
			$config = get_post_meta( $post->ID, '_metaforge_group_config', true );
			if ( ! is_array( $config ) || empty( $config['location_rules'] ) ) {
				continue;
			}

			$updated = false;
			foreach ( $config['location_rules'] as &$group_rules ) {
				if ( ! is_array( $group_rules ) ) {
					continue;
				}
				foreach ( $group_rules as &$rule ) {
					if ( ( $rule['param'] ?? '' ) === 'options_page' && ( $rule['value'] ?? '' ) === $old_slug ) {
						$rule['value'] = $new_slug;
						$updated       = true;
					}
				}
			}

			if ( $updated ) {
				update_post_meta( $post->ID, '_metaforge_group_config', $config );
			}
		}

		MetaForge_Loader::clear_cache();
	}

	/**
	 * Render a user-defined options page with MetaForge fields.
	 */
	public function render_options_page( array $page ) {
		$slug     = sanitize_key( $page['slug'] );
		$title    = esc_html( $page['title'] );
		$store_id = $this->get_or_create_store_post( $slug, $page['title'] );

		// Get all field groups assigned to this options page
		$groups = $this->get_groups_for_options_page( $slug );

		$saved = false;
		if ( isset( $_POST['metaforge_save_options'] ) ) {
			check_admin_referer( 'metaforge_options_save_' . $slug, 'metaforge_options_nonce' );
			if ( current_user_can( 'manage_metaforge' ) ) {
				// phpcs:disable WordPress.Security.ValidatedSanitizedInput.InputNotSanitized -- Raw JSON payload validated via json_decode() and options input array sanitized per field schema in save_options_values().
				if ( ! empty( $_POST['metaforge_opts_json'] ) ) {
					$raw_json = wp_unslash( $_POST['metaforge_opts_json'] );
					if ( is_string( $raw_json ) && $raw_json !== '' && $raw_json !== '{}' && $raw_json !== '[]' ) {
						$json_data = json_decode( $raw_json, true );
						if ( is_array( $json_data ) && ! empty( $json_data ) ) {
							$_POST['metaforge_option'] = $json_data;
						}
					}
				}
				$options_input = isset( $_POST['metaforge_option'] ) && is_array( $_POST['metaforge_option'] ) ? wp_unslash( $_POST['metaforge_option'] ) : array();
				// phpcs:enable WordPress.Security.ValidatedSanitizedInput.InputNotSanitized
				$this->save_options_values( $store_id, $groups, $options_input );
				$saved = true;
			}
		}
		?>
		<div class="wrap mfe-wrap">
			<?php MetaForge_AdminHeader::render_top_bar( 'options_pages' ); ?>

			<?php if ( empty( $groups ) ) : ?>
				<?php
				MetaForge_AdminHeader::render_sub_header( esc_html( $page['title'] ), admin_url( 'admin.php?page=metaforge&action=add' ) );
				?>
				<div class="mfe-builder-wrap">
					<div class="mfe-notice-warning mfe-mt-20">
						<p>No field groups are assigned to this options page yet. <a
								href="<?php echo esc_url( admin_url( 'admin.php?page=metaforge&action=add' ) ); ?>">Create a Field Group</a>
							and set its Location to <strong>Options Page &rarr; <?php echo esc_html( $title ); ?></strong>.</p>
					</div>
				</div>
			<?php else : ?>
				<form method="post">
					<?php wp_nonce_field( 'metaforge_options_save_' . $slug, 'metaforge_options_nonce' ); ?>
					<input type="hidden" name="metaforge_save_options" value="1">

					<?php
					$save_btn = '<button type="submit" class="mfe-btn-primary"><span class="dashicons dashicons-saved"></span> ' . esc_html__( 'Save Options', 'metaforge-engine' ) . '</button>';
					MetaForge_AdminHeader::render_sub_header( esc_html( $page['title'] ), '', $save_btn );
					?>

					<?php if ( $saved ) : ?>
						<div class="mfe-notice-success mfe-mt-16">
							<span class="dashicons dashicons-yes mfe-notice-icon"></span>
							<p><?php esc_html_e( 'Options saved successfully.', 'metaforge-engine' ); ?></p>
							<button type="button" class="mfe-notice-close" aria-label="<?php esc_attr_e( 'Dismiss notice', 'metaforge-engine' ); ?>">&times;</button>
						</div>
					<?php endif; ?>

					<div class="mfe-builder-wrap mfe-mt-20">
						<?php foreach ( $groups as $group ) : ?>
							<?php
							if ( empty( $group['fields'] ) ) {
								continue;}
							?>
							<div class="mfe-post-edit-group mfe-mb-20">
								<?php if ( strtolower( $group['group_name'] ?? '' ) !== strtolower( $title ) ) : ?>
									<h3><?php echo esc_html( $group['group_name'] ?? 'Settings' ); ?></h3>
								<?php endif; ?>
								<?php foreach ( $group['fields'] as $field ) : ?>
									<?php
									$field_name = $field['name'] ?? '';
									if ( ! $field_name ) {
										continue;
									}
									$value = get_post_meta( $store_id, $field_name, true );
									if ( in_array( $field['type'] ?? '', array( 'repeater', 'group' ), true ) ) {
										if ( ! is_array( $value ) ) {
											$value = array();
										} else {
											$value = $this->strip_template_rows_options( $value );
											if ( ( $field['type'] ?? '' ) === 'repeater' ) {
												$value = array_values( $value );
											}
										}
									}
									MetaForge_FieldManager::render_field( $field, $value, 'metaforge_option[' . esc_attr( $field_name ) . ']' );
									?>
								<?php endforeach; ?>
							</div>
						<?php endforeach; ?>
					</div>

					<div class="mfe-bottom-bar">
						<button type="submit" class="mfe-btn-primary">
							<span class="dashicons dashicons-saved"></span> <?php esc_html_e( 'Save Options', 'metaforge-engine' ); ?>
						</button>
					</div>
				</form>
			<?php endif; ?>

			<?php MetaForge_AdminHeader::render_footer(); ?>
		</div>
		<?php
	}


	/**
	 * Save submitted options values to post meta on the store post.
	 */
	private function save_options_values( int $store_id, array $groups, array $submitted ) {

		foreach ( $groups as $group ) {
			foreach ( $group['fields'] ?? array() as $field ) {
				$name = $field['name'] ?? '';
				$type = $field['type'] ?? 'text';
				if ( ! $name ) {
					continue;
				}

				$raw = $submitted[ $name ] ?? null;
				if ( $raw === null ) {
					if ( $type === 'repeater' ) {
						$raw = array();
					} else {
						delete_post_meta( $store_id, $name );
						continue;
					}
				}


				// Sanitize based on field type to preserve data integrity
				$registry_instance = MetaForge_Field_Registry::get_field_type( $type );
				if ( ! $registry_instance ) {
					$class_name = 'MetaForge_' . str_replace( ' ', '', ucwords( str_replace( '_', ' ', $type ) ) ) . 'Field';
					if ( class_exists( $class_name ) ) {
						$registry_instance = new $class_name();
					}
				}
				if ( $registry_instance ) {
					$clean = $registry_instance->sanitize( $raw, $field );
					if ( is_array( $clean ) && in_array( $type, array( 'repeater', 'group', 'flexible_content' ), true ) ) {
						$clean = $this->strip_template_rows_options( $clean );
						if ( in_array( $type, array( 'repeater', 'flexible_content' ), true ) ) {
							$clean = array_values( $clean );
						}
					}
				} else {
					switch ( $type ) {
						case 'textarea':
							$clean = sanitize_textarea_field( $raw );
							break;
						case 'wysiwyg':
							$clean = wp_kses_post( $raw );
							break;
						case 'true_false':
							$clean = (bool) $raw ? 1 : 0;
							break;
						case 'checkbox':
						case 'taxonomy':
							// Multi-value: store as serialized array
							$clean = is_array( $raw )
								? array_map( 'sanitize_text_field', $raw )
								: sanitize_text_field( $raw );
							break;
						case 'image':
						case 'file':
							$clean = absint( $raw );
							break;
						case 'repeater':
						case 'group':
							$clean = $this->sanitize_recursive_options( $raw );
							if ( is_array( $clean ) ) {
								$clean = $this->strip_template_rows_options( $clean );
								if ( $type === 'repeater' ) {
									$clean = array_values( $clean );
								}
							}
							break;
						case 'link':
							$clean = is_array( $raw ) ? array(
								'url'    => esc_url_raw( $raw['url'] ?? '' ),
								'text'   => sanitize_text_field( $raw['text'] ?? ( $raw['title'] ?? '' ) ),
								'target' => in_array( $raw['target'] ?? '', array( '', '_blank' ) ) ? ( $raw['target'] ?? '' ) : '',
							) : sanitize_text_field( $raw );
							break;
						default:
							$clean = sanitize_text_field( $raw );
					}
				}
				update_post_meta( $store_id, $name, $clean );
			}
		}
	}

	/**
	 * Get all field groups whose location rule targets a specific options page slug.
	 *
	 * P-2: Reads from the shared metaforge_all_field_groups_cache transient (same one used
	 * everywhere else) instead of issuing a raw get_posts() on every options page render.
	 */
	public function get_groups_for_options_page( string $slug ): array {
		// Re-use the same transient populated by MetaForge_FieldManager::get_groups_by_post_type().
		$all_groups = get_transient( 'metaforge_all_field_groups_cache' );

		if ( false === $all_groups ) {
			// Cache miss: hydrate it the same way FieldManager does.
			$posts      = get_posts(
				array(
					'post_type'      => 'metaforge_group',
					'posts_per_page' => -1,
					'post_status'    => 'publish',
					'orderby'        => 'menu_order',
					'order'          => 'ASC',
				)
			);
			$all_groups = array();
			foreach ( $posts as $post ) {
				$config = get_post_meta( $post->ID, '_metaforge_group_config', true );
				if ( is_array( $config ) ) {
					$all_groups[] = $config;
				}
			}
			set_transient( 'metaforge_all_field_groups_cache', $all_groups, HOUR_IN_SECONDS * 24 );
		}

		$result = array();
		foreach ( $all_groups as $config ) {
			if ( ! is_array( $config ) ) {
				continue;
			}
			foreach ( $config['location_rules'] ?? array() as $rule_group ) {
				foreach ( $rule_group as $rule ) {
					if ( ( $rule['param'] ?? '' ) === 'options_page' && ( $rule['value'] ?? '' ) === $slug ) {
						$result[] = $config;
						break 2;
					}
				}
			}
		}

		return $result;
	}

	/**
	 * Ensure a backing store post exists for the given options page slug.
	 * Returns the post ID.
	 */
	private function get_or_create_store_post( string $slug, string $title ): int {
		global $wpdb;
        // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- Storage post ID lookup via custom post type query.
		$post_id = $wpdb->get_var(
			$wpdb->prepare(
				"SELECT ID FROM {$wpdb->posts} WHERE post_title = %s AND post_type = %s AND post_status = 'publish' LIMIT 1",
				$slug,
				self::STORAGE_POST_TYPE
			)
		);

		if ( $post_id ) {
			return intval( $post_id );
		}

		return wp_insert_post(
			array(
				'post_title'  => $slug,
				'post_type'   => self::STORAGE_POST_TYPE,
				'post_status' => 'publish',
			)
		);
	}

	private function sanitize_recursive_options( $value ) {
		if ( is_array( $value ) ) {
			$out = array();
			foreach ( $value as $k => $v ) {
				$out[ $k ] = $this->sanitize_recursive_options( $v );
			}
			return $out;
		}

		return wp_kses_post( wp_unslash( (string) $value ) );
	}

	private function strip_template_rows_options( $data ) {
		if ( ! is_array( $data ) ) {
			return $data;
		}
		$out = array();
		foreach ( $data as $k => $v ) {
			if ( (string) $k === '999' ) {
				continue;
			}
			$out[ $k ] = is_array( $v ) ? $this->strip_template_rows_options( $v ) : $v;
		}
		return $out;
	}
}