<?php
/**
 * Admin Initializer for Accessibility Audio TTS
 *
 * Handles initialization of admin-specific components including controllers,
 * asset management, settings, and WordPress optimizations.
 *
 * @package Accessibility_Audio_TTS
 * @subpackage Core\Bootstrap
 * @since 2.0.0
 * @author App4You.dev
 */

namespace Accessibility_Audio_TTS\Core\Bootstrap;

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

/**
 * Admin component initializer
 *
 * Manages initialization of admin-specific functionality including
 * secure admin classes, renderers, conversion manager, and asset
 * management system with lazy loading support.
 *
 * @since 2.0.0
 */
class Admin_Initializer {

	/**
	 * Admin components registry
	 *
	 * @var array
	 */
	private static array $admin_components = array();

	/**
	 * Initialized admin components
	 *
	 * @var array
	 */
	private static array $initialized = array();

	/**
	 * Initialize admin components
	 *
	 * @throws \Exception If admin initialization fails.
	 * @return void
	 */
	public static function init(): void {
		try {
			if ( defined( 'WP_DEBUG' ) && WP_DEBUG ) {
				accessibility_audio_tts_debug_log( 'AAT: Admin initialization started' );
			}

			// Setup WordPress optimizations first.
			self::setup_wordpress_optimizations();

			// Initialize admin security.
			self::initialize_admin_security();

			// Initialize admin controllers.
			self::initialize_admin_controllers();

			// Initialize admin renderers.
			self::initialize_admin_renderers();

			// Initialize conversion system.
			self::initialize_conversion_system();

			// Initialize asset management.
			self::initialize_asset_management();

			// Initialize post edit meta box.
			self::initialize_post_meta_box();

			if ( defined( 'WP_DEBUG' ) && WP_DEBUG ) {
				accessibility_audio_tts_debug_log( 'AAT: Admin initialization completed successfully' );
			}
		} catch ( \Exception $e ) {
			self::handle_initialization_error( $e, 'admin' );
			throw $e;
		}
	}

	/**
	 * Setup WordPress specific optimizations
	 *
	 * Applies performance optimizations specific to WordPress admin area.
	 *
	 * @return void
	 */
	private static function setup_wordpress_optimizations(): void {
		if ( self::is_initialized( 'wp_optimizations' ) ) {
			return;
		}

		// Disable WordPress Heartbeat API on plugin page for performance.
		add_action(
            'admin_enqueue_scripts',
            function () {
                // Only process if we're in admin and have proper permissions.
                if ( ! is_admin() || ! current_user_can( 'manage_options' ) ) {
                    return;
                }

                // phpcs:ignore WordPress.Security.NonceVerification.Recommended -- admin_enqueue_scripts context doesn't require nonce verification
                $page = isset( $_GET['page'] ) ? sanitize_text_field( wp_unslash( $_GET['page'] ) ) : '';
                if ( 'accessibility-audio-tts-audio' === $page ) {
                    wp_deregister_script( 'heartbeat' );
                }
            },
            1
		);

		self::mark_initialized( 'wp_optimizations' );
		accessibility_audio_tts_debug_log( __( 'WordPress optimizations applied', 'accessibility-audio-tts-text-to-speech-for-articles' ) );
	}

	/**
	 * Initialize admin security
	 *
	 * Sets up secure admin class and security middleware.
	 *
	 * @throws \Exception If security initialization fails.
	 * @return void
	 */
	private static function initialize_admin_security(): void {
		if ( self::is_initialized( 'admin_security' ) ) {
			return;
		}

		accessibility_audio_tts_debug_log( __( 'Initializing admin security...', 'accessibility-audio-tts-text-to-speech-for-articles' ) );

		// SECURITY: Use secure admin class - must be instantiated immediately for menu registration.
		try {
			$admin_secure = new \Accessibility_Audio_TTS\Admin\Admin_Secure();
			self::register_instance( 'admin_secure', $admin_secure );
			if ( defined( 'WP_DEBUG' ) && WP_DEBUG ) {
				accessibility_audio_tts_debug_log( 'AAT: Admin_Secure instantiated successfully' );
			}
		} catch ( \Exception $e ) {
			if ( defined( 'WP_DEBUG' ) && WP_DEBUG ) {
				accessibility_audio_tts_debug_log( 'AAT: Failed to instantiate Admin_Secure: ' . $e->getMessage() );
				accessibility_audio_tts_debug_log( 'AAT: Stack trace: ' . $e->getTraceAsString() );
			}
			throw $e;
		}

		self::mark_initialized( 'admin_security' );
		accessibility_audio_tts_debug_log( __( 'Admin security initialized successfully', 'accessibility-audio-tts-text-to-speech-for-articles' ) );
	}

