<?php

namespace Yipresser\AdminOptimizer\Admin;

use Yipresser\AdminOptimizer\Module_Registry;

// Exit if accessed directly.
if ( ! defined( 'ABSPATH' ) ) {
	exit;
}

/**
 * Shared Free-owned write path for capability activation
 *
 * This is the single AJAX endpoint any rendering surface uses to change a
 * capability's canonical ON/OFF state. Overview uses it for `MODULE`
 * capabilities; `Sections\Performance` also uses it for its
 * Section-owned `SECTION_FEATURE` tweaks. Both classifications are accepted
 * by the same action, same nonce, and same `Module_Registry::set_enabled()`
 * write primitive — there is no second endpoint and no second write
 * semantics. `NATIVE` and `ACTIVATION_ALWAYS` capabilities have no persisted
 * toggle and are always rejected here.
 *
 * Availability (`Module_Registry::is_available()`) is a `MODULE`-only
 * concept — it is defined as "MODULE classification and a resolvable
 * runtime_target" and is unconditionally `false` for any other
 * classification. `SECTION_FEATURE` capabilities are Section-executed
 * directly (no `Runtime_Loader` construction, no `runtime_target`), so the
 * availability gate below applies only when the resolved capability is a
 * `MODULE`; a `SECTION_FEATURE` request skips it entirely rather than being
 * permanently rejected as "unavailable".
 *
 * This class carries no assumption about which screen or DOM issued the
 * request — it accepts a canonical module ID and a desired boolean state and
 * nothing else. It never trusts the browser for option keys, classification,
 * tier, availability, or runtime target: every one of those is re-resolved
 * from `Module_Registry` server-side.
 *
 * It also owns a second, unrelated write path: `handle_pin_toggle()` is the
 * single AJAX endpoint for pinning/unpinning a module on the Optimize
 * submenu (`Section_Renderer`'s pin control). Pinning is presentation only —
 * it never changes canonical activation state — but is colocated here rather
 * than in its own class, mirroring the shared-endpoint shape above: one
 * capability check, one nonce, one small persisted option (`PIN_OPTION`),
 * this class the sole writer. Readers (`Section_Renderer`, `Bootstrap::add_pinned_menu()`)
 * call `get_option( self::PIN_OPTION, [] )` directly rather than through a
 * getter here, since `is_available()`/`has_module()` at the read site already
 * filter out anything stale without needing a shared normalize step.
 */
final class Module_Activation {

	const ACTION = 'adminoptimizer_toggle_module';

	const NONCE_ACTION = 'adminoptimizer_toggle_module';

	const NONCE_FIELD = 'nonce';

	/**
	 * Site-wide pinned-module shortcuts option (array of canonical module
	 * IDs) read directly by `Section_Renderer` and `Bootstrap::add_pinned_menu()`
	 * -- this class is the sole writer, but not a gatekeeper for reads.
	 */
	const PIN_OPTION = 'adminoptim_pinned_modules';

	const PIN_ACTION = 'adminoptimizer_toggle_pinned_module';

	const PIN_NONCE_ACTION = 'adminoptimizer_toggle_pinned_module';

	const MAX_PINS = 5;

	/**
	 * Register the AJAX hooks.
	 *
	 * @return void
	 */
	public function register(): void {
		add_action( 'wp_ajax_' . self::ACTION, [ $this, 'handle' ] );
		add_action( 'wp_ajax_' . self::PIN_ACTION, [ $this, 'handle_pin_toggle' ] );
	}

