<?php

declare(strict_types=1);

namespace Agent001\Frontend;

\defined( 'ABSPATH' ) || exit;

use Agent001\Admin\Onboarding;
use Agent001\Config\Settings;

final class CachePurger
{
    private const WIDGET_SETTINGS = [ 'selected_agent_ids', 'selected_agent_embed_token', 'selected_agent_active' ];

    private const PURGE_FUNCTIONS = [
        'rocket_clean_domain',
        'w3tc_flush_all',
        'wp_cache_clear_cache',
        'sg_cachepress_purge_cache',
        'wpo_cache_flush',
        'wpfc_clear_all_cache',
        'pantheon_wp_clear_edge_all',
        'spinupwp_purge_site',
    ];

    private const PURGE_STATIC_METHODS = [
        [ 'Cache_Enabler', 'clear_total_cache' ],
        [ 'comet_cache', 'clear' ],
        [ 'Swift_Performance_Cache', 'clear_all_cache' ],
        [ 'Cachify', 'flush_total_cache' ],
        [ 'WpeCommon', 'purge_memcached' ],
        [ 'WpeCommon', 'purge_varnish_cache' ],
    ];

    private const PURGE_ACTIONS = [
        'litespeed_purge_all',
        'breeze_clear_all_cache',
        'wphb_clear_page_cache',
        'rt_nginx_helper_purge_all',
        'swcfpc_purge_cache',
        'warpdrive_domain_flush',
        'agent001_purge_cache',
    ];

    private static bool $scheduled = false;

    public function register(): void
    {
        \add_action( 'update_option_' . Settings::OPTION_NAME, [ $this, 'onSettingsUpdated' ], 10, 2 );
        \add_action( 'update_option_' . Onboarding::OPTION, [ $this, 'onOnboardingUpdated' ], 10, 2 );
    }

    /**
     * @param mixed $old
     * @param mixed $new
     */
    public function onSettingsUpdated( $old, $new ): void
    {
        if ( \get_option( Onboarding::OPTION, '' ) !== 'complete' ) {
            return;
        }

        if ( self::widgetChanged( is_array( $old ) ? $old : [], is_array( $new ) ? $new : [] ) ) {
            self::purgeAll();
        }
    }

    /**
     * @param mixed $old
     * @param mixed $new
     */
    public function onOnboardingUpdated( $old, $new ): void
    {
        if ( ( $old === 'complete' ) !== ( $new === 'complete' ) ) {
            self::purgeAll();
        }
    }

    public static function widgetChanged( array $old, array $new ): bool
    {
        $old = array_merge( Settings::DEFAULTS, $old );
        $new = array_merge( Settings::DEFAULTS, $new );

        foreach ( self::WIDGET_SETTINGS as $key ) {
            if ( $old[ $key ] !== $new[ $key ] ) {
                return true;
            }
        }

        return $old['widget_key'] !== '' && $old['widget_key'] !== $new['widget_key'];
    }

    public static function purgeAll(): void
    {
        if ( self::$scheduled ) {
            return;
        }
        self::$scheduled = true;

        \add_action( 'shutdown', [ self::class, 'purgeNow' ], 0 );
    }

    public static function purgeNow(): void
    {
        foreach ( self::PURGE_FUNCTIONS as $function ) {
            if ( \function_exists( $function ) ) {
                self::attempt( $function );
            }
        }

        foreach ( self::PURGE_STATIC_METHODS as $method ) {
            if ( self::isStaticMethod( $method[0], $method[1] ) ) {
                self::attempt( $method );
            }
        }

        if ( self::isStaticMethod( 'VarnishPurger', 'purge_url' ) && self::isStaticMethod( 'VarnishPurger', 'the_home_url' ) ) {
            self::attempt(
                static function (): void {
                    \call_user_func( [ 'VarnishPurger', 'purge_url' ], \call_user_func( [ 'VarnishPurger', 'the_home_url' ] ) . '/?vhp-regex' );
                }
            );
        }

        $cloudflare = $GLOBALS['cloudflareHooks'] ?? null;
        if ( is_object( $cloudflare ) && \method_exists( $cloudflare, 'purgeCacheEverything' ) ) {
            self::attempt( [ $cloudflare, 'purgeCacheEverything' ] );
        }

        $kinsta = $GLOBALS['kinsta_cache']->kinsta_cache_purge ?? null;
        if ( is_object( $kinsta ) && \method_exists( $kinsta, 'purge_complete_caches' ) ) {
            self::attempt( [ $kinsta, 'purge_complete_caches' ] );
        }

        if ( \defined( 'IS_PRESSABLE' ) || \defined( 'WPCOMSH_VERSION' ) ) {
            self::attempt( 'wp_cache_flush' );
        }

        if ( isset( $_SERVER['X-LSCACHE'] ) && ! \headers_sent() ) {
            \header( 'X-LiteSpeed-Purge: *', false );
        }

        foreach ( self::PURGE_ACTIONS as $hook ) {
            self::attempt(
                static function () use ( $hook ): void {
                    \do_action( $hook );
                }
            );
        }
    }

    private static function isStaticMethod( string $class, string $method ): bool
    {
        if ( ! \class_exists( $class ) || ! \method_exists( $class, $method ) ) {
            return false;
        }

        return ( new \ReflectionMethod( $class, $method ) )->isStatic();
    }

    private static function attempt( callable $purge ): void
    {
        try {
            $purge();
        } catch ( \Throwable $e ) {
            return;
        }
    }
}