<?php
/**
 * Keeps paid content out of the places where WordPress shows a post's text or files without
 * drawing the page: the site search (it matches the raw post content, so a hidden code could be
 * guessed letter by letter) and the media library's public listings of files put into a paid part.
 *
 * @package CryptowayButton
 */

namespace CryptowayButton;

defined( 'ABSPATH' ) || exit;

final class PaidContent {

    /** The searchable copy of a post's content: the same text with its paid parts left out. */
    public const META_PUBLIC = '_cryptoway_button_public_content';

    /** Ids of the media files a post's paid parts show. */
    public const META_MEDIA = '_cryptoway_button_paid_media';

    /** 'yes' once any post has paid content: until then the search is left alone. */
    public const FLAG = 'cryptoway_button_has_paid';

    /** Media files shown in paid parts, of every post: attachment id => post id. */
    public const MEDIA_OPTION = 'cryptoway_button_paid_media';

    /** Done once the posts that existed before this version were indexed. */
    public const SCAN_OPTION = 'cryptoway_button_paid_scan';

    /** Block attributes that name a media file, per block. */
    private const MEDIA_ATTRS = [
        'core/image'      => [ 'id' ],
        'core/file'       => [ 'id' ],
        'core/video'      => [ 'id' ],
        'core/audio'      => [ 'id' ],
        'core/cover'      => [ 'id' ],
        'core/media-text' => [ 'mediaId' ],
        'core/gallery'    => [ 'ids' ],
    ];

    private function __construct() {}

    public static function register(): void {
        add_action( 'wp_after_insert_post', [ self::class, 'index_post' ], 10, 2 );
        add_action( 'deleted_post', [ self::class, 'forget_post' ] );
        add_filter( 'posts_search', [ self::class, 'search' ] );
        add_filter( 'rest_attachment_query', [ self::class, 'media_query' ] );
        add_filter( 'rest_request_before_callbacks', [ self::class, 'media_item' ], 10, 3 );
        add_action( 'template_redirect', [ self::class, 'attachment_page' ], 1 );
        add_action( 'admin_init', [ self::class, 'scan_existing' ] );
        add_filter( 'enclosure_links', [ self::class, 'enclosure_links' ], 10, 2 );
        add_filter( 'rss_enclosure', [ self::class, 'feed_enclosure' ] );
        add_filter( 'atom_enclosure', [ self::class, 'feed_enclosure' ] );
        add_filter( 'render_block_core/latest-posts', [ self::class, 'latest_posts' ] );
        add_filter( 'oembed_request_post_id', [ self::class, 'oembed_post_id' ] );
    }

    // ------------------------------------------------------------------ the index

    /** Keep the searchable copy and the paid media of a saved post up to date. */
    public static function index_post( $post_id, $post ): void {
        if ( ! $post instanceof \WP_Post || wp_is_post_revision( $post ) || wp_is_post_autosave( $post ) ) {
            return;
        }

        $content = (string) $post->post_content;
        $public  = self::public_copy( $content );
        $media   = null === $public ? [] : self::paid_media( $content );

        if ( null === $public ) {
            delete_post_meta( (int) $post_id, self::META_PUBLIC );
            delete_post_meta( (int) $post_id, self::META_MEDIA );
        } else {
            // Meta values are unslashed on the way in.
            update_post_meta( (int) $post_id, self::META_PUBLIC, wp_slash( $public ) );
            update_post_meta( (int) $post_id, self::META_MEDIA, $media );

            if ( 'yes' !== get_option( self::FLAG ) ) {
                update_option( self::FLAG, 'yes', true );
            }
        }

        self::set_media_of( (int) $post_id, $media );
    }

    public static function forget_post( $post_id ): void {
        self::set_media_of( (int) $post_id, [] );
    }

    /**
     * The media files of a paid part drawn outside post content (a template part, a widget), kept
     * under the button's key while Button::remember_paid() keeps the part itself; null forgets them.
     *
     * @param array{kind: string, raw: string}|null $paid
     */
    public static function remember_media( string $key, ?array $paid ): void {
        $ids = [];

        if ( null !== $paid ) {
            $raw = (string) ( $paid['raw'] ?? '' );

            if ( 'blocks' === ( $paid['kind'] ?? '' ) ) {
                self::collect_media( parse_blocks( $raw ), true, $ids );
            } elseif ( preg_match_all( '/wp-image-(\d+)|attachment_id=(\d+)|\bids="([\d,\s]+)"/', $raw, $found, PREG_SET_ORDER ) ) {
                foreach ( $found as $f ) {
                    foreach ( preg_split( '/[\s,]+/', implode( ',', array_slice( $f, 1 ) ) ) ?: [] as $id ) {
                        $ids[] = (int) $id;
                    }
                }
            }

            $ids = array_merge( $ids, self::ids_from_urls( wp_extract_urls( $raw ) ) );
        }

        self::set_media_of( 'b:' . md5( $key ), array_values( array_unique( array_filter( $ids ) ) ) );
    }