	/**
	 * Handle a module activation/deactivation AJAX request.
	 *
	 * Validation order: canonical module ID resolution, module-specific
	 * activation capability, nonce, classification, availability — each rejection returns a
	 * distinct error code so callers/tests can distinguish failure reasons.
	 *
	 * @return void
	 */
	public function handle(): void {
		$module_id = isset( $_POST['module_id'] ) ? sanitize_text_field( wp_unslash( $_POST['module_id'] ) ) : '';

		if ( '' === $module_id || ! Module_Registry::has_module( $module_id ) ) {
			wp_send_json_error( [ 'code' => 'unknown_module' ], 404 );
		}

		$module = Module_Registry::get_module( $module_id );
		if ( ! current_user_can( Module_Registry::get_activation_capability( $module['id'] ) ) ) {
			wp_send_json_error( [ 'code' => 'forbidden' ], 403 );
		}

		check_ajax_referer( self::NONCE_ACTION, self::NONCE_FIELD );

		$enabled = ! empty( $_POST['enabled'] ) && '0' !== $_POST['enabled'];

		$classification = $module['classification'];

		if (
			( Module_Registry::MODULE !== $classification && Module_Registry::SECTION_FEATURE !== $classification )
			|| ! Module_Registry::is_toggleable( $module_id )
		) {
			wp_send_json_error( [ 'code' => 'not_toggleable' ], 400 );
		}

		if ( Module_Registry::MODULE === $classification && $enabled && ! Module_Registry::is_available( $module_id ) ) {
			wp_send_json_error( [ 'code' => 'unavailable' ], 400 );
		}

		$result = Module_Registry::set_enabled( $module_id, $enabled );

		if ( is_wp_error( $result ) ) {
			wp_send_json_error( [ 'code' => $result->get_error_code() ], 500 );
		}

		wp_send_json_success( $this->canonical_state_payload( $module_id ) );
	}

	/**
	 * Handle a pin/unpin AJAX request: appends the module ID to
	 * `PIN_OPTION` if absent, removes it if present. Unlike `handle()`,
	 * pinning is presentation/navigation only -- there is no classification
	 * or activation-mode gate, only that the ID resolve to a real,
	 * currently-registered module.
	 *
	 * @return void
	 */
	public function handle_pin_toggle(): void {
		if ( ! current_user_can( $this->pin_required_capability() ) ) {
			wp_send_json_error( [ 'code' => 'forbidden' ], 403 );
		}

		check_ajax_referer( self::PIN_NONCE_ACTION, self::NONCE_FIELD );

		$module_id = isset( $_POST['module_id'] ) ? sanitize_key( wp_unslash( $_POST['module_id'] ) ) : '';

		if ( '' === $module_id || ! Module_Registry::has_module( $module_id ) ) {
			wp_send_json_error( [ 'code' => 'unknown_module' ], 404 );
		}

		$pinned = self::normalize_pinned( (array) get_option( self::PIN_OPTION, [] ) );

		if ( in_array( $module_id, $pinned, true ) ) {
			$pinned = array_values( array_diff( $pinned, [ $module_id ] ) );
		} else {
			$pinned[] = $module_id;
		}

		$pinned = self::normalize_pinned( $pinned );

		update_option( self::PIN_OPTION, $pinned );

		wp_send_json_success(
			[
				'module_id' => $module_id,
				'pinned'    => in_array( $module_id, $pinned, true ),
			]
		);
	}

	/**
	 * Sanitize, dedupe, drop any slug that isn't a real currently-registered
	 * module, and cap the list at MAX_PINS by dropping the oldest entries
	 * (the front of the list, since new pins are appended at the end).
	 *
	 * @param array $slugs Raw slug list.
	 *
	 * @return array<int, string>
	 */
	private static function normalize_pinned( array $slugs ): array {
		$normalized = [];

		foreach ( $slugs as $slug ) {
			$slug = sanitize_key( (string) $slug );

			if ( '' === $slug || in_array( $slug, $normalized, true ) || ! Module_Registry::has_module( $slug ) ) {
				continue;
			}

			$normalized[] = $slug;
		}

		if ( count( $normalized ) > self::MAX_PINS ) {
			$normalized = array_slice( $normalized, -self::MAX_PINS );
		}

		return $normalized;
	}

	/**
	 * Pinning mutates one site-wide navigation option, not module runtime
	 * state. It deliberately retains the console-administrator policy instead
	 * of inheriting a module's activation capability.
	 *
	 * @return string
	 */
	private function pin_required_capability(): string {
		return 'manage_options';
	}

	/**
	 * Re-resolve and return a module's canonical state after a write, rather
	 * than deriving the response from the submitted boolean (Phase 3.5B.2 §9).
	 *
	 * @param string $module_id Canonical module ID.
	 *
	 * @return array{module_id:string,enabled:bool,status:string,section:string}
	 */
	private function canonical_state_payload( string $module_id ): array {
		$module = Module_Registry::get_module( $module_id );

		return [
			'module_id' => $module_id,
			'enabled'   => Module_Registry::is_enabled( $module_id ),
			'status'    => Module_Registry::get_status( $module_id ),
			'section'   => $module['section'] ?? '',
		];
	}
}