<?php
/**
 * Plugin Name:       AI-O Optimiser
 * Plugin URI:        https://ai-o.com.au/ai-o-optimiser/
 * Description:       Free edition. See which AI assistants reach your site, and whether anything is blocking them. Metadata, Schema and NAP are in the paid edition.
 * Version:           1.39.7
 * Requires at least: 6.9
 * Requires PHP:      8.0
 * Author:            AI-O
 * Author URI:        https://ai-o.com.au/
 * License:           GPL v2 or later
 * License URI:       https://www.gnu.org/licenses/gpl-2.0.html
 * Text Domain:       ai-o-optimiser
 */

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

/*
 * Refuse activation outright while the sibling edition is active, reliably,
 * regardless of which entry file WordPress happens to require first.
 *
 * This has to be registered here, unconditionally, before the stand-down
 * guard below has any chance to return early -- and it has to be a closure,
 * not a named function, because a closure is a runtime value created fresh
 * at this exact call site, never a compile-time declaration, so registering
 * one is always safe even when this exact file (or the sibling edition's
 * byte-identical copy of it) has already been required earlier in the same
 * request. register_activation_hook() itself is likewise just a function
 * call, not a declaration, so it is always safe to call unconditionally too.
 *
 * Why this exists, and why AI_O_Optimiser_Migration::prepare_activation()
 * alone was not enough: that refusal only ever ran for whichever copy's
 * declarations happened to "win" the stand-down guard below, because it
 * lives in includes/ai-o-optimiser-runtime.php, reached only past that
 * guard's early return -- and this file's own former comment assumed
 * "folders sort before their -pro sibling" decides which copy that is. It
 * does not: WordPress's activate_plugin() sorts active_plugins with plain
 * PHP sort(), and "ai-o-optimiser-pro/ai-o-optimiser-pro.php" sorts BEFORE
 * "ai-o-optimiser/ai-o-optimiser.php" ('-' is ASCII 0x2D, '/' is 0x2F) -- so
 * on a real install activating core while the standalone paid package is
 * already active, standalone Pro's entry loads first, core's own guard
 * below sees AI_O_Optimiser_VERSION already defined, and core silently
 * stands itself down before ever reaching the runtime file -- so its own
 * activation hook, and therefore the correct refusal, never ran at all. See
 * RELEASES/1.37.25-core-pro-addon-migration-safety-net-fix.md for how this was found and
 * fixed; tests/core-pro-addon-coexistence.php pins it against the real load
 * order, not just the friendly one.
 *
 * Deliberately self-contained rather than reaching for
 * AI_O_Optimiser_Migration: that class collides symbol-for-symbol with the
 * sibling edition's own identical copy (same source), so reusing whichever
 * copy happened to load first would run the WRONG edition's refusal rule
 * against THIS activation attempt. is_plugin_active() carries no such risk
 * -- it is a WordPress core function, never declared by this codebase.
 */
register_activation_hook(
	__FILE__,
	function () {
		if ( ! function_exists( 'is_plugin_active' ) ) {
			require_once ABSPATH . 'wp-admin/includes/plugin.php';
		}
		/*
		 * The standalone paid package's own basename. Free's carve rewrites
		 * this the same way it already rewrites
		 * AI_O_Optimiser_Migration::sibling_edition_basenames() --
		 * tools/build-free-edition.php's own verification sweep covers both.
		 */
		$sibling_basename = 'ai-o-optimiser-pro/ai-o-optimiser.php';
		if ( ! is_plugin_active( $sibling_basename ) ) {
			return;
		}
		$data = function_exists( 'get_plugin_data' ) ? get_plugin_data( trailingslashit( WP_PLUGIN_DIR ) . $sibling_basename, false, false ) : array();
		$name = is_array( $data ) && ! empty( $data['Name'] ) ? (string) $data['Name'] : $sibling_basename;
		deactivate_plugins( plugin_basename( __FILE__ ) );
		wp_die(
			sprintf(
				/* translators: %s: the other AI-O Optimiser edition's name and basename, as "Name (folder/file.php)". */
				esc_html__( 'AI-O Optimiser was not activated. Another copy of AI-O Optimiser is active and both would read and write the same data: %s. Deactivate it from the Plugins screen, then activate this one. Its data is kept and carried across.', 'ai-o-optimiser' ),
				esc_html( sprintf( '%1$s (%2$s)', $name, $sibling_basename ) )
			),
			esc_html__( 'AI-O Optimiser was not activated', 'ai-o-optimiser' ),
			array( 'back_link' => true )
		);
	}
);

