<?php
/**
 * WordPress Mock for Testing
 *
 * @package CareBook\Ultimate\Tests\Mocks
 * @since 1.0.0
 */

declare(strict_types=1);

namespace CareBook\Ultimate\Tests\Mocks;

/**
 * WordPressMock class
 * 
 * Provides mock implementations of WordPress functions for testing
 * 
 * @since 1.0.0
 */
class WordPressMock
{
    /**
     * Storage for actions and hooks
     * 
     * @var array<string, array<callable>>
     */
    private static array $actions = [];
    
    /**
     * Storage for filters
     * 
     * @var array<string, array<callable>>
     */
    private static array $filters = [];
    
    /**
     * Storage for transients
     * 
     * @var array<string, mixed>
     */
    private static array $transients = [];
    
    /**
     * Storage for options
     * 
     * @var array<string, mixed>
     */
    private static array $options = [];
    
    /**
     * Current user capabilities
     * 
     * @var array<string, bool>
     */
    private static array $userCaps = [
        'manage_options' => true,
        'edit_posts' => true,
    ];
    
    /**
     * Current user ID
     * 
     * @var int
     */
    private static int $userId = 1;
    
    /**
     * Reset all mock data
     * 
     * @return void
     * @since 1.0.0
     */
    public static function reset(): void
    {
        self::$actions = [];
        self::$filters = [];
        self::$transients = [];
        self::$options = [];
        self::$userCaps = [
            'manage_options' => true,
            'edit_posts' => true,
        ];
        self::$userId = 1;
    }
    
    /**
     * Mock add_action
     * 
     * @param string $hook
     * @param callable $callback
     * @param int $priority
     * @param int $args
     * @return bool
     * @since 1.0.0
     */
    public static function add_action(string $hook, callable $callback, int $priority = 10, int $args = 1): bool
    {
        if (!isset(self::$actions[$hook])) {
            self::$actions[$hook] = [];
        }
        
        self::$actions[$hook][] = [
            'callback' => $callback,
            'priority' => $priority,
            'args' => $args
        ];
        
        return true;
    }
    
    /**
     * Mock do_action
     * 
     * @param string $hook
     * @param mixed ...$args
     * @return void
     * @since 1.0.0
     */
    public static function do_action(string $hook, ...$args): void
    {
        if (isset(self::$actions[$hook])) {
            foreach (self::$actions[$hook] as $action) {
                call_user_func_array($action['callback'], $args);
            }
        }
    }
    
    /**
     * Mock add_filter
     * 
     * @param string $hook
     * @param callable $callback
     * @param int $priority
     * @param int $args
     * @return bool
     * @since 1.0.0
     */
    public static function add_filter(string $hook, callable $callback, int $priority = 10, int $args = 1): bool
    {
        if (!isset(self::$filters[$hook])) {
            self::$filters[$hook] = [];
        }
        
        self::$filters[$hook][] = [
            'callback' => $callback,
            'priority' => $priority,
            'args' => $args
        ];
        
        return true;
    }
    
    /**
     * Mock apply_filters
     * 
     * @param string $hook
     * @param mixed $value
     * @param mixed ...$args
     * @return mixed
     * @since 1.0.0
     */
    public static function apply_filters(string $hook, mixed $value, ...$args): mixed
    {
        if (isset(self::$filters[$hook])) {
            foreach (self::$filters[$hook] as $filter) {
                $value = call_user_func_array($filter['callback'], array_merge([$value], $args));
            }
        }
        
        return $value;
    }
    
    /**
     * Mock get_transient
     * 
     * @param string $key
     * @return mixed
     * @since 1.0.0
     */
    public static function get_transient(string $key): mixed
    {
        return self::$transients[$key] ?? false;
    }
    
    /**
     * Mock set_transient
     * 
     * @param string $key
     * @param mixed $value
     * @param int $expiration
     * @return bool
     * @since 1.0.0
     */
    public static function set_transient(string $key, mixed $value, int $expiration = 0): bool
    {
        self::$transients[$key] = $value;
        return true;
    }
    
    /**
     * Mock delete_transient
     * 
     * @param string $key
     * @return bool
     * @since 1.0.0
     */
    public static function delete_transient(string $key): bool
    {
        unset(self::$transients[$key]);
        return true;
    }
    
    /**
     * Mock get_option
     * 
     * @param string $key
     * @param mixed $default
     * @return mixed
     * @since 1.0.0
     */
    public static function get_option(string $key, mixed $default = false): mixed
    {
        return self::$options[$key] ?? $default;
    }
    
    /**
     * Mock update_option
     * 
     * @param string $key
     * @param mixed $value
     * @return bool
     * @since 1.0.0
     */
    public static function update_option(string $key, mixed $value): bool
    {
        self::$options[$key] = $value;
        return true;
    }
    
    /**
     * Mock current_user_can
     * 
     * @param string $capability
     * @return bool
     * @since 1.0.0
     */
    public static function current_user_can(string $capability): bool
    {
        return self::$userCaps[$capability] ?? false;
    }
    
    /**
     * Mock get_current_user_id
     * 
     * @return int
     * @since 1.0.0
     */
    public static function get_current_user_id(): int
    {
        return self::$userId;
    }
    
    /**
     * Set user capabilities for testing
     * 
     * @param array<string, bool> $caps
     * @return void
     * @since 1.0.0
     */
    public static function setUserCapabilities(array $caps): void
    {
        self::$userCaps = $caps;
    }
    
    /**
     * Set current user ID for testing
     * 
     * @param int $userId
     * @return void
     * @since 1.0.0
     */
    public static function setUserId(int $userId): void
    {
        self::$userId = $userId;
    }
    
    /**
     * Get registered actions for testing verification
     * 
     * @param string|null $hook
     * @return array
     * @since 1.0.0
     */
    public static function getActions(?string $hook = null): array
    {
        return $hook ? (self::$actions[$hook] ?? []) : self::$actions;
    }
    
    /**
     * Get registered filters for testing verification
     * 
     * @param string|null $hook
     * @return array
     * @since 1.0.0
     */
    public static function getFilters(?string $hook = null): array
    {
        return $hook ? (self::$filters[$hook] ?? []) : self::$filters;
    }
    
    /**
     * Mock wp_verify_nonce
     * 
     * @param string|null $nonce
     * @param string $action
     * @return bool
     * @since 1.0.0
     */
    public static function wp_verify_nonce(?string $nonce, string $action): bool
    {
        return !empty($nonce);
    }
    
    /**
     * Mock wp_create_nonce
     * 
     * @param string $action
     * @return string
     * @since 1.0.0
     */
    public static function wp_create_nonce(string $action): string
    {
        return hash('sha256', $action . time());
    }
    
    /**
     * Mock sanitize_text_field
     * 
     * @param string $str
     * @return string
     * @since 1.0.0
     */
    public static function sanitize_text_field(string $str): string
    {
        return trim(strip_tags($str));
    }
    
    /**
     * Mock esc_html
     * 
     * @param string $text
     * @return string
     * @since 1.0.0
     */
    public static function esc_html(string $text): string
    {
        return htmlspecialchars($text, ENT_QUOTES | ENT_HTML5, 'UTF-8');
    }
    
    /**
     * Mock wp_die
     * 
     * @param string $message
     * @param string $title
     * @param array $args
     * @throws \Exception
     * @return never
     * @since 1.0.0
     */
    public static function wp_die(string $message = '', string $title = '', array $args = []): never
    {
        throw new \Exception("wp_die called: {$message}");
    }
}