<?php
/*
 * Plugin name: Batcache Manager
 * Plugin URI: http://www.github.com/spacedmonkey/batcache-manager
 * Description: Cache clearing for batcache
 * Author: Jonathan Harris
 * Author URI: http://www.jonathandavidharris.co.uk
 * Version: 2.0.2
*/

/**
 * Class Batcache_Manager
 */
class Batcache_Manager {

    /**
     * List of feeds
     *
     * @since    2.0.0
     *
     * @var array
     */
    private $feeds = array( 'rss', 'rss2', 'rdf', 'atom' );

    /**
     * List of links to process
     *
     * @since    2.0.0
     *
     * @var array
     */
    private $links = array();

    /**
     * Instance of this class.
     *
     * @since    2.0.0
     *
     * @var      object
     */
    protected static $instance = null;

    /**
     *
     */
    private function __construct() {

        global $batcache, $wp_object_cache;

        // Do not load if our advanced-cache.php isn't loaded
        if ( ! isset( $batcache ) || ! is_object( $batcache ) || ! method_exists( $wp_object_cache, 'incr' ) ) {
            return;
        }

        $batcache->configure_groups();

        // Posts
        add_action( 'clean_post_cache', array( $this, 'action_clean_post_cache' ), 15 );
        // Terms
        add_action( 'clean_term_cache', array( $this, 'action_clean_term_cache' ), 10, 3 );
        //Comments
        add_action( 'clean_comment_cache', array( $this, 'action_update_comment' ) ); // Only supported in 4.5
        add_action( 'comment_post', array( $this, 'action_update_comment' ) );
        add_action( 'wp_set_comment_status', array( $this, 'action_update_comment' ) );
        add_action( 'edit_comment', array( $this, 'action_update_comment' ) );
        // Users
        add_action( 'clean_user_cache', array( $this, 'action_update_user' ) );
        add_action( 'profile_update', array( $this, 'action_update_user' ) );
        // Widgets
        add_filter( 'widget_update_callback', array( $this, 'action_update_widget' ), 50 );
        // Customiser
        add_action( 'customize_save_after', array( $this, 'flush_all' ) );
        // Theme
        add_action( 'switch_theme', array( $this, 'flush_all' ) );
        // Nav
        add_action( 'wp_update_nav_menu', array( $this, 'flush_all' ) );

        // Add site aliases to list of links
        add_filter( 'batcache_manager_links', array( $this, 'add_site_alias' ) );

        // Do the flush of the urls on shutdown
        add_action( 'shutdown', array( $this, 'clear_urls' ) );
    }

    /**
     * Return an instance of this class.
     *
     * @since     2.0.0
     *
     * @return    object    A single instance of this class.
     */
    public static function get_instance() {
        // If the single instance hasn't been set, set it now.
        if ( null == self::$instance ) {
            self::$instance = new self;
        }

        return self::$instance;
    }

    /**
     * Determines whether a post type is considered "viewable".
     *
     * For built-in post types such as posts and pages, the 'public' value will be evaluated.
     * For all others, the 'publicly_queryable' value will be used.
     *
     *
     * @param string $post_type Post type.
     *
     * @return bool Whether the post type should be considered viewable.
     */
    public function is_post_type_viewable( $post_type ) {
        $post_type_object = get_post_type_object( $post_type );
        if ( empty( $post_type_object ) ) {
            return false;
        }

        return $post_type_object->publicly_queryable || ( $post_type_object->_builtin && $post_type_object->public );
    }

    /**
     * Whether the taxonomy object is public.
     *
     * Checks to make sure that the taxonomy is an object first. Then Gets the
     * object, and finally returns the public value in the object.
     *
     * A false return value might also mean that the taxonomy does not exist.
     *
     * @since 2.0.0
     *
     * @param string $taxonomy Name of taxonomy object.
     *
     * @return bool Whether the taxonomy is public.
     */
    function is_taxonomy_viewable( $taxonomy ) {
        if ( ! taxonomy_exists( $taxonomy ) ) {
            return false;
        }

        $taxonomy = get_taxonomy( $taxonomy );

        return $taxonomy->public;
    }

    /**
     * Clear post on post update
     *
     * @param $post_id
     */
    public function action_clean_post_cache( $post_id ) {

        $post = get_post( $post_id );
        if ( $post && $post->post_type && ! $this->is_post_type_viewable( $post->post_type ) || ! in_array( get_post_status( $post_id ), array( 'publish', 'trash' ) ) ) {
            return;
        }

        // Only flush the permalink of the specific post that changed.
        // Date archives, author archives, feeds, and the homepage are intentionally
        // NOT flushed here — those shared URLs should only be invalidated on a
        // full manual flush, not on every individual page save.
        $permalink = get_permalink( $post );
        if ( ! empty( $permalink ) ) {
            $this->links[] = $permalink;
        }

        // --- START OF MODIFIED CODE ---

        // Check if the updated post is a WooCommerce product
        if ( 'product' === $post->post_type ) {
            $product_url = get_permalink( $post );

            // 1. Flush the specific product URL (Batcache)
            self::clear_url( $product_url );

            // 2. Store the product URL in the option table
            update_option( 'edge-cache-single-page-url-purged', $product_url );

            // 3. Purge Edge Cache for the specific URL
            if (class_exists('Edge_Cache_Plugin')) {
                // Set the default timezone to UTC before calling date()
                $timezone_backup = date_default_timezone_get();
                date_default_timezone_set('UTC');

                $edge_cache = Edge_Cache_Plugin::get_instance();
                $urls = array($product_url);
                
                // Use the correct method to purge URIs
                $result = $edge_cache->purge_uris_now($urls);
                    
                // Save time stamp to database if edge cache is purged for particular page
                $edge_cache_purge_time = date('jS F Y g:ia') . "\nUTC";
                update_option('single-page-edge-cache-purge-time-stamp', $edge_cache_purge_time);

                // Restore the original timezone
                date_default_timezone_set($timezone_backup);
            }
        }

        // --- END OF MODIFIED CODE ---
    }

    /**
     * Clear terms on term update
     *
     * @param array $ids Single or list of Term IDs.
     * @param string $taxonomy
     * @param bool $clean_taxonomy Optional. Whether to clean taxonomy wide caches (true), or just individual
     * term object caches (false). Default true. Only support in WP 4.5
     */
    public function action_clean_term_cache( $ids, $taxonomy, $clean_taxonomy = true ) {
        // Clear taxonomy global caches. If false, lets not both.
        if ( ! $clean_taxonomy ) {
            return;
        }
        // If not a public taxonomy, don't clear caches.
        if ( ! $this->is_taxonomy_viewable( $taxonomy ) ) {
            return;
        }

        foreach ( $ids as $term ) {
            $this->setup_term_urls( $term, $taxonomy );
        }
    }

    /**
     * Clear post page on comment update
     *
     * @param $comment_id
     */
    public function action_update_comment( $comment_id ) {
        $comment = get_comment( $comment_id );
        $post_id = $comment->comment_post_ID;
        $this->setup_post_urls( $post_id );
        $this->setup_post_comment_urls( $post_id, $comment_id );
    }

    /**
     * Clear author links on update user.
     *
     * @param $user_id
     */
    public function action_update_user( $user_id ) {
        $this->setup_author_urls( $user_id );
    }

    public function flush_all() {
        if ( function_exists( 'batcache_flush_all' ) ) {
            batcache_flush_all();
        }
    }

    /**
     * Flush all of the caches when a widget is updated.
     *
     * @param  array $instance The current widget instance's settings.
     *
     * @return array $instance
     */
    public function action_update_widget( $instance ) {
        $this->flush_all();

        return $instance;
    }

    /**
     * Get term archive and feed links for each term
     *
     * @param $term
     * @param $taxonomy
     */
    public function setup_term_urls( $term, $taxonomy ) {

        $term_link = get_term_link( $term, $taxonomy );
        if ( ! is_wp_error( $term_link ) ) {
            $this->links[] = $term_link;
        }
        foreach ( $this->feeds as $feed ) {
            $term_link_feed = get_term_feed_link( $term, $taxonomy, $feed );
            if ( $term_link_feed ) {
                $this->links[] = $term_link_feed;
            }
        }

        $taxonomy_object = get_taxonomy( $taxonomy );
        if ( $taxonomy_object->show_in_rest && $taxonomy_object->rest_base ) {
            $base = $taxonomy_object->rest_base;
            $this->links[] = get_rest_url( null, '/wp/v2/' . $base );
            $this->links[] = get_rest_url( null, '/wp/v2/' . $base . '/'. $term );
        }

    }

    /**
     * Home page / blog page and feed links
     */
    public function setup_site_urls() {
        if ( get_option( 'show_on_front' ) == 'page' ) {
            $this->links[] = get_permalink( get_option( 'page_for_posts' ) );
        }

        $this->links[] = home_url( '/' );

        foreach ( $this->feeds as $feed ) {
            $this->links[] = get_feed_link( $feed );
        }
    }

    /**
     * Get permalink, date archives and custom post type links
     *
     * @param $post
     */
    public function setup_post_urls( $post ) {
        $post = get_post( $post );

        $this->links[] = get_permalink( $post );
        if ( $post->post_type == 'post' ) {
            $year          = get_the_time( "Y", $post );
            $month         = get_the_time( "m", $post );
            $day           = get_the_time( "d", $post );
            $this->links[] = get_year_link( $year );
            $this->links[] = get_month_link( $year, $month );
            $this->links[] = get_day_link( $year, $month, $day );
        } else if ( ! in_array( $post->post_type, get_post_types( array( 'public' => true ) ) ) ) {
            if ( $archive_link = get_post_type_archive_link( $post->post_type ) ) {
                $this->links[] = $archive_link;
            }
            foreach ( $this->feeds as $feed ) {
                if ( $archive_link_feed = get_post_type_archive_feed_link( $post->post_type, $feed ) ) {
                    $this->links[] = $archive_link_feed;
                }
            }
        }
        $post_type = get_post_type_object( $post->post_type );
        if ( $post_type->show_in_rest && $post_type->rest_base ) {
            $base = $post_type->rest_base;
            $this->links[] = get_rest_url( null, '/wp/v2/' . $base );
            $this->links[] = get_rest_url( null, '/wp/v2/' . $base . '/'. $post->ID );
        }
    }

    /**
     * Author profile and feed links
     *
     * @param $author_id
     */
    public function setup_author_urls( $author_id ) {
        $this->links[] = get_author_posts_url( $author_id );
        foreach ( $this->feeds as $feed ) {
            $this->links[] = get_author_feed_link( $author_id, $feed );
        }
        $this->links[] = get_rest_url( null, '/wp/v2/users' );
        $this->links[] = get_rest_url( null, '/wp/v2/users/' . $author_id );
    }

    /**
     * Get feed urls for comments for single posts
     *
     * @param $post_id
     */
    public function setup_post_comment_urls( $post_id, $comment_id = 0 ) {
        foreach ( $this->feeds as $feed ) {
            $this->links[] = get_post_comments_feed_link( $post_id, $feed );
        }

        foreach ( $this->feeds as $feed ) {
            $this->links[] = get_feed_link( "comments_" . $feed );
        }
        $this->links[] = get_rest_url( null, '/wp/v2/comments' );
        $this->links[] = get_rest_url( null, '/wp/v2/comments/' . $comment_id );
    }


    /**
     * Work around for those using Domain mapping or have CMS on different url.
     *
     * @param $links
     */
    public function add_site_alias( $links ) {
        $home = parse_url( home_url(), PHP_URL_HOST );

        $compare_urls = array(
            parse_url( get_option( 'home' ), PHP_URL_HOST ),
            parse_url( get_option( 'siteurl' ), PHP_URL_HOST ),
            parse_url( site_url(), PHP_URL_HOST )
        );

        // Compare home, site urls with filtered home url
        foreach ( $compare_urls as $compare_url ) {
            if ( $compare_url != $home ) {
                foreach ( $links as $url ) {
                    $links[] = str_replace( $home, $compare_url, $url );
                }
            }
        }

        return $links;
    }

    /**
     * Loop around all urls and clear
     */
    public function clear_urls() {
        if ( empty ( $this->get_links() ) ) {
            return;
        }

        foreach ( $this->get_links() as $url ) {
            self::clear_url( $url );
        }
        // Clear out links
        $this->links = array();

        // --- START OF MODIFIED CODE ---

        // Set the default timezone to UTC before calling date()
        $timezone_backup = date_default_timezone_get();
        date_default_timezone_set('UTC');

        // Update the timestamp option with the specified format
        $batcache_flush_time = date('jS F Y g:ia') . "\nUTC";
        update_option( 'flush-object-cache-for-single-page-time-stamp', $batcache_flush_time );

        // Restore the original timezone
        date_default_timezone_set($timezone_backup);

        // --- END OF MODIFIED CODE ---
    }

    /**
     *
     * @param $url
     *
     * @return bool|false|int
     */
    public static function clear_url( $url ) {
        global $batcache, $wp_object_cache;

        $url = apply_filters( 'batcache_manager_link', $url );

        if ( empty( $url ) ) {
            return false;
        }

        do_action( 'batcache_manager_before_flush', $url );

        // Force to http
        $url = set_url_scheme( $url, 'http' );

        $url_key = md5( $url );

        wp_cache_add( "{$url_key}_version", 0, $batcache->group );
        $retval = wp_cache_incr( "{$url_key}_version", 1, $batcache->group );

        // $batcache_no_remote_group_key = array_search( $batcache->group, (array) $wp_object_cache->no_remote_groups );
        $batcache_no_remote_group_key = property_exists($wp_object_cache, 'no_remote_groups') ? array_search( $batcache->group, (array) $wp_object_cache->no_remote_groups ) : false;

        if ( false !== $batcache_no_remote_group_key ) {
            // The *_version key needs to be replicated remotely, otherwise invalidation won't work.
            // The race condition here should be acceptable.
            unset( $wp_object_cache->no_remote_groups[ $batcache_no_remote_group_key ] );
            $retval                                                             = wp_cache_set( "{$url_key}_version", $retval, $batcache->group );
            $wp_object_cache->no_remote_groups[ $batcache_no_remote_group_key ] = $batcache->group;
        }

        do_action( 'batcache_manager_after_flush', $url, $retval );

        return $retval;
    }

    /**
     * Filter links
     *
     * @return array
     */
    public function get_links() {
        $this->links = apply_filters( 'batcache_manager_links', $this->links );

        return array_unique( $this->links );
    }

}

global $batcache_manager;

$batcache_manager = Batcache_Manager::get_instance();