    /**
     * Record which hidden media files belong to an owner, replacing what it had before.
     *
     * @param int|string $owner A post id, or 'b:<md5 of a button key>'.
     */
    private static function set_media_of( $owner, array $media ): void {
        $all   = get_option( self::MEDIA_OPTION, [] );
        $all   = is_array( $all ) ? $all : [];
        $old   = $all;
        $owner = (string) $owner;

        $all = array_filter( $all, static fn( $held_by ): bool => (string) $held_by !== $owner );
        foreach ( $media as $attachment_id ) {
            $all[ (int) $attachment_id ] = is_numeric( $owner ) ? (int) $owner : $owner;
        }

        if ( $all !== $old ) {
            update_option( self::MEDIA_OPTION, $all, false );
        }
    }

    /**
     * The content with every paid part emptied, or null when it has none: the inner blocks of the
     * button block and the text a [cryptoway] shortcode encloses (inner blocks of the button are
     * never shown otherwise, whatever "After payment" says).
     */
    public static function public_copy( string $content ): ?string {
        $changed = false;

        if ( str_contains( $content, '<!-- wp:cryptoway-button/button' ) ) {
            $blocks = self::strip_blocks( parse_blocks( $content ), $changed );

            if ( $changed ) {
                $content = serialize_blocks( $blocks );
            }
        }

        if ( str_contains( $content, '[cryptoway' ) ) {
            $content = (string) preg_replace_callback(
                '/' . get_shortcode_regex( [ 'cryptoway', 'cryptoway_button' ] ) . '/s',
                static function ( array $m ) use ( &$changed ): string {
                    // An escaped [[cryptoway]] is only shown, and a button without text hides nothing.
                    if ( ( '[' === $m[1] && ']' === $m[6] ) || '' === trim( (string) $m[5] ) ) {
                        return $m[0];
                    }
                    $changed = true;
                    return $m[1] . '[' . $m[2] . $m[3] . '][/' . $m[2] . ']' . $m[6];
                },
                $content
            );
        }

        return $changed ? $content : null;
    }

    /** @param array<int, array> $blocks */
    private static function strip_blocks( array $blocks, bool &$changed ): array {
        foreach ( $blocks as $i => $block ) {
            if ( 'cryptoway-button/button' === ( $block['blockName'] ?? '' ) ) {
                if ( ! empty( $block['innerBlocks'] ) ) {
                    $blocks[ $i ]['innerBlocks']  = [];
                    $blocks[ $i ]['innerHTML']    = '';
                    $blocks[ $i ]['innerContent'] = [];
                    $changed                      = true;
                }
                continue;
            }

            if ( ! empty( $block['innerBlocks'] ) ) {
                $blocks[ $i ]['innerBlocks'] = self::strip_blocks( $block['innerBlocks'], $changed );
            }
        }

        return $blocks;
    }

    /**
     * Ids of the media files the paid parts of a content show: the media blocks inside the button
     * block, and images and galleries in the text a shortcode encloses.
     *
     * @return int[]
     */
    private static function paid_media( string $content ): array {
        $ids = [];

        if ( str_contains( $content, '<!-- wp:cryptoway-button/button' ) ) {
            self::collect_media( parse_blocks( $content ), false, $ids );
        }

        if ( str_contains( $content, '[cryptoway' ) && preg_match_all( '/' . get_shortcode_regex( [ 'cryptoway', 'cryptoway_button' ] ) . '/s', $content, $matches, PREG_SET_ORDER ) ) {
            foreach ( $matches as $m ) {
                if ( '[' === $m[1] && ']' === $m[6] ) {
                    continue;
                }
                if ( preg_match_all( '/wp-image-(\d+)|attachment_id=(\d+)|\bids="([\d,\s]+)"/', (string) $m[5], $found, PREG_SET_ORDER ) ) {
                    foreach ( $found as $f ) {
                        foreach ( preg_split( '/[\s,]+/', implode( ',', array_slice( $f, 1 ) ) ) ?: [] as $id ) {
                            $ids[] = (int) $id;
                        }
                    }
                }
            }
        }

        // Files a paid part only links to by address (a PDF in a paragraph, a ZIP behind a button).
        $ids = array_merge( $ids, self::ids_from_urls( self::paid_urls( $content ) ) );

        return array_values( array_unique( array_filter( $ids ) ) );
    }