	/**
	 * Initialize admin controllers
	 *
	 * Sets up all admin controllers for different functionalities.
	 *
	 * @return void
	 */
	private static function initialize_admin_controllers(): void {
		if ( self::is_initialized( 'admin_controllers' ) ) {
			return;
		}

		accessibility_audio_tts_debug_log( __( 'Initializing admin controllers...', 'accessibility-audio-tts-text-to-speech-for-articles' ) );

		// Register controllers (lazy loaded).
		$controllers = array(
			'page_controller'       => '\\Accessibility_Audio_TTS\\Admin\\Admin_Page_Controller',
			'ajax_controller'       => '\\Accessibility_Audio_TTS\\Admin\\Admin_AJAX_Controller',
			'data_controller'       => '\\Accessibility_Audio_TTS\\Admin\\Admin_Data_Controller',
			'background_controller' => '\\Accessibility_Audio_TTS\\Admin\\Admin_Background_Controller',
			'settings_controller'   => '\\Accessibility_Audio_TTS\\Admin\\Admin_Settings_Controller',
			'posts_controller'      => '\\Accessibility_Audio_TTS\\Admin\\Admin_Posts_Controller',
			'audio_controller'      => '\\Accessibility_Audio_TTS\\Admin\\Admin_Audio_Controller',
			'debug_controller'      => '\\Accessibility_Audio_TTS\\Admin\\Admin_Debug_Controller',
		);

		foreach ( $controllers as $key => $class ) {
			self::register_component( $key, $class );
		}

		self::mark_initialized( 'admin_controllers' );
		accessibility_audio_tts_debug_log( __( 'Admin controllers initialized successfully', 'accessibility-audio-tts-text-to-speech-for-articles' ) );
	}

	/**
	 * Initialize admin renderers
	 *
	 * Sets up renderers for admin pages and components.
	 *
	 * @return void
	 */
	private static function initialize_admin_renderers(): void {
		if ( self::is_initialized( 'admin_renderers' ) ) {
			return;
		}

		accessibility_audio_tts_debug_log( __( 'Initializing admin renderers...', 'accessibility-audio-tts-text-to-speech-for-articles' ) );

		// Initialize the renderer to ensure its assets are enqueued.
		self::register_component( 'list_renderer', '\\Accessibility_Audio_TTS\\Admin\\Generated_List_Renderer' );
		self::register_component( 'page_renderer', '\\Accessibility_Audio_TTS\\Admin\\Admin_Page_Renderer' );

		self::mark_initialized( 'admin_renderers' );
		accessibility_audio_tts_debug_log( __( 'Admin renderers initialized successfully', 'accessibility-audio-tts-text-to-speech-for-articles' ) );
	}

	/**
	 * Initialize conversion system
	 *
	 * Sets up conversion manager and related components.
	 *
	 * @return void
	 */
	private static function initialize_conversion_system(): void {
		if ( self::is_initialized( 'conversion_system' ) ) {
			return;
		}

		accessibility_audio_tts_debug_log( __( 'Initializing conversion system...', 'accessibility-audio-tts-text-to-speech-for-articles' ) );

		// Initialize conversion manager.
		self::register_component( 'conversion_manager', '\\Accessibility_Audio_TTS\\Admin\\Conversion_Manager' );
		self::register_component( 'conversion_processor', '\\Accessibility_Audio_TTS\\Admin\\Conversion_Processor' );

		self::mark_initialized( 'conversion_system' );
		accessibility_audio_tts_debug_log( __( 'Conversion system initialized successfully', 'accessibility-audio-tts-text-to-speech-for-articles' ) );
	}

	/**
	 * Initialize asset management
	 *
	 * Sets up asset management system with support for new modules.
	 *
	 * @return void
	 */
	private static function initialize_asset_management(): void {
		if ( self::is_initialized( 'asset_management' ) ) {
			return;
		}

		accessibility_audio_tts_debug_log( __( 'Initializing admin asset management...', 'accessibility-audio-tts-text-to-speech-for-articles' ) );

		// Initialize asset management with support for new modules.
		self::register_component( 'asset_manager', '\\Accessibility_Audio_TTS\\Admin\\Asset_Manager' );
		self::register_component( 'frontend_asset_loader', '\\Accessibility_Audio_TTS\\Admin\\Frontend_Asset_Loader' );
		self::register_component( 'simple_admin_asset_loader', '\\Accessibility_Audio_TTS\\Admin\\Simple_Admin_Asset_Loader' );

		self::mark_initialized( 'asset_management' );
		accessibility_audio_tts_debug_log( __( 'Admin asset management initialized successfully', 'accessibility-audio-tts-text-to-speech-for-articles' ) );
	}

	/**
	 * Initialize post edit meta box
	 *
	 * Registers the audio meta box on post edit screens.
	 * Must be instantiated immediately to register WordPress hooks.
	 *
	 * @return void
	 */
	private static function initialize_post_meta_box(): void {
		if ( self::is_initialized( 'post_meta_box' ) ) {
			return;
		}

		$meta_box = new \Accessibility_Audio_TTS\Admin\Post_Edit_Meta_Box();
		self::register_instance( 'post_meta_box', $meta_box );

		self::mark_initialized( 'post_meta_box' );
	}