/*
 * Stand down when another copy of this plugin is already loaded.
 *
 * WordPress activates a plugin by including its entry file in a request where
 * the already-active plugins are loaded too (plugin_sandbox_scrape()). Two
 * copies in two folders -- an upgrade installed alongside the running one, or
 * Free alongside the paid edition -- therefore reach this file twice in one
 * process. Without this guard the second include dies on the first function
 * declaration below with "Cannot redeclare
 * ai_o_optimiser_meets_minimum_requirements()", and WordPress reports only
 * "Plugin could not be activated because it triggered a fatal error."
 *
 * This is the ordinary-page-load half of the protection; the closure above
 * is the activation-time half, and covers the case this guard alone cannot:
 * whichever copy stands down here never reaches its own activation hook, so
 * without the closure above, activating this edition while the sibling is
 * already active would succeed silently, with no refusal at all, whenever
 * this copy happens to be the one that stands down (which the sort-order
 * mistake above meant was every real install).
 *
 * tests/plugin-path-activation-collision.php pins the redeclaration half;
 * tests/core-pro-addon-coexistence.php pins the sibling-refusal half.
 */
if ( defined( 'AI_O_Optimiser_VERSION' ) ) {
	add_action(
		'admin_notices',
		function () {
			if ( ! current_user_can( 'activate_plugins' ) ) {
				return;
			}
			echo '<div class="notice notice-error"><p>' . sprintf(
				/* translators: 1: version of the copy that is running, 2: file path of the copy that stood down. */
				esc_html__( 'Two copies of AI-O Optimiser are installed. Version %1$s loaded first and is running; the copy at %2$s has stood down to avoid a fatal error. Deactivate and delete whichever copy you do not want, then reactivate the other.', 'ai-o-optimiser' ),
				esc_html( AI_O_Optimiser_VERSION ),
				esc_html( str_replace( ABSPATH, '', __FILE__ ) )
			) . '</p></div>';
		}
	);
	return;
}

define( 'AI_O_Optimiser_MIN_WP_VERSION', '6.9' );
define( 'AI_O_Optimiser_NATIVE_AI_MIN_WP_VERSION', '7.0' );
define( 'AI_O_Optimiser_MIN_PHP_VERSION', '8.0' );
define( 'AI_O_Optimiser_VERSION', '1.39.7' );
define( 'AI_O_Optimiser_PRODUCT_NAME', 'AI-O Optimiser' );
define( 'AI_O_Optimiser_PLUGIN_FILE', __FILE__ );
define( 'AI_O_Optimiser_PLUGIN_DIR', plugin_dir_path( __FILE__ ) );
define( 'AI_O_Optimiser_PLUGIN_URL', plugin_dir_url( __FILE__ ) );
define( 'AI_O_Optimiser_TABLE_NAME', 'ai_o_optimiser_crawler_log' );
define( 'AI_O_Optimiser_NIGHTLY_HEALTH_HOOK', 'ai_o_optimiser_nightly_health_check' );
define( 'AI_O_Optimiser_SENSITIVE_CAPABILITY', 'manage_ai_o_optimiser_sensitive' );
// Mirrors AI_O_Optimiser_Migration::STATE_OPTION. Declared here so the upgrade
// gate can read it without paying the parse cost of the migration class on
// every request. tests/migration-upgrade-ordering.php asserts the two match.
define( 'AI_O_Optimiser_MIGRATION_STATE_OPTION', 'ai_o_optimiser_migration_1203' );

/*
 * Declarations live in the runtime file, not here, so the guard above can work
 * at all -- see the comment at the top of that file.
 */
require_once AI_O_Optimiser_PLUGIN_DIR . 'includes/ai-o-optimiser-runtime.php';