<?php
// Exit if accessed directly
if ( ! defined( 'ABSPATH' ) ) {
    exit;
}

/**
 * Extension Interface Class
 * 
 * Handles communication between the main plugin and premium extensions
 *
 * @since      1.0.0
 */

/**
 * Extension Interface Class
 *
 * This class provides the interface for premium extensions to register
 * with the main plugin and extend its functionality.
 */
class ACTLOGPRO_Extension_Interface {

    /**
     * Registered extensions
     *
     * @since    1.0.0
     * @access   private
     * @var      array    $extensions    Array of registered extensions
     */
    private static $extensions = array();

    /**
     * Registered premium features
     *
     * @since    1.0.0
     * @access   private
     * @var      array    $premium_features    Array of registered premium features
     */
    private static $premium_features = array();

    /**
     * Initialize the extension interface
     *
     * @since    1.0.0
     */
    public static function init() {
        // Hook for extensions to register themselves
        add_action('plugins_loaded', array(__CLASS__, 'load_extensions'), 15);
        
        // Allow extensions to register features
        do_action('actlogpro_extension_interface_loaded');
    }

    /**
     * Register an extension
     *
     * @since    1.0.0
     * @param    string    $extension_id      Unique extension identifier
     * @param    string    $extension_name    Human readable extension name
     * @param    string    $extension_version Extension version
     * @param    array     $capabilities      Extension capabilities
     * @return   bool      True if registered successfully
     */
    public static function register_extension($extension_id, $extension_name, $extension_version, $capabilities = array()) {
        if (isset(self::$extensions[$extension_id])) {
            return false; // Extension already registered
        }

        self::$extensions[$extension_id] = array(
            'id' => $extension_id,
            'name' => $extension_name,
            'version' => $extension_version,
            'capabilities' => $capabilities,
            'registered_at' => current_time('timestamp')
        );

        // Note: Extension registration is an internal system event that happens on every request
        // No need to log this as it would create excessive log entries

        return true;
    }

    /**
     * Register a premium feature
     *
     * @since    1.0.0
     * @param    string    $feature_id       Unique feature identifier
     * @param    string    $feature_name     Human readable feature name
     * @param    string    $extension_id     Extension that provides this feature
     * @param    callable  $init_callback    Callback to initialize the feature
     * @return   bool      True if registered successfully
     */
    public static function register_premium_feature($feature_id, $feature_name, $extension_id, $init_callback = null) {
        // Determine initial enabled status based on active integrations setting
        $enabled = true; // Default to enabled
        
        // For integration features, check the actlogpro_active_integrations setting
        if (preg_match('/^(\w+)_integration$/', $feature_id, $matches)) {
            $integration_id = $matches[1];
            $active_integrations = get_option('actlogpro_active_integrations', array());
            $enabled = in_array($integration_id, $active_integrations);
            
            
        }

        // If feature is already registered, update its enabled status
        if (isset(self::$premium_features[$feature_id])) {
            $old_enabled = self::$premium_features[$feature_id]['enabled'];
            self::$premium_features[$feature_id]['enabled'] = $enabled;
            
            // If status changed from disabled to enabled, initialize the feature
            if (!$old_enabled && $enabled && is_callable($init_callback)) {
                call_user_func($init_callback);
            }
            
            return true; // Status updated successfully
        }

        self::$premium_features[$feature_id] = array(
            'id' => $feature_id,
            'name' => $feature_name,
            'extension_id' => $extension_id,
            'init_callback' => $init_callback,
            'enabled' => $enabled
        );

        // Initialize the feature if callback provided and feature is enabled (only on first registration)
        if ($enabled && is_callable($init_callback)) {
            call_user_func($init_callback);
        }

        return true;
    }

    /**
     * Check if an extension is registered
     *
     * @since    1.0.0
     * @param    string    $extension_id    Extension identifier
     * @return   bool      True if extension is registered
     */
    public static function is_extension_registered($extension_id) {
        return isset(self::$extensions[$extension_id]);
    }

    /**
     * Check if a premium feature is available
     *
     * @since    1.0.0
     * @param    string    $feature_id    Feature identifier
     * @return   bool      True if feature is available
     */
    public static function is_premium_feature_available($feature_id) {
        $available = isset(self::$premium_features[$feature_id]) && self::$premium_features[$feature_id]['enabled'];
        

        
        return $available;
    }

    /**
     * Get all registered extensions
     *
     * @since    1.0.0
     * @return   array    Array of registered extensions
     */
    public static function get_extensions() {
        return self::$extensions;
    }

    /**
     * Get all registered premium features
     *
     * @since    1.0.0
     * @return   array    Array of registered premium features
     */
    public static function get_premium_features() {
        return self::$premium_features;
    }

    /**
     * Load extensions - called on plugins_loaded
     *
     * @since    1.0.0
     */
    public static function load_extensions() {
        // Prevent multiple loading on the same request
        static $loaded = false;
        if ($loaded) {
            return;
        }
        
        // Fire action for extensions to register themselves
        do_action('actlogpro_register_extensions');
        
        // Fire action for premium features to register
        do_action('actlogpro_register_premium_features');
        
        // Fire action after all extensions are loaded
        do_action('actlogpro_extensions_loaded');
        
        $loaded = true;
    }

    /**
     * Unregister an extension
     *
     * @since    1.0.0
     * @param    string    $extension_id    Extension identifier
     * @return   bool      True if unregistered successfully
     */
    public static function unregister_extension($extension_id) {
        if (!isset(self::$extensions[$extension_id])) {
            return false;
        }

        // Remove all features provided by this extension
        foreach (self::$premium_features as $feature_id => $feature) {
            if ($feature['extension_id'] === $extension_id) {
                unset(self::$premium_features[$feature_id]);
            }
        }

        unset(self::$extensions[$extension_id]);

        // Note: Extension unregistration is an internal system event
        // No need to log this as it would create excessive log entries

        return true;
    }

    /**
     * Enable or disable a premium feature
     *
     * @since    1.0.0
     * @param    string    $feature_id    Feature identifier
     * @param    bool      $enabled       Whether to enable the feature
     * @return   bool      True if successful
     */
    public static function set_premium_feature_status($feature_id, $enabled) {
        if (!isset(self::$premium_features[$feature_id])) {
            return false;
        }

        self::$premium_features[$feature_id]['enabled'] = (bool) $enabled;
        return true;
    }

    /**
     * Manually initialize a premium feature if it exists and is enabled
     *
     * @since    1.0.0
     * @param    string    $feature_id    Feature identifier
     * @return   bool      True if feature was initialized
     */
    public static function initialize_premium_feature($feature_id) {
        if (!isset(self::$premium_features[$feature_id])) {
            return false;
        }

        $feature = self::$premium_features[$feature_id];
        
        // Only initialize if enabled and has callback
        if ($feature['enabled'] && is_callable($feature['init_callback'])) {
            call_user_func($feature['init_callback']);
            return true;
        }

        return false;
    }
}