    /**
     * Media files named by address: only addresses in the uploads folder are looked up (at most 50),
     * relative ones made absolute. A resized copy names its file without the size; a big or turned
     * photo is stored as "-scaled" or "-rotated".
     *
     * @param string[] $urls
     * @return int[]
     */
    private static function ids_from_urls( array $urls ): array {
        $uploads = (string) wp_parse_url( (string) ( wp_get_upload_dir()['baseurl'] ?? '' ), PHP_URL_PATH );

        if ( '' === $uploads ) {
            return [];
        }

        $ids    = [];
        $looked = 0;

        foreach ( $urls as $url ) {
            $url = (string) preg_replace( '/[?#].*$/', '', \WP_Http::make_absolute_url( html_entity_decode( (string) $url ), home_url( '/' ) ) );

            if ( ! str_contains( $url, $uploads . '/' ) ) {
                continue;
            }
            if ( ++$looked > 50 ) {
                break;
            }

            $id = attachment_url_to_postid( $url );

            if ( 0 === $id ) {
                $base = (string) preg_replace( '/-\d+x\d+(?=\.[a-z0-9]+$)/i', '', $url );

                foreach ( [ $base, (string) preg_replace( '/(\.[a-z0-9]+)$/i', '-scaled$1', $base ), (string) preg_replace( '/(\.[a-z0-9]+)$/i', '-rotated$1', $base ) ] as $try ) {
                    if ( $try !== $url ) {
                        $id = attachment_url_to_postid( $try );
                        if ( $id > 0 ) {
                            break;
                        }
                    }
                }
            }

            $ids[] = $id;
        }

        return $ids;
    }

    /**
     * Addresses that appear in the paid parts of a content and nowhere in its public part.
     *
     * @return string[] As written in the content.
     */
    private static function paid_urls( string $content ): array {
        $public = self::public_copy( $content );

        if ( null === $public ) {
            return [];
        }

        $open = array_flip( array_map( [ self::class, 'url_key' ], wp_extract_urls( $public ) ) );
        $paid = [];

        foreach ( wp_extract_urls( $content ) as $url ) {
            $key = self::url_key( $url );

            if ( ! isset( $open[ $key ] ) ) {
                $paid[ $key ] = html_entity_decode( $url );
            }
        }

        return array_values( $paid );
    }

    /** One spelling of an address for comparing: no fragment, no trailing slash, lower case. */
    private static function url_key( string $url ): string {
        return strtolower( untrailingslashit( strip_fragment_from_url( trim( html_entity_decode( $url ) ) ) ) );
    }

    /**
     * @param array<int, array> $blocks
     * @param int[]             $ids Filled in.
     */
    private static function collect_media( array $blocks, bool $inside, array &$ids ): void {
        foreach ( $blocks as $block ) {
            $name   = (string) ( $block['blockName'] ?? '' );
            $attrs  = is_array( $block['attrs'] ?? null ) ? $block['attrs'] : [];
            $paid   = $inside || 'cryptoway-button/button' === $name;

            if ( $inside && isset( self::MEDIA_ATTRS[ $name ] ) ) {
                foreach ( self::MEDIA_ATTRS[ $name ] as $attr ) {
                    foreach ( (array) ( $attrs[ $attr ] ?? [] ) as $id ) {
                        $ids[] = (int) $id;
                    }
                }
            }

            // An image put inline into a paragraph or custom HTML carries its id only in its class.
            if ( $inside && preg_match_all( '/\bwp-image-(\d+)\b/', (string) ( $block['innerHTML'] ?? '' ), $m ) ) {
                foreach ( $m[1] as $id ) {
                    $ids[] = (int) $id;
                }
            }

            if ( ! empty( $block['innerBlocks'] ) ) {
                self::collect_media( $block['innerBlocks'], $paid, $ids );
            }
        }
    }