	/**
	 * Register component for lazy loading
	 *
	 * @param string $key Component key.
	 * @param string $class_name Class name.
	 * @param array  $args Constructor arguments.
	 * @return void
	 */
	private static function register_component( string $key, string $class_name, array $args = array() ): void {
		self::$admin_components[ $key ] = array(
			'class'    => $class_name,
			'args'     => $args,
			'instance' => null,
		);

		accessibility_audio_tts_debug_log( "Registered admin component: {$key} -> {$class_name}" );
	}

	/**
	 * Register existing instance
	 *
	 * @param string $key Component key.
	 * @param object $instance Instance.
	 * @return void
	 */
	private static function register_instance( string $key, object $instance ): void {
		self::$admin_components[ $key ] = array(
			'class'    => get_class( $instance ),
			'args'     => array(),
			'instance' => $instance,
		);

		accessibility_audio_tts_debug_log( "Registered admin instance: {$key} -> " . get_class( $instance ) );
	}

	/**
	 * Get component instance (lazy loaded)
	 *
	 * @param string      $key Component key.
	 * @param string|null $class_name Class name (if not registered).
	 * @param array       $args Constructor arguments.
	 * @throws \Exception If component not registered or class not found.
	 * @return object Component instance.
	 */
	public static function get_component( string $key, ?string $class_name = null, array $args = array() ): object {
		// If not registered and class name provided, register it.
		if ( ! isset( self::$admin_components[ $key ] ) && $class_name ) {
			self::register_component( $key, $class_name, $args );
		}

		if ( ! isset( self::$admin_components[ $key ] ) ) {
			throw new \Exception( sprintf( "Admin component '%s' not registered", esc_html( $key ) ) );
		}

		$component = &self::$admin_components[ $key ];

		// Lazy load instance.
		if ( null === $component['instance'] ) {
			if ( ! class_exists( $component['class'] ) ) {
				throw new \Exception( sprintf( "Admin component class '%s' not found", esc_html( $component['class'] ) ) );
			}

			// Handle singleton classes that have get_instance() method.
			if ( method_exists( $component['class'], 'get_instance' ) ) {
				$component['instance'] = $component['class']::get_instance();
			} else {
				// Regular class instantiation.
				$component['instance'] = empty( $component['args'] )
				? new $component['class']()
				: new $component['class']( ...$component['args'] );
			}

			accessibility_audio_tts_debug_log( "Lazy loaded admin component: {$key}" );
		}

		return $component['instance'];
	}

	/**
	 * Check if component is initialized
	 *
	 * @param string $component Component name.
	 * @return bool
	 */
	private static function is_initialized( string $component ): bool {
		return isset( self::$initialized[ $component ] );
	}

	/**
	 * Mark component as initialized
	 *
	 * @param string $component Component name.
	 * @return void
	 */
	private static function mark_initialized( string $component ): void {
		self::$initialized[ $component ] = true;
	}

	/**
	 * Handle initialization errors
	 *
	 * @param \Exception $e Exception.
	 * @param string     $area Context.
	 * @return void
	 */
	private static function handle_initialization_error( \Exception $e, string $area ): void {
		/* translators: 1: initialization area (core/admin/frontend), 2: error message */
		$msg = sprintf( __( 'CRITICAL ERROR in %1$s initialization: %2$s', 'accessibility-audio-tts-text-to-speech-for-articles' ), $area, $e->getMessage() );
		accessibility_audio_tts_error_log( $msg );
		add_action(
            'admin_notices',
            function () use ( $e, $area ) {
                /* translators: 1: plugin area, 2: error message */
                $text = sprintf( __( 'Accessibility Audio TTS %1$s Error: %2$s', 'accessibility-audio-tts-text-to-speech-for-articles' ), $area, $e->getMessage() );
                ?>
		<div class="notice notice-error">
                <p><?php echo esc_html( $text ); ?></p>
		</div>
                <?php
            }
		);
	}

	/**
	 * Get admin statistics
	 *
	 * @return array Statistics.
	 */
	public static function get_admin_stats(): array {
		$loaded_components = 0;
		foreach ( self::$admin_components as $component ) {
			if ( null !== $component['instance'] ) {
				++$loaded_components;
			}
		}

		return array(
			'registered_components' => count( self::$admin_components ),
			'loaded_components'     => $loaded_components,
			'initialized_systems'   => count( self::$initialized ),
			'systems'               => array_keys( self::$initialized ),
		);
	}

	/**
	 * Clear admin components (for testing)
	 *
	 * @return void
	 */
	public static function clear_components(): void {
		self::$admin_components = array();
		self::$initialized      = array();
		accessibility_audio_tts_debug_log( 'Admin initializer components cleared' );
	}
}