    /** Index the posts saved before this version, a batch per admin page load until all are done. */
    public static function scan_existing(): void {
        if ( '1' === get_option( self::SCAN_OPTION ) || ! current_user_can( 'edit_posts' ) ) {
            return;
        }

        global $wpdb;

        $done = (int) get_option( self::SCAN_OPTION . '_at', 0 );

        // phpcs:disable WordPress.DB.DirectDatabaseQuery -- a one-time pass over posts that mention the button, in batches.
        $ids = $wpdb->get_col( $wpdb->prepare(
            "SELECT ID FROM {$wpdb->posts}
              WHERE ID > %d AND post_type <> 'revision'
                AND ( post_content LIKE %s OR post_content LIKE %s )
              ORDER BY ID ASC LIMIT 200",
            $done,
            '%' . $wpdb->esc_like( '<!-- wp:cryptoway-button/button' ) . '%',
            '%' . $wpdb->esc_like( '[cryptoway' ) . '%'
        ) );
        // phpcs:enable WordPress.DB.DirectDatabaseQuery

        foreach ( $ids as $id ) {
            self::index_post( (int) $id, get_post( (int) $id ) );
            $done = (int) $id;
        }

        if ( count( $ids ) < 200 ) {
            update_option( self::SCAN_OPTION, '1', true );
            delete_option( self::SCAN_OPTION . '_at' );
        } else {
            update_option( self::SCAN_OPTION . '_at', $done, false );
        }
    }

    // ------------------------------------------------------------------ search

    /**
     * Site search (?s=, the REST search, /wp/v2/posts?search=) matches the searchable copy of a post
     * that has one instead of its raw content. The admin lists keep searching the full text.
     *
     * @param string $search The WHERE part WP_Query built for the search.
     */
    public static function search( $search ) {
        if ( ! is_string( $search ) || '' === $search || 'yes' !== get_option( self::FLAG ) ) {
            return $search;
        }

        if ( is_admin() && ! wp_doing_ajax() ) {
            return $search;
        }

        global $wpdb;

        $column = "{$wpdb->posts}.post_content";

        if ( ! str_contains( $search, $column ) ) {
            return $search;
        }

        $copy = $wpdb->prepare(
            "COALESCE((SELECT cwbtn_pm.meta_value FROM {$wpdb->postmeta} cwbtn_pm WHERE cwbtn_pm.post_id = {$wpdb->posts}.ID AND cwbtn_pm.meta_key = %s LIMIT 1), {$wpdb->posts}.post_content)",
            self::META_PUBLIC
        );

        return str_replace( $column, $copy, $search );
    }

    // ------------------------------------------------------------------ media

    /** Whether a media file is shown only in a paid part (and not to someone who may edit media). */
    public static function is_hidden_media( int $attachment_id ): bool {
        if ( $attachment_id <= 0 || current_user_can( 'upload_files' ) ) {
            return false;
        }

        $all = get_option( self::MEDIA_OPTION, [] );

        return is_array( $all ) && isset( $all[ $attachment_id ] );
    }

    /**
     * The public media listing (/wp/v2/media) leaves those files out.
     *
     * @param array $args WP_Query arguments.
     */
    public static function media_query( $args ) {
        if ( ! is_array( $args ) || current_user_can( 'upload_files' ) ) {
            return $args;
        }

        $all = get_option( self::MEDIA_OPTION, [] );

        if ( is_array( $all ) && $all ) {
            $hidden = array_map( 'intval', array_keys( $all ) );

            // WP_Query applies post__in instead of post__not_in (?include[]=): the hidden ids go from both.
            if ( ! empty( $args['post__in'] ) ) {
                $kept             = array_values( array_diff( array_map( 'intval', (array) $args['post__in'] ), $hidden ) );
                $args['post__in'] = $kept ? $kept : [ 0 ];
            }

            // phpcs:ignore WordPressVIPMinimum.Performance.WPQueryParams.PostNotIn_post__not_in -- only the anonymous media listing; the list holds just the files of paid parts.
            $args['post__not_in'] = array_merge( (array) ( $args['post__not_in'] ?? [] ), $hidden );
        }

        return $args;
    }

    /**
     * One media file by id (/wp/v2/media/<id>, also embedded as a featured image): not found for such a
     * file, as if it did not exist. Told by the handler, not by the address: REST matches routes
     * whatever their letter case.
     *
     * @param mixed            $response
     * @param array            $handler
     * @param \WP_REST_Request $request
     */
    public static function media_item( $response, $handler, $request ) {
        if ( ! $request instanceof \WP_REST_Request || ! in_array( $request->get_method(), [ 'GET', 'HEAD' ], true ) ) {
            return $response;
        }

        $callback = is_array( $handler ) ? ( $handler['callback'] ?? null ) : null;

        if ( is_array( $callback ) && ( $callback[0] ?? null ) instanceof \WP_REST_Attachments_Controller && 'get_item' === ( $callback[1] ?? '' )
            && self::is_hidden_media( (int) $request->get_param( 'id' ) ) ) {
            return new \WP_Error( 'rest_post_invalid_id', __( 'Not found.', 'cryptoway-button' ), [ 'status' => 404 ] );
        }

        return $response;
    }

    // ------------------------------------------------------------------ feeds and other listings

    /**
     * Audio and video a post links to become enclosures of its feed item: not those of its paid parts.
     *
     * @param string[] $links
     * @param int      $post_id
     */
    public static function enclosure_links( $links, $post_id ) {
        $post = get_post( (int) $post_id );

        if ( ! is_array( $links ) || ! $post instanceof \WP_Post ) {
            return $links;
        }

        $paid = array_flip( array_map( [ self::class, 'url_key' ], self::paid_urls( (string) $post->post_content ) ) );

        return $paid ? array_values( array_filter( $links, static fn( $link ): bool => ! isset( $paid[ self::url_key( (string) $link ) ] ) ) ) : $links;
    }

    /**
     * An enclosure saved before (or by another tool) is left out of the feed when its file belongs to a
     * paid part of the post being listed.
     *
     * @param string $html The <enclosure> or <link rel="enclosure"> tag.
     */
    public static function feed_enclosure( $html ) {
        $post = get_post();

        if ( ! is_string( $html ) || ! $post instanceof \WP_Post || '' === (string) get_post_meta( $post->ID, self::META_PUBLIC, true ) ) {
            return $html;
        }

        if ( 1 !== preg_match( '/\b(?:url|href)="([^"]+)"/', $html, $m ) ) {
            return $html;
        }

        static $paid = [];
        $paid[ $post->ID ] ??= array_flip( array_map( [ self::class, 'url_key' ], self::paid_urls( (string) $post->post_content ) ) );

        return isset( $paid[ $post->ID ][ self::url_key( $m[1] ) ] ) ? '' : $html;
    }

    /**
     * The Latest Posts block shows full post text raw before WordPress 7.0 (the button never draws it):
     * its paid parts are taken out of the output.
     *
     * @param string $html
     */
    public static function latest_posts( $html ) {
        if ( ! is_string( $html ) || ( ! str_contains( $html, '<!-- wp:cryptoway-button/button' ) && ! str_contains( $html, '[cryptoway' ) ) ) {
            return $html;
        }

        // A paid shortcode goes whole: left with no text, the page (which runs shortcodes on this
        // output) would draw it as a live button with nothing to sell.
        if ( str_contains( $html, '[cryptoway' ) ) {
            $html = (string) preg_replace_callback(
                '/' . get_shortcode_regex( [ 'cryptoway', 'cryptoway_button' ] ) . '/s',
                static fn( array $m ): string => ( ( '[' === $m[1] && ']' === $m[6] ) || '' === trim( (string) $m[5] ) ) ? $m[0] : $m[1] . $m[6],
                $html
            );
        }

        return self::public_copy( $html ) ?? $html;
    }

    /**
     * The attachment page of such a file is not found either, nor its feed (a 404 keeps the feed flag
     * and the post, and the feed item would carry the file's address). No redirect to its address.
     */
    public static function attachment_page(): void {
        if ( ! is_attachment() || ! self::is_hidden_media( (int) get_queried_object_id() ) ) {
            return;
        }

        global $wp_query;
        $wp_query->posts      = [];
        $wp_query->post       = null;
        $wp_query->post_count = 0;
        $wp_query->set_404();
        remove_action( 'template_redirect', 'redirect_canonical' );
        status_header( 404 );
        nocache_headers();
    }

    /** No oEmbed card (with its thumbnail) for such a file. */
    public static function oembed_post_id( $post_id ) {
        return self::is_hidden_media( (int) $post_id ) ? 0 : $post_id;
    }
}