class-post-collection.php

<?php
// phpcs:disable WordPress.Security.NonceVerification.Recommended,WordPress.Security.NonceVerification.Missing,WordPress.DB.DirectDatabaseQuery.DirectQuery,WordPress.DB.DirectDatabaseQuery.NoCaching -- Request reads are validated by action handlers and migration/status reads intentionally use prepared direct queries.
/**
 * Post Collection
 *
 * This contains the post collection functions.
 *
 * @package Post_Collection
 */

namespace PostCollection;

defined( 'ABSPATH' ) || exit;

use Friends\Friends;
use WP_HTML_Tag_Processor;

/**
 * This is the class for the downloading and storing posts.
 *
 * @since 0.1
 *
 * @package Post_Collection
 * @author Alex Kirk
 */
class Post_Collection {
	const CPT = 'collected_post';
	const COLLECTION_TAXONOMY = 'post_collection';

	/**
	 * Nonce action for the frontend admin-ajax endpoints.
	 */
	const AJAX_NONCE = 'post-collection-ajax';

	/**
	 * Whether to cache the retrieved users
	 *
	 * @var boolean
	 */
	public static $cache = true;

	/**
	 * Contains a reference to the Friends class.
	 *
	 * @var Friends
	 */
	private $friends;

	/**
	 * Contains the site configs
	 *
	 * @var array
	 */
	private $site_configs = array();

	/**
	 * Contains the article notes instance
	 *
	 * @var Article_Notes
	 */
	private $article_notes;

	/**
	 * Contains the abilities integration instance.
	 *
	 * @var Post_Collection_Abilities|null
	 */
	private $abilities;

	/**
	 * Constructor
	 *
	 * @param Friends|null $friends A reference to the Friends object (optional).
	 */
	public function __construct( ?Friends $friends = null ) {
		$this->friends = $friends;
		$this->article_notes = new Article_Notes( $this );
		if ( class_exists( __NAMESPACE__ . '\Post_Collection_Abilities' ) ) {
			$this->abilities = new Post_Collection_Abilities( $this );
		}
		$this->register_hooks();
		if ( did_action( 'init' ) ) {
			$this->boot_app();
		} else {
			add_action( 'init', array( $this, 'boot_app' ), 0 );
		}
	}

	/**
	 * Initialize the standalone frontend app.
	 */
	public function boot_app() {
		if ( class_exists( __NAMESPACE__ . '\Post_Collection_App' ) ) {
			Post_Collection_App::boot( $this );
		}
	}

	/**
	 * Get the tag taxonomy to use for post collections.
	 *
	 * @return string The taxonomy name.
	 */
	public function get_tag_taxonomy() {
		if ( $this->friends && defined( 'Friends\Friends::TAG_TAXONOMY' ) ) {
			return Friends::TAG_TAXONOMY;
		}
		return 'friend_tag';
	}

	/**
	 * Get the required role capability for Friends functionality.
	 *
	 * @return string The capability name.
	 */
	public function get_required_role() {
		if ( $this->friends && defined( 'Friends\Friends::REQUIRED_ROLE' ) ) {
			return Friends::REQUIRED_ROLE;
		}
		return 'edit_private_posts';
	}

	/**
	 * Get the Friends version or fallback.
	 *
	 * @return string The version string.
	 */
	public function get_friends_version() {
		if ( $this->friends && defined( 'Friends\Friends::VERSION' ) ) {
			return Friends::VERSION;
		}
		return '1.0';
	}

	/**
	 * Check if we're on the Friends frontend.
	 *
	 * @return bool True if on Friends frontend.
	 */
	public function is_on_friends_frontend() {
		if ( $this->friends ) {
			return Friends::on_frontend();
		}
		return false;
	}

	/**
	 * Check if a URL is valid using Friends method if available.
	 *
	 * @param string $url The URL to check.
	 * @return bool True if URL is valid.
	 */
	public function check_url( $url ) {
		if ( $this->friends ) {
			return Friends::check_url( $url );
		}
		return filter_var( $url, FILTER_VALIDATE_URL ) !== false;
	}

	/**
	 * Parse a shared text payload into a URL and optional title.
	 *
	 * @param string $text The shared text.
	 * @return array Parsed URL and title.
	 */
	public function parse_shared_url_payload( $text ) {
		$text = trim( (string) $text );
		if ( $this->check_url( $text ) ) {
			return array(
				'url'   => $text,
				'title' => '',
			);
		}

		if ( preg_match( '~https?://[^\s<>"\']+~i', $text, $matches, PREG_OFFSET_CAPTURE ) ) {
			$url   = rtrim( $matches[0][0], '.,;:!?)]}' );
			$title = trim( substr( $text, 0, $matches[0][1] ) );
			$title = preg_replace( '/\s+/', ' ', $title );

			return array(
				'url'   => $url,
				'title' => $title && strlen( $title ) <= 160 ? $title : '',
			);
		}

		return array(
			'url'   => $text,
			'title' => '',
		);
	}

	/**
	 * Truncate URL using Friends method if available.
	 *
	 * @param string $url The URL to truncate.
	 * @return string The truncated URL.
	 */
	public function url_truncate( $url ) {
		if ( $this->friends ) {
			return Friends::url_truncate( $url );
		}
		// Simple fallback truncation
		if ( strlen( $url ) > 50 ) {
			return substr( $url, 0, 47 ) . '...';
		}
		return $url;
	}

	/**
	 * Find post ID by URL.
	 *
	 * @param string $url     The URL to find.
	 * @param int    $user_id The post author ID.
	 * @return int|null The post ID if found, null otherwise.
	 */
	public function url_to_postid( $url, $user_id ) {
		if ( $this->friends ) {
			return $this->friends->feed->url_to_postid( $url, $user_id );
		}

		// Fallback: query by guid field.
		global $wpdb;
		$post_id = $wpdb->get_var(
			$wpdb->prepare(
				"SELECT ID FROM $wpdb->posts WHERE guid = %s AND post_author = %d AND post_type = %s LIMIT 1",
				$url,
				$user_id,
				self::CPT
			)
		);

		return $post_id ? intval( $post_id ) : null;
	}

	/**
	 * Get the article notes instance.
	 *
	 * @return Article_Notes The article notes instance.
	 */
	public function get_article_notes() {
		return $this->article_notes;
	}

	/**
	 * Get the post author name.
	 *
	 * @param \WP_Post $post The post object.
	 * @return string The author display name.
	 */
	public function get_post_author_name( \WP_Post $post ) {
		if ( $this->friends && class_exists( '\Friends\User' ) ) {
			$author = \Friends\User::get_post_author( $post );
			return $author->display_name;
		}
		return get_the_author_meta( 'display_name', $post->post_author );
	}

	/**
	 * Register the WordPress hooks
	 */
	private function register_hooks() {
		if ( did_action( 'init' ) ) {
			$this->register_custom_post_type();
			$this->add_revision_support();
		} else {
			add_action( 'init', array( $this, 'register_custom_post_type' ) );
			add_action( 'init', array( $this, 'add_revision_support' ) );
		}
		add_filter( 'friends_author_post_type', array( $this, 'filter_author_post_type' ), 10, 2 );
		add_filter( 'friends_frontend_post_types', array( $this, 'add_frontend_post_types' ) );
		add_action( 'pre_get_posts', array( $this, 'filter_collection_friend_posts_query' ), 20 );
		add_action( 'tool_box', array( $this, 'toolbox_bookmarklet' ) );
		add_filter( 'user_row_actions', array( $this, 'user_row_actions' ), 10, 2 );
		add_action( 'admin_menu', array( $this, 'admin_menu' ), 50 );
		add_action( 'admin_bar_menu', array( $this, 'admin_bar_new_content' ), 72 );
		add_action( 'enqueue_block_editor_assets', array( $this, 'enqueue_block_editor_assets' ) );
		add_action( 'wp_enqueue_scripts', array( $this, 'enqueue_scripts' ), 99999 );
		add_action( 'wp_loaded', array( $this, 'save_url_endpoint' ), 100 );
		add_filter( 'get_edit_user_link', array( $this, 'edit_post_collection_link' ), 10, 2 );
		add_action( 'friend_post_edit_link', array( $this, 'allow_post_editing' ), 10, 2 );
		add_action( 'friends_show_author_edit', array( $this, 'friends_show_author_edit' ), 10, 2 );
		add_action( 'friends_entry_dropdown_menu', array( $this, 'entry_dropdown_menu' ), 10, 2 );
		add_action( 'friends_friend_feed_viewable', array( $this, 'friends_friend_feed_viewable' ), 10, 2 );
		add_filter( 'friends_friend_posts_query_viewable', array( $this, 'collection_friend_posts_query_viewable' ), 10, 2 );
		add_action( 'friend_user_role_name', array( $this, 'friend_user_role_name' ), 10, 2 );
		add_filter( 'friends_plugin_roles', array( $this, 'associate_friend_user_role' ) );
		add_action( 'friends_override_author_name', array( $this, 'friends_override_author_name' ), 15, 3 );
		add_filter( 'send_to_e_reader_ebook_author', array( $this, 'filter_ebook_author' ), 10, 2 );
		add_action( 'friends_widget_friend_list_after', array( $this, 'friends_widget_friend_list_after' ), 10, 2 );
		add_action( 'friends_author_header', array( $this, 'friends_author_header' ) );
		add_action( 'friends_author_header', array( $this, 'enter_url_field' ) );
		add_action( 'friends_post_footer_first', array( $this, 'share_button' ) );
		add_action( 'friends_feed_table_header', array( $this, 'feed_table_header' ) );
		add_action( 'friends_feed_table_row', array( $this, 'feed_table_row' ), 10, 2 );
		add_action( 'friends_feed_list_item', array( $this, 'feed_list_item' ), 10, 2 );
		add_action( 'friends_process_feed_item_submit', array( $this, 'feed_item_submit' ), 10, 2 );
		add_action( 'friends_modify_feed_item', array( $this, 'modify_feed_item' ), 10, 4 );
		add_filter( 'friends_can_update_modified_feed_posts', array( $this, 'can_update_modified_feed_posts' ), 10, 5 );
		add_action( 'friends_after_register_feed_taxonomy', array( $this, 'after_register_feed_taxonomy' ) );
		add_filter( 'my_apps_plugins', array( $this, 'my_apps_plugins' ) );
		add_action( 'wp_ajax_post-collection-mark-publish', array( $this, 'wp_ajax_mark_publish' ) );
		add_action( 'wp_ajax_post-collection-mark-private', array( $this, 'wp_ajax_mark_private' ) );
		add_action( 'wp_ajax_post-collection-change-author', array( $this, 'wp_ajax_change_author' ) );
		add_action( 'wp_ajax_post-collection-save-to-collection', array( $this, 'wp_ajax_save_to_collection' ) );
		add_action( 'wp_ajax_post-collection-fetch-full-content', array( $this, 'wp_ajax_fetch_full_content' ) );
		add_action( 'wp_ajax_post-collection-download-images', array( $this, 'wp_ajax_download_images' ) );
		add_action( 'wp_ajax_post-collection-re-extract', array( $this, 'wp_ajax_re_extract' ) );
		add_filter( 'friends_search_autocomplete', array( $this, 'friends_search_autocomplete' ), 20, 2 );
		add_filter( 'friends_browser_extension_actions', array( $this, 'friends_browser_extension_actions' ), 10, 3 );
		add_filter( 'friends_browser_extension_action_post_collection_save', array( $this, 'friends_browser_extension_action_save' ), 10, 4 );
	}

	public function register_site_config( SiteConfig\SiteConfig $config ) {
		$this->site_configs[] = $config;
	}

	/**
	 * Register the custom post type for collected posts.
	 */
	public function register_custom_post_type() {
		$this->register_collection_taxonomy();

		$labels = array(
			'name'               => __( 'Collected Posts', 'post-collection' ),
			'singular_name'      => __( 'Collected Post', 'post-collection' ),
			'add_new'            => _x( 'Add New', 'collected post', 'post-collection' ),
			'add_new_item'       => __( 'Add New Collected Post', 'post-collection' ),
			'edit_item'          => __( 'Edit Collected Post', 'post-collection' ),
			'new_item'           => __( 'New Collected Post', 'post-collection' ),
			'all_items'          => __( 'All Collected Posts', 'post-collection' ),
			'view_item'          => __( 'View Collected Post', 'post-collection' ),
			'search_items'       => __( 'Search Collected Posts', 'post-collection' ),
			'not_found'          => __( 'No Collected Posts found', 'post-collection' ),
			'not_found_in_trash' => __( 'No Collected Posts found in the Trash', 'post-collection' ),
			'parent_item_colon'  => '',
			'menu_name'          => __( 'Collected Posts', 'post-collection' ),
		);

		$args = array(
			'labels'              => $labels,
			'description'         => __( 'A collected post from the web', 'post-collection' ),
			'publicly_queryable'  => current_user_can( $this->get_required_role() ),
			'show_ui'             => true,
			'show_in_menu'        => apply_filters( 'post_collection_show_in_menu', true ),
			'show_in_nav_menus'   => false,
			'show_in_admin_bar'   => false,
			'show_in_rest'        => is_user_logged_in(),
			'exclude_from_search' => true,
			'public'              => false,
			'delete_with_user'    => true,
			'menu_position'       => 5,
			'menu_icon'           => 'dashicons-book',
			'supports'            => array( 'title', 'editor', 'author', 'revisions', 'thumbnail', 'excerpt', 'comments', 'post-formats' ),
			'taxonomies'          => array( self::COLLECTION_TAXONOMY, $this->get_tag_taxonomy(), 'post_format' ),
			'has_archive'         => true,
			'rewrite'             => false,
		);

		register_post_type( self::CPT, $args );
	}

	/**
	 * Register collections as a taxonomy for collected posts.
	 */
	public function register_collection_taxonomy() {
		$labels = array(
			'name'          => __( 'Post Collections', 'post-collection' ),
			'singular_name' => __( 'Post Collection', 'post-collection' ),
			'search_items'  => __( 'Search Post Collections', 'post-collection' ),
			'all_items'     => __( 'All Post Collections', 'post-collection' ),
			'edit_item'     => __( 'Edit Post Collection', 'post-collection' ),
			'update_item'   => __( 'Update Post Collection', 'post-collection' ),
			'add_new_item'  => __( 'Add New Post Collection', 'post-collection' ),
			'new_item_name' => __( 'New Post Collection Name', 'post-collection' ),
			'menu_name'     => __( 'Post Collections', 'post-collection' ),
		);

		register_taxonomy(
			self::COLLECTION_TAXONOMY,
			self::CPT,
			array(
				'labels'            => $labels,
				'public'            => false,
				'show_ui'           => true,
				'show_admin_column' => true,
				'show_in_rest'      => is_user_logged_in(),
				'hierarchical'      => false,
				'rewrite'           => false,
			)
		);
	}

	public function add_revision_support() {
		add_post_type_support( self::CPT, 'revisions' );
	}

	/**
	 * Filter the post type when querying by a post_collection author.
	 *
	 * @param string|array $post_type The current post type(s).
	 * @param User         $user      The author being queried.
	 * @return string|array The filtered post type(s).
	 */
	public function filter_author_post_type( $post_type, $user ) {
		if ( $user->has_cap( 'post_collection' ) ) {
			return self::CPT;
		}
		return $post_type;
	}

	/**
	 * Get the collection term addressed by a /friends/{collection}/ query.
	 *
	 * @param \WP_Query|null $query Optional query object.
	 * @return \WP_Term|null Collection term, if the query targets one.
	 */
	private function get_collection_term_from_friends_query( $query = null ) {
		if ( $query instanceof \WP_Query ) {
			$pagename = isset( $query->query['pagename'] ) ? $query->query['pagename'] : $query->get( 'pagename' );
			if ( ! $pagename ) {
				$pagename = isset( $query->query['category_name'] ) ? $query->query['category_name'] : $query->get( 'category_name' );
			}
			if ( ! $pagename ) {
				$pagename = isset( $query->query['name'] ) ? $query->query['name'] : $query->get( 'name' );
			}
		} else {
			$pagename = get_query_var( 'pagename' );
			if ( ! $pagename ) {
				$pagename = get_query_var( 'category_name' );
			}
			if ( ! $pagename ) {
				$pagename = get_query_var( 'name' );
			}
		}

		$pagename_parts = explode( '/', trim( (string) $pagename, '/' ) );
		if ( 'friends' !== array_shift( $pagename_parts ) || empty( $pagename_parts[0] ) ) {
			return null;
		}

		$collection = get_term_by( 'slug', sanitize_title( $pagename_parts[0] ), self::COLLECTION_TAXONOMY );
		if ( ! $collection || is_wp_error( $collection ) ) {
			return null;
		}

		return $collection;
	}

	/**
	 * Query migrated collection URLs by collection term instead of old author users.
	 *
	 * @param \WP_Query $query The main query.
	 */
	public function filter_collection_friend_posts_query( \WP_Query $query ) {
		global $wp_query;

		if ( $wp_query !== $query || $query->is_admin() || $query->is_home() ) {
			return;
		}

		$collection = $this->get_collection_term_from_friends_query( $query );
		if ( ! $collection ) {
			return;
		}

		$tax_query = $query->get( 'tax_query' );
		if ( ! is_array( $tax_query ) ) {
			$tax_query = array();
		}
		if ( $tax_query ) {
			$tax_query['relation'] = 'AND';
		}
		$tax_query[] = array(
			'taxonomy' => self::COLLECTION_TAXONOMY,
			'field'    => 'term_id',
			'terms'    => array( (int) $collection->term_id ),
		);

		$query->set( 'author', '' );
		$query->set( 'author_name', '' );
		$query->set( 'post_type', self::CPT );
		$query->set( 'tax_query', $tax_query );
		$query->is_author = true;
	}

	/**
	 * Add post_collection CPT to the Friends frontend post types.
	 *
	 * This is for backward compatibility with older versions of the Friends plugin.
	 *
	 * @param array $post_types The incoming post types.
	 * @return array The frontend post types.
	 */
	public function add_frontend_post_types( $post_types ) {
		return array_merge( array( self::CPT ), $post_types );
	}

	/**
	 * Get the Friends\Template_Loader singleton
	 *
	 * @return Friends\Template_Loader A class instance.
	 */
	public static function template_loader() {
		static $template_loader;
		if ( ! isset( $template_loader ) ) {
			require_once __DIR__ . '/class-post-collection-template-loader.php';
			$template_loader = new Post_Collection_Template_Loader();
		}
		return $template_loader;
	}

	public function allow_post_editing( $link, $original ) {
		if ( $this->is_post_collection_user( get_the_author_meta( 'ID' ) ) ) {
			return $original;
		}
		return $link;
	}

	public function friends_show_author_edit( $show, $friend_user ) {
		static $cache = array();
		if ( isset( $cache[ $friend_user->ID ] ) ) {
			if ( $cache[ $friend_user->ID ] ) {
				return $show;
			}
			return false;
		}

		if ( $friend_user->has_cap( 'post_collection' ) ) {
			$cache[ $friend_user->ID ] = false;
			return false;
		}

		$cache[ $friend_user->ID ] = true;
		return $show;
	}

	public function entry_dropdown_menu( $post = null, $friend_user = null ) {
		$divider = '<li class="divider" data-content="' . esc_attr__( 'Post Collection', 'post-collection' ) . '"></li>';
		$list_tags = array(
			'li' => array(
				'class'        => true,
				'data-content' => true,
			),
		);
		$post                    = get_post( $post );
		$author                  = $friend_user instanceof \WP_User ? $friend_user : $this->get_feed_item_author( $post );
		$user_id                 = $author ? $author->ID : get_the_author_meta( 'ID' );
		$user_id                 = (int) $user_id;
		$author_attr             = $user_id;
		$is_post_collection_user = $this->is_post_collection_user( $user_id );
		$is_collected_post       = $post && self::CPT === $post->post_type;

		if ( $is_collected_post && $is_post_collection_user ) {
			echo wp_kses( $divider, $list_tags );
			$divider = '';
			?>
			<li class="menu-item"><a href="<?php echo esc_url( get_edit_user_link( $user_id ) ); ?>"><?php esc_html_e( 'Edit Post Collection', 'post-collection' ); ?></a></li>
			<?php
			if ( 'private' === get_post_status() ) {
				?>
				<li class="menu-item"><a href="#" data-id="<?php echo esc_attr( get_the_ID() ); ?>" class="post-collection-mark-publish"><?php esc_html_e( 'Show post in the feed', 'post-collection' ); ?></a></li>
				<?php
			} elseif ( 'publish' === get_post_status() ) {
				?>
					<li class="menu-item"><a href="#" data-id="<?php echo esc_attr( get_the_ID() ); ?>" class="post-collection-mark-private"><?php esc_html_e( 'Hide post from the feed', 'post-collection' ); ?></a></li>
				<?php
			}
		}

		foreach ( $this->get_post_collection_terms() as $collection ) {
			if ( $is_collected_post && has_term( (int) $collection->term_id, self::COLLECTION_TAXONOMY, $post ) ) {
				continue;
			}
			if ( get_term_meta( $collection->term_id, 'friends_post_collection_inactive', true ) ) {
				continue;
			}
			echo wp_kses( $divider, $list_tags );
			$divider = '';
			?>
			<li class="menu-item"><a href="#" data-id="<?php echo esc_attr( get_the_ID() ); ?>" data-collection="<?php echo esc_attr( $collection->term_id ); ?>" class="post-collection-save-to-collection has-icon-right<?php echo esc_attr( get_term_meta( $collection->term_id, 'friends_post_collection_copy_mode', true ) ? ' copy-mode' : '' ); ?>">
				<?php
				if ( get_term_meta( $collection->term_id, 'friends_post_collection_copy_mode', true ) ) {
					echo esc_html(
						sprintf(
							// translators: %s is the name of a post collection.
							_x( 'Copy to %s', 'post-collection', 'post-collection' ),
							$collection->name
						)
					);
				} else {
					echo esc_html(
						sprintf(
							// translators: %s is the name of a post collection.
							_x( 'Move to %s', 'post-collection', 'post-collection' ),
							$collection->name
						)
					);
				}
				?>
				<i class="form-icon"></i></a>
			</li>
			<?php
		}

		$already_fetched = get_post_meta( get_the_ID(), 'full-content-fetched', true );
		$i_classes = 'form-icon';
		if ( $already_fetched ) {
			$i_classes = 'dashicons dashicons-saved';
		}

		$already_downloaded = get_post_meta( get_the_ID(), 'images-downloaded', true );
		$i_classes = 'form-icon';
		if ( $already_downloaded ) {
			$i_classes = 'dashicons dashicons-saved';
		}

		?>
		<li class="menu-item"><a href="#" data-id="<?php echo esc_attr( get_the_ID() ); ?>" data-author="<?php echo esc_attr( $author_attr ); ?>" class="post-collection-fetch-full-content has-icon-right">
			<?php
				esc_html_e( 'Fetch full content', 'post-collection' );
			?>
			<i class="<?php echo esc_attr( $i_classes ); ?>"></i></a>
		</li>
		<li class="menu-item"><a href="#" data-id="<?php echo esc_attr( get_the_ID() ); ?>" data-author="<?php echo esc_attr( $author_attr ); ?>" class="post-collection-download-images has-icon-right">
			<?php
				esc_html_e( 'Download external images', 'post-collection' );
			?>
			<i class="<?php echo esc_attr( $i_classes ); ?>"></i></a>
		</li>
		<?php
		$revisions = wp_get_post_revisions( get_the_ID(), array( 'posts_per_page' => 1 ) );
		if ( ! empty( $revisions ) ) :
			?>
		<li class="menu-item"><a href="#" data-id="<?php echo esc_attr( get_the_ID() ); ?>" class="post-collection-re-extract has-icon-right">
			<?php
				esc_html_e( 'Re-extract from original HTML', 'post-collection' );
			?>
			<i class="form-icon"></i></a>
		</li>
			<?php
		endif;
	}

	/**
	 * Get the author for the current Friends feed item.
	 *
	 * Friends can store feed ownership in taxonomy relationships, so template
	 * author globals and post_author are not always the right source.
	 *
	 * @param \WP_Post|null $post The feed item post.
	 * @return \WP_User|false The resolved feed item author.
	 */
	private function get_feed_item_author( $post = null ) {
		$post = get_post( $post );
		if ( ! $post ) {
			return false;
		}

		if ( class_exists( '\Friends\User' ) && method_exists( '\Friends\User', 'get_post_author' ) ) {
			$author = \Friends\User::get_post_author( $post );
			if ( $author && ! is_wp_error( $author ) ) {
				return $author;
			}
		}

		return User::get_post_author( $post );
	}

	public function edit_post_collection_link( $link, $user_id ) {
		$user = new \WP_User( $user_id );
		if ( is_multisite() && is_super_admin( $user->ID ) ) {
			return $link;
		}
		if (
			! $user->has_cap( 'post_collection' )
		) {
			return $link;
		}

		return self_admin_url( 'admin.php?page=edit-post-collection&user=' . $user_id );
	}


	public function is_post_collection_user( $user_id ) {
		static $cache = array();

		if ( ! isset( $cache[ $user_id ] ) ) {
			$user = new User( $user_id );
			$cache[ $user_id ] = $user->has_cap( 'post_collection' );
		}

		return $cache[ $user_id ];
	}

	/**
	 * Process access for the Friends Edit User page
	 */
	private function check_edit_post_collection() {
		if ( ! current_user_can( $this->get_required_role() ) ) {
			wp_die( esc_html__( 'Sorry, you are not allowed to edit this user.' ) ); // phpcs:ignore WordPress.WP.I18n.MissingArgDomain
		}

		if ( ! isset( $_GET['user'] ) || ! is_numeric( $_GET['user'] ) ) {
			wp_die( esc_html__( 'Invalid user ID.' ) ); // phpcs:ignore WordPress.WP.I18n.MissingArgDomain
		}

		$user = new User( intval( $_GET['user'] ) );
		if ( ! $user || is_wp_error( $user ) ) {
			wp_die( esc_html__( 'Invalid user ID.' ) ); // phpcs:ignore WordPress.WP.I18n.MissingArgDomain
		}

		if ( is_multisite() && is_super_admin( intval( $_GET['user'] ) ) ) {
			wp_die( esc_html__( 'Invalid user ID.' ) ); // phpcs:ignore WordPress.WP.I18n.MissingArgDomain
		}

		if (
			! $user->has_cap( 'post_collection' )
		) {
			wp_die( esc_html__( 'This is not a user related to this plugin.', 'post-collection' ) );
		}

		return $user;
	}

	/**
	 * Process the Friends Edit Post Collection page
	 */
	public function process_edit_post_collection() {
		$user    = $this->check_edit_post_collection();
		$arg       = 'updated';
		$arg_value = 1;

		if ( isset( $_POST['_wpnonce'] ) && wp_verify_nonce( sanitize_key( wp_unslash( $_POST['_wpnonce'] ) ), 'edit-post-collection-' . $user->ID ) ) {

			$display_name = isset( $_POST['display_name'] ) ? trim( sanitize_text_field( wp_unslash( $_POST['display_name'] ) ) ) : '';
			if ( $display_name ) {
				$user->display_name = $display_name;
			}
			$user->description = isset( $_POST['description'] ) ? trim( sanitize_textarea_field( wp_unslash( $_POST['description'] ) ) ) : '';
			wp_update_user( $user );

			if ( ! empty( $_POST['publish_post_collection'] ) ) {
				update_user_option( $user->ID, 'friends_publish_post_collection', true );
			} else {
				delete_user_option( $user->ID, 'friends_publish_post_collection' );
			}
			$frontend_mode = isset( $_POST['frontend_mode'] ) ? sanitize_key( wp_unslash( $_POST['frontend_mode'] ) ) : 'posts';
			if ( in_array( $frontend_mode, array( 'bookmarks', 'posts' ), true ) ) {
				update_user_option( $user->ID, 'post_collection_frontend_mode', $frontend_mode );
			}
			$frontend_view = isset( $_POST['frontend_view'] ) ? sanitize_key( wp_unslash( $_POST['frontend_view'] ) ) : 'reader';
			if ( in_array( $frontend_view, array( 'board', 'links', 'reader' ), true ) ) {
				update_user_option( $user->ID, 'post_collection_frontend_view', $frontend_view );
			}
			if ( ! empty( $_POST['hide_from_home'] ) ) {
				update_user_option( $user->ID, 'post_collection_hide_from_home', true );
			} else {
				delete_user_option( $user->ID, 'post_collection_hide_from_home' );
			}
			if ( isset( $_POST['dropdown'] ) ) {
				switch ( sanitize_key( wp_unslash( $_POST['dropdown'] ) ) ) {
					case 'inactive':
						update_user_option( $user->ID, 'friends_post_collection_inactive', true );
						break;
					case 'move':
						delete_user_option( $user->ID, 'friends_post_collection_inactive' );
						delete_user_option( $user->ID, 'friends_post_collection_copy_mode' );
						break;
					case 'copy':
						delete_user_option( $user->ID, 'friends_post_collection_inactive' );
						update_user_option( $user->ID, 'friends_post_collection_copy_mode', true );
						break;
				}
			}
		} else {
			return;
		}

		if ( isset( $_GET['wp_http_referer'] ) ) {
			wp_safe_redirect( esc_url_raw( wp_unslash( $_GET['wp_http_referer'] ) ) );
		} else {
			$request_uri = isset( $_SERVER['REQUEST_URI'] ) ? esc_url_raw( wp_unslash( $_SERVER['REQUEST_URI'] ) ) : '';
			wp_safe_redirect( add_query_arg( $arg, $arg_value, remove_query_arg( array( 'wp_http_referer', '_wpnonce' ), $request_uri ) ) );
		}
		exit;
	}

	public function render_edit_post_collection() {
		$user = $this->check_edit_post_collection();
		$args = array(
			'user'                => $user,
			'inactive'            => get_user_option( 'friends_post_collection_inactive', $user->ID ),
			'copy_mode'           => get_user_option( 'friends_post_collection_copy_mode', $user->ID ),
			'posts'               => new \WP_Query(
				array(
					'post_type'   => self::CPT,
					'post_status' => array( 'publish', 'private' ),
					'author'      => $user->ID,
				)
			),
			'post_collection_url' => home_url( '/?user=' . $user->ID ),
			'bookmarklet_js'      => $this->get_bookmarklet_js(),
			'frontend_mode'       => get_user_option( 'post_collection_frontend_mode', $user->ID ),
			'frontend_view'       => get_user_option( 'post_collection_frontend_view', $user->ID ),
			'hide_from_home'      => get_user_option( 'post_collection_hide_from_home', $user->ID ),
			'frontend_url'        => class_exists( __NAMESPACE__ . '\Post_Collection_App' ) && Post_Collection_App::instance() ? Post_Collection_App::instance()->get_collection_url( $user ) : '',
		);

		?>
		<h1><?php echo esc_html( $user->user_login ); ?></h1>
		<?php

		if ( isset( $_GET['updated'] ) ) {
			?>
			<div id="message" class="updated notice is-dismissible"><p><?php esc_html_e( 'User was updated.', 'post-collection' ); ?></p></div>
			<?php
		} elseif ( isset( $_GET['error'] ) ) {
			?>
			<div id="message" class="updated error is-dismissible"><p><?php esc_html_e( 'An error occurred.', 'post-collection' ); ?></p></div>
			<?php
		}

		$this->template_loader()->get_template_part( 'admin/edit-post-collection', null, $args );
	}

	/**
	 * Process access for the Friends create User page
	 */
	private function check_create_post_collection() {
		if ( ! current_user_can( $this->get_required_role() ) ) {
			wp_die( esc_html__( 'Sorry, you are not allowed to create this user.' ) ); // phpcs:ignore WordPress.WP.I18n.MissingArgDomain
		}

		$user = (object) array(
			'user_login'   => null,
			'display_name' => null,
		);
		if ( isset( $_POST['display_name'] ) ) {
			$user->display_name = sanitize_text_field( wp_unslash( $_POST['display_name'] ) );
		}

		if ( isset( $_POST['user_login'] ) ) {
			$user->user_login = sanitize_user( wp_unslash( $_POST['user_login'] ) );
			if ( ! $user->user_login && $user->display_name ) {
				$user->user_login = User::sanitize_username( $user->display_name );
			}
		}
		return $user;
	}

	/**
	 * Process the Friends Create Post Collection page
	 */
	public function process_create_post_collection() {
		$errors = new \WP_Error();
		$user   = $this->check_create_post_collection();

		if ( ! $user->user_login ) {
			$errors->add( 'user_login', __( '<strong>Error</strong>: This username is invalid because it uses illegal characters. Please enter a valid username.' ) ); // phpcs:ignore WordPress.WP.I18n.MissingArgDomain
		} elseif ( username_exists( $user->user_login ) ) {
			$errors->add( 'user_login', __( '<strong>Error</strong>: This username is already registered. Please choose another one.' ) ); // phpcs:ignore WordPress.WP.I18n.MissingArgDomain
		} elseif ( ! $user->display_name ) {
			$errors->add( 'user_login', __( '<strong>Error</strong>: Please enter a valid display name.' ) ); // phpcs:ignore WordPress.WP.I18n.MissingArgDomain
		}

		if ( ! $errors->has_errors() ) {
			$userdata  = array(
				'user_login'   => $user->user_login,
				'display_name' => $user->display_name,
				'user_pass'    => wp_generate_password( 256 ),
				'role'         => 'post_collection',
			);
			$user_id = wp_insert_user( $userdata );
			if ( is_wp_error( $user_id ) ) {
				return $user_id;
			}
			wp_safe_redirect( self_admin_url( 'admin.php?page=edit-post-collection&user=' . $user_id ) );
			exit;
		}

		return $errors;
	}

	public function render_create_post_collection() {
		$response = null;
		$user     = $this->check_create_post_collection();

		if ( ! empty( $_POST ) ) {
			if ( ! isset( $_POST['_wpnonce'] ) || ! wp_verify_nonce( sanitize_key( wp_unslash( $_POST['_wpnonce'] ) ), 'create-post-collection' ) ) {
				$response = new \WP_Error( 'invalid-nonce', __( 'For security reasons, please verify the URL and click next if you want to proceed.', 'post-collection' ) );
			} else {
				$response = $this->process_create_post_collection();
			}
		}

		?>
		<h1><?php esc_html_e( 'Create Post Collection', 'post-collection' ); ?></h1>
		<?php

		if ( is_wp_error( $response ) ) {
			?>
			<div id="message" class="updated notice is-dismissible"><p>
			<?php
			echo wp_kses(
				$response->get_error_message(),
				array(
					'strong' => array(),
					'a'      => array(
						'href'   => array(),
						'rel'    => array(),
						'target' => array(),
					),
				)
			);
			?>
				</p>
			</div>
			<?php
		}

		$args = array(
			'user_login'   => $user->user_login,
			'display_name' => $user->display_name,
		);

		$this->template_loader()->get_template_part( 'admin/create-post-collection', null, $args );
	}

	public function enqueue_scripts() {
		if ( ! is_user_logged_in() ) {
			return;
		}

		if ( $this->is_on_friends_frontend() ) {
			wp_enqueue_script( 'post-collection', plugins_url( 'post-collection.js', __FILE__ ), array( 'friends' ), filemtime( __DIR__ . '/post-collection.js' ), true );
			wp_localize_script(
				'post-collection',
				'postCollection',
				array(
					'nonce' => wp_create_nonce( self::AJAX_NONCE ),
				)
			);
		}
	}

	/**
	 * Enqueue block editor assets for collected posts.
	 */
	public function enqueue_block_editor_assets() {
		$screen = function_exists( 'get_current_screen' ) ? get_current_screen() : null;
		if ( ! $screen || self::CPT !== $screen->post_type ) {
			return;
		}

		$post = get_post();
		if ( ! $post || self::CPT !== $post->post_type ) {
			return;
		}

		$source_url = $this->get_post_source_url( $post );
		if ( ! $source_url ) {
			return;
		}

		$handle = 'post-collection-editor';
		wp_enqueue_script(
			$handle,
			plugins_url( 'post-collection-editor.js', __FILE__ ),
			array( 'wp-components', 'wp-edit-post', 'wp-element', 'wp-i18n', 'wp-plugins' ),
			filemtime( __DIR__ . '/post-collection-editor.js' ),
			true
		);

		wp_localize_script(
			$handle,
			'postCollectionEditor',
			array(
				'sourceUrl' => $source_url,
				'i18n'      => array(
					'panelTitle'        => __( 'Post Archives', 'post-collection' ),
					'waybackSnapshots'  => __( 'Wayback Snapshots', 'post-collection' ),
					'archiveIs'         => __( 'Archive.is', 'post-collection' ),
					'archiveLinksLabel' => __( 'Find archived copies of the original article URL.', 'post-collection' ),
				),
			)
		);
	}

	/**
	 * Get the original source URL for a collected post.
	 *
	 * @param \WP_Post $post The collected post.
	 * @return string
	 */
	private function get_post_source_url( \WP_Post $post ) {
		$url = get_post_meta( $post->ID, 'url', true );
		if ( is_string( $url ) && $this->check_url( $url ) ) {
			return $url;
		}

		if ( $this->check_url( $post->guid ) ) {
			return $post->guid;
		}

		return '';
	}

	public function admin_menu() {
		if ( $this->friends ) {
			add_submenu_page(
				'',
				__( 'Create Post Collection', 'post-collection' ),
				__( 'Create Post Collection', 'post-collection' ),
				$this->get_required_role(),
				'create-post-collection',
				array( $this, 'render_create_post_collection' )
			);

			add_submenu_page(
				'',
				__( 'Edit Post Collection', 'post-collection' ),
				__( 'Edit Post Collection', 'post-collection' ),
				$this->get_required_role(),
				'edit-post-collection',
				array( $this, 'render_edit_post_collection' )
			);
		}
	}


	/**
	 * Add a Post Collection entry to the New Content admin section
	 *
	 * @param  \WP_Admin_Bar $wp_menu The admin bar to modify.
	 */
	public function admin_bar_new_content( \WP_Admin_Bar $wp_menu ) {
		if ( current_user_can( $this->get_required_role() ) ) {
			$wp_menu->add_menu(
				array(
					'id'     => 'new-post-collection',
					'parent' => 'new-content',
					'title'  => esc_html__( 'Post Collection', 'post-collection' ),
					'href'   => home_url( '/post-collection/new/' ),
				)
			);
		}
	}
	/**
	 * Add actions to the user rows
	 *
	 * @param  array    $actions The existing actions.
	 * @param  \WP_User $user    The user in question.
	 * @return array The extended actions.
	 */
	public function user_row_actions( array $actions, \WP_User $user ) {
		if (
			! current_user_can( $this->get_required_role() ) ||
			(
				! $user->has_cap( 'post_collection' )
			)
		) {
			return $actions;
		}

		if ( is_multisite() ) {
			if ( is_super_admin( $user->ID ) ) {
				return $actions;
			}

			$actions = array_merge( array( 'edit' => '<a href="' . esc_url( self_admin_url( 'admin.php?page=edit-post-collection&user=' . $user->ID ) ) . '">' . __( 'Edit' ) . '</a>' ), $actions ); // phpcs:ignore WordPress.WP.I18n.MissingArgDomain
		}

		$friend_user = new User( $user );
		$actions['view'] = '<a href="' . esc_url( $friend_user->get_local_friends_page_url() ) . '">' . __( 'View' ) . '</a>'; // phpcs:ignore WordPress.WP.I18n.MissingArgDomain

		unset( $actions['resetpassword'] );

		return $actions;
	}

	/**
	 * Display an about page for the plugin.
	 *
	 * @param      bool $display_about_friends  The display about friends section.
	 */
	public function about_page( $display_about_friends = false ) {
		?>
		<div class="wrap">
			<h1><?php esc_html_e( 'Friends Post Collection', 'post-collection' ); ?></h1>

			<p><?php esc_html_e( 'The Friends Post Collection plugin allows you to save external posts to your WordPress, either for just collecting them for yourself as a searchable archive, or to syndicate those posts into new feeds.', 'post-collection' ); ?></p>

			<?php
			if ( $display_about_friends ) :
				?>
				<p>
				<?php
				echo wp_kses(
						// translators: %s: URL to the Friends Plugin page on WordPress.org.
					sprintf( __( 'The Friends plugin is all about connecting with friends and news. Learn more on its <a href=%s>plugin page on WordPress.org</a>.', 'post-collection' ), '"https://wordpress.org/plugins/friends" target="_blank" rel="noopener noreferrer"' ),
					array(
						'a' => array(
							'href'   => array(),
							'rel'    => array(),
							'target' => array(),
						),
					)
				);
				?>
				</p>
			<?php endif; ?>
			<p>
				<?php
				echo wp_kses(
					// translators: %s: URL to the Embed library.
					sprintf( __( 'This plugin is uses information of the open source project <a href=%s>FTR Site Config</a>.', 'post-collection' ), '"https://github.com/fivefilters/ftr-site-config" target="_blank" rel="noopener noreferrer"' ),
					array(
						'a' => array(
							'href'   => array(),
							'rel'    => array(),
							'target' => array(),
						),
					)
				);
				?>
			</p>
		</div>
		<?php
	}

	/**
	 * Display an about page for the plugin with the friends section.
	 */
	public function about_page_with_friends_about() {
		return $this->about_page( true );
	}

	public function get_post_collection_users() {
		static $users;
		if ( ! self::$cache || ! isset( $users ) ) {
			$users = new User_Query(
				array(
					'role'    => 'post_collection',
					'order'   => 'ASC',
					'orderby' => 'display_name',
				)
			);
		}
		return $users;
	}

	/**
	 * Get taxonomy-backed post collections.
	 *
	 * @return \WP_Term[] Collection terms.
	 */
	private function get_post_collection_terms() {
		$terms = get_terms(
			array(
				'taxonomy'   => self::COLLECTION_TAXONOMY,
				'hide_empty' => false,
				'orderby'    => 'name',
				'order'      => 'ASC',
			)
		);

		return is_wp_error( $terms ) ? array() : $terms;
	}

	private function get_bookmarklet_js() {
		$js = file_get_contents( __DIR__ . '/post-collection-injector.js' );
		$js = str_replace( 'text.sending_article_to_your_blog', '"' . addslashes( __( 'Sending the article to your WordPress...', 'post-collection' ) ) . '"', $js );
		$js = str_replace( 'text.do_you_want_to_send_the_article_to_your_blog', '"' . addslashes( __( 'Do you want to send the article on this page to your WordPress?', 'post-collection' ) ) . '"', $js );
		$js = str_replace( PHP_EOL, '', preg_replace( '/\s+/', ' ', $js ) );
		return $js;
	}

	/**
	 * Build a bookmarklet href for saving into a collection.
	 *
	 * @param string $target_arg The save endpoint query argument.
	 * @param int    $target_id  The target collection or user ID.
	 * @return string Bookmarklet href.
	 */
	public function get_bookmarklet_href( $target_arg, $target_id ) {
		$target_url = home_url( '/?' . rawurlencode( $target_arg ) . '=' . rawurlencode( (string) $target_id ) );
		$js = str_replace(
			"window.document.getElementById( 'post-collection-script' ).getAttribute( 'data-post-url' )",
			"'" . esc_url( $target_url ) . "'",
			$this->get_bookmarklet_js()
		);

		return 'javascript:' . rawurlencode( trim( $js, ';' ) );
	}

	/**
	 * Build a URLForwarder template for saving into a collection.
	 *
	 * @param string $target_arg The save endpoint query argument.
	 * @param int    $target_id  The target collection or user ID.
	 * @return string URLForwarder template URL.
	 */
	public function get_urlforwarder_url( $target_arg, $target_id ) {
		return home_url(
			'/?' . rawurlencode( $target_arg ) . '=' . rawurlencode( (string) $target_id ) . '&collect-post=@url&title=@subject'
		);
	}

	/**
	 * Render a bookmarklet link.
	 *
	 * @param string $href  Bookmarklet href.
	 * @param string $label Bookmarklet label.
	 */
	public function render_bookmarklet_link( $href, $label ) {
		?>
		<a href="<?php echo esc_attr( $href ); ?>" class="post-collection-bookmarklet">
			<?php echo esc_html( $label ); ?>
		</a>
		<?php
	}

	/**
	 * Display the Bookmarklet at the Tools section of wp-admin
	 */
	public function toolbox_bookmarklet() {
		$post_collections = $this->get_post_collection_terms();
		?>
		<div class="card">
			<h2 class="title"><?php esc_html_e( 'Post Collection', 'post-collection' ); ?></h2>
			<h3><?php esc_html_e( 'Bookmarklets', 'post-collection' ); ?></h3>

			<p><?php esc_html_e( "Drag one of these bookmarklets to your bookmarks bar and click it when you're on an article you want to save from the web.", 'post-collection' ); ?></p>
			<p>
				<?php foreach ( $post_collections as $collection ) : ?>
					<?php
					$this->render_bookmarklet_link(
						$this->get_bookmarklet_href( 'collection', $collection->term_id ),
						sprintf(
							// translators: %s is the name of a post collection.
							__( 'Save to %s', 'post-collection' ),
							$collection->name
						)
					);
					?>
				<?php endforeach; ?>
			</p>
		</div>
		<?php
	}

	public function save_url_endpoint() {
		$delimiter = '===BODY===';
		$url = false;
		$shared_title = '';
		$collection = null;
		if ( isset( $_REQUEST['collect-post'], $_REQUEST['collection'] ) ) {
			$collection = get_term( absint( wp_unslash( $_REQUEST['collection'] ) ), self::COLLECTION_TAXONOMY );
			if ( ! $collection || is_wp_error( $collection ) ) {
				return;
			}
			// phpcs:ignore WordPress.Security.ValidatedSanitizedInput.InputNotSanitized -- parse_shared_url_payload() validates the URL with check_url() and sanitizes the title.
			$shared_payload = $this->parse_shared_url_payload( wp_unslash( $_REQUEST['collect-post'] ) );
			$url            = $shared_payload['url'];
			$shared_title   = $shared_payload['title'];
		}
		if ( isset( $_REQUEST['collect-post'] ) && isset( $_REQUEST['user'] ) ) {
			if ( ! intval( $_REQUEST['user'] ) ) {
				return;
			}
			$user_id    = absint( wp_unslash( $_REQUEST['user'] ) );
			$saved_body = get_user_option( 'post-collection_last_save', $user_id );
			list( $last_url, $last_body ) = explode( $delimiter, $saved_body ? $saved_body : $delimiter, 2 );
			// phpcs:ignore WordPress.Security.ValidatedSanitizedInput.InputNotSanitized -- Validated with check_url() before it is stored or fetched.
			$url = wp_unslash( $_REQUEST['collect-post'] );
			$body = false;
			if ( isset( $_POST['body'] ) ) {
				// phpcs:ignore WordPress.Security.ValidatedSanitizedInput.InputNotSanitized -- The raw page HTML is input for the Readability extractor; the extracted result is run through wp_kses_post() before it is saved.
				$body = wp_unslash( $_POST['body'] );
			} elseif ( rawurldecode( $last_url ) === rawurldecode( $url ) ) {
				$body = $last_body;
			}
		}

		if ( ! $url ) {
			return;
		}
		$request_method = isset( $_SERVER['REQUEST_METHOD'] ) ? strtoupper( sanitize_key( wp_unslash( $_SERVER['REQUEST_METHOD'] ) ) ) : 'GET';
		if ( 'POST' !== $request_method && isset( $_REQUEST['post-only'] ) ) {
			$friend_user = new User( intval( $_REQUEST['user'] ) );
			$post_id = $this->url_to_postid( $url, $friend_user->ID );
			if ( ! $post_id ) {
				$post_only = absint( wp_unslash( $_REQUEST['post-only'] ) ) + 1;
				$_REQUEST['post-only'] = $post_only;
				if ( $post_only <= 3 ) {
					sleep( 3 - $post_only );
					wp_safe_redirect( add_query_arg( $_REQUEST, home_url( '/' ) ) );
					exit;
				} else {
					// We tried 3 times, so let's remove the post-only and import it via GET.
					wp_safe_redirect( remove_query_arg( 'post-only' ) );
					exit;
				}
			}
			wp_safe_redirect( $friend_user->get_local_friends_page_url( $post_id ) );
			exit;
		}

		if ( $body ) {
			update_user_option( absint( wp_unslash( $_REQUEST['user'] ) ), 'post-collection_last_save', $url . $delimiter . $body );
		}

		if ( ! current_user_can( $this->get_required_role() ) ) {
			auth_redirect();
		}

		if ( $collection ) {
			$args = array();
			if ( $shared_title ) {
				$args['title'] = $shared_title;
			} elseif ( isset( $_REQUEST['title'] ) ) {
				$args['title'] = sanitize_text_field( wp_unslash( $_REQUEST['title'] ) );
			}

			if ( isset( $_POST['post_collection_action'] ) && 'manual-save' === sanitize_key( wp_unslash( $_POST['post_collection_action'] ) ) ) {
				if ( ! isset( $_POST['_wpnonce'] ) || ! wp_verify_nonce( sanitize_text_field( wp_unslash( $_POST['_wpnonce'] ) ), 'post-collection-manual-save' ) ) {
					wp_die( esc_html__( 'Could not verify the save request.', 'post-collection' ) );
				}

				$post_id = $this->save_url_to_collection_term_without_content( $url, $collection, $args );
				if ( is_wp_error( $post_id ) ) {
					wp_die( esc_html( $post_id->get_error_message() ) );
				}

				wp_safe_redirect( get_edit_post_link( $post_id, 'raw' ) );
				exit;
			}

			$post_id = $this->save_url_to_collection_term( $url, $collection, $body, $args );
			if ( is_wp_error( $post_id ) ) {
				$this->render_save_error_page( $post_id, $url, $collection, $args );
				exit;
			}

			wp_safe_redirect( home_url( '/post-collection/' . $collection->slug . '/' . $post_id . '/' ) );
			exit;
		}

		$friend_user = new User( intval( $_REQUEST['user'] ) );
		if ( ! is_wp_error( $friend_user ) || ! $friend_user->has_cap( 'post_collection' ) ) {
			$error = $this->save_url( $url, $friend_user, $body );
			if ( is_wp_error( $error ) ) {
				wp_die( esc_html( $error->get_error_message() ) );
			}
		}
	}

	/**
	 * Save a URL to a collection without downloaded content.
	 *
	 * @param string   $url        Source URL.
	 * @param \WP_Term $collection Collection term.
	 * @param array    $args       Optional arguments: title.
	 * @return int|\WP_Error Post ID or error.
	 */
	public function save_url_to_collection_term_without_content( $url, \WP_Term $collection, $args = array() ) {
		if ( ! is_string( $url ) || ! $this->check_url( $url ) ) {
			return new \WP_Error( 'invalid-url', __( 'You entered an invalid URL.', 'post-collection' ) );
		}

		$title = '';
		if ( isset( $args['title'] ) ) {
			$title = wp_strip_all_tags( trim( sanitize_text_field( $args['title'] ) ) );
		}
		if ( ! $title ) {
			$path  = trim( (string) wp_parse_url( $url, PHP_URL_PATH ), '/' );
			$parts = explode( '/', $path );
			$title = ucwords( strtr( end( $parts ), '-', ' ' ) );
		}
		if ( ! $title ) {
			$title = $url;
		}

		$post_id = $this->url_to_collection_term_postid( $url, $collection );
		if ( $post_id ) {
			wp_untrash_post( $post_id );
			$updated_post = wp_update_post(
				array(
					'ID'         => $post_id,
					'post_title' => $title,
				),
				true
			);

			return is_wp_error( $updated_post ) ? $updated_post : (int) $post_id;
		}

		$post_id = wp_insert_post(
			array(
				'post_status'  => 'private',
				'post_author'  => get_current_user_id(),
				'guid'         => $url,
				'post_type'    => self::CPT,
				'post_title'   => $title,
				'post_content' => '',
			),
			true
		);
		if ( is_wp_error( $post_id ) ) {
			return $post_id;
		}

		wp_set_object_terms( $post_id, array( (int) $collection->term_id ), self::COLLECTION_TAXONOMY, false );

		return (int) $post_id;
	}

	/**
	 * Render a save error page with a manual recovery action.
	 *
	 * @param \WP_Error $error      Save error.
	 * @param string    $url        Source URL.
	 * @param \WP_Term  $collection Collection term.
	 * @param array     $args       Save arguments.
	 */
	private function render_save_error_page( \WP_Error $error, $url, \WP_Term $collection, $args = array() ) {
		$title = isset( $args['title'] ) ? wp_strip_all_tags( trim( sanitize_text_field( $args['title'] ) ) ) : '';
		?>
		<!doctype html>
		<html <?php language_attributes(); ?>>
		<head>
			<meta charset="<?php bloginfo( 'charset' ); ?>">
			<meta name="viewport" content="width=device-width, initial-scale=1">
			<title><?php esc_html_e( 'Could not save article', 'post-collection' ); ?></title>
			<?php wp_head(); ?>
		</head>
		<body>
			<main style="max-width: 680px; margin: 48px auto; padding: 0 20px; font-family: sans-serif;">
				<h1><?php esc_html_e( 'Could not save article', 'post-collection' ); ?></h1>
				<p><?php echo esc_html( $error->get_error_message() ); ?></p>
				<p><a href="<?php echo esc_url( $url ); ?>" target="_blank" rel="noopener noreferrer"><?php echo esc_html( $url ); ?></a></p>
				<form method="post">
					<input type="hidden" name="post_collection_action" value="manual-save">
					<input type="hidden" name="collection" value="<?php echo esc_attr( $collection->term_id ); ?>">
					<input type="hidden" name="collect-post" value="<?php echo esc_attr( $url ); ?>">
					<input type="hidden" name="title" value="<?php echo esc_attr( $title ); ?>">
					<?php wp_nonce_field( 'post-collection-manual-save' ); ?>
					<p>
						<button type="submit"><?php esc_html_e( 'Save anyway and edit', 'post-collection' ); ?></button>
					</p>
				</form>
			</main>
			<?php wp_footer(); ?>
		</body>
		</html>
		<?php
	}

	/**
	 * Find a collected post in a collection term by source URL.
	 *
	 * @param string   $url        Source URL.
	 * @param \WP_Term $collection Collection term.
	 * @return int|null Post ID if found.
	 */
	private function url_to_collection_term_postid( $url, \WP_Term $collection ) {
		global $wpdb;

		if ( ! $wpdb || empty( $wpdb->posts ) ) {
			$posts = get_posts(
				array(
					'post_type'      => self::CPT,
					'post_status'    => array( 'publish', 'private', 'trash' ),
					'posts_per_page' => -1,
				)
			);

			foreach ( $posts as $post ) {
				if ( $url === $post->guid && has_term( (int) $collection->term_id, self::COLLECTION_TAXONOMY, $post ) ) {
					return (int) $post->ID;
				}
			}

			return null;
		}

		$post_id = $wpdb->get_var(
			$wpdb->prepare(
				"SELECT p.ID
				FROM {$wpdb->posts} p
				INNER JOIN {$wpdb->term_relationships} tr ON p.ID = tr.object_id
				INNER JOIN {$wpdb->term_taxonomy} tt ON tr.term_taxonomy_id = tt.term_taxonomy_id
				WHERE p.guid = %s
					AND p.post_type = %s
					AND tt.taxonomy = %s
					AND tt.term_id = %d
				LIMIT 1",
				$url,
				self::CPT,
				self::COLLECTION_TAXONOMY,
				$collection->term_id
			)
		);

		return $post_id ? (int) $post_id : null;
	}

	/**
	 * Save a URL to a taxonomy-backed collection.
	 *
	 * @param string   $url        Source URL.
	 * @param \WP_Term $collection Collection term.
	 * @param string   $content    Optional HTML content.
	 * @return int|\WP_Error Post ID or error.
	 */
	private function save_url_to_collection_term( $url, \WP_Term $collection, $content = null, $args = array() ) {
		if ( ! is_string( $url ) || ! $this->check_url( $url ) ) {
			return new \WP_Error( 'invalid-url', __( 'You entered an invalid URL.', 'post-collection' ) );
		}

		$return_details = ! empty( $args['return_details'] );
		$title_override = '';
		if ( isset( $args['title'] ) ) {
			$title_override = wp_strip_all_tags( trim( sanitize_text_field( $args['title'] ) ) );
		}

		$tags = array();
		if ( isset( $args['tags'] ) && is_array( $args['tags'] ) ) {
			$tags = array_values(
				array_filter(
					array_map(
						function ( $tag ) {
							return sanitize_text_field( wp_strip_all_tags( trim( $tag ) ) );
						},
						$args['tags']
					)
				)
			);
		}

		$post_id = $this->url_to_collection_term_postid( $url, $collection );
		if ( $post_id ) {
			wp_untrash_post( $post_id );
			if ( $title_override ) {
				$updated_post = wp_update_post(
					array(
						'ID'         => $post_id,
						'post_title' => $title_override,
					),
					true
				);
				if ( is_wp_error( $updated_post ) ) {
					return $updated_post;
				}
			}

			if ( $tags ) {
				$terms = wp_set_post_terms( $post_id, $tags, $this->get_tag_taxonomy(), true );
				if ( is_wp_error( $terms ) ) {
					return $terms;
				}
			}

			if ( $return_details ) {
				return array(
					'post_id'           => (int) $post_id,
					'created'           => false,
					'content_extracted' => false,
					'word_count'        => $this->get_post_word_count( $post_id ),
				);
			}

			return (int) $post_id;
		}

		$item = $this->download( $url, $content );
		if ( is_wp_error( $item ) ) {
			return $item;
		}

		if ( ! $item->content ) {
			return new \WP_Error(
				'invalid-content',
				__( 'No content was extracted.', 'post-collection' ),
				array(
					'status' => 422,
					'url'    => $url,
				)
			);
		}

		$title = $item->title ? wp_strip_all_tags( trim( $item->title ) ) : '';
		if ( ! $title ) {
			$path = trim( (string) wp_parse_url( $url, PHP_URL_PATH ), '/' );
			$parts = explode( '/', $path );
			$title = ucwords( strtr( end( $parts ), '-', ' ' ) );
		}
		if ( $title_override ) {
			$title = $title_override;
		}

		$post_id = wp_insert_post(
			array(
				'post_status'  => 'private',
				'post_author'  => get_current_user_id(),
				'guid'         => $url,
				'post_type'    => self::CPT,
				'post_title'   => $title,
				'post_content' => ! empty( $item->raw_html ) ? $item->raw_html : '',
			),
			true
		);
		if ( is_wp_error( $post_id ) ) {
			return $post_id;
		}

		wp_set_object_terms( $post_id, array( (int) $collection->term_id ), self::COLLECTION_TAXONOMY, false );

		$content_extracted = false;
		if ( $item->content ) {
			wp_update_post(
				array(
					'ID'           => $post_id,
					'post_content' => force_balance_tags( trim( wp_kses_post( $item->content ) ) ),
				)
			);
			$content_extracted = true;
		}

		if ( $item->author ) {
			update_post_meta( $post_id, 'author', $item->author );
		}

		if ( $tags ) {
			$terms = wp_set_post_terms( $post_id, $tags, $this->get_tag_taxonomy(), true );
			if ( is_wp_error( $terms ) ) {
				return $terms;
			}
		}

		if ( $return_details ) {
			return array(
				'post_id'           => (int) $post_id,
				'created'           => true,
				'content_extracted' => $content_extracted,
				'word_count'        => $this->get_post_word_count( $post_id ),
			);
		}

		return (int) $post_id;
	}

	/**
	 * Count words in a collected post.
	 *
	 * @param int $post_id Post ID.
	 * @return int Word count.
	 */
	private function get_post_word_count( $post_id ) {
		$post = get_post( $post_id );
		if ( ! $post ) {
			return 0;
		}

		$charset = function_exists( 'get_bloginfo' ) && get_bloginfo( 'charset' ) ? get_bloginfo( 'charset' ) : 'UTF-8';
		$content = html_entity_decode( wp_strip_all_tags( $post->post_content ), ENT_QUOTES, $charset );

		return str_word_count( $content );
	}

	/**
	 * Parse import text into unique URLs.
	 *
	 * @param string $raw_import Plain text, bookmark export HTML, or mixed pasted content.
	 * @return array URL strings.
	 */
	public function parse_import_urls( $raw_import ) {
		return array_map(
			function ( $item ) {
				return $item['url'];
			},
			$this->parse_import_items( $raw_import )
		);
	}

	/**
	 * Parse import text into unique import items.
	 *
	 * @param string $raw_import Plain text, bookmark HTML, CSV, RSS, or Atom.
	 * @param string $filename Optional source filename.
	 * @return array Import items.
	 */
	public function parse_import_items( $raw_import, $filename = '' ) {
		$raw_import = (string) $raw_import;
		$extension  = strtolower( pathinfo( (string) $filename, PATHINFO_EXTENSION ) );
		$trimmed    = ltrim( $raw_import );

		if ( 'csv' === $extension || $this->looks_like_csv_import( $raw_import ) ) {
			return $this->deduplicate_import_items( $this->parse_csv_import_items( $raw_import ) );
		}

		if ( in_array( $extension, array( 'xml', 'rss', 'atom' ), true ) || 0 === strpos( $trimmed, '<?xml' ) || 0 === strpos( $trimmed, '<rss' ) || 0 === strpos( $trimmed, '<feed' ) ) {
			$items = $this->parse_feed_import_items( $raw_import );
			if ( $items ) {
				return $this->deduplicate_import_items( $items );
			}
		}

		return $this->deduplicate_import_items( $this->parse_text_import_items( $raw_import ) );
	}

	/**
	 * Parse multiple import sources.
	 *
	 * @param array $sources Import source arrays with content and filename keys.
	 * @return array Import items.
	 */
	public function parse_import_sources( array $sources ) {
		$items = array();
		foreach ( $sources as $source ) {
			if ( ! is_array( $source ) ) {
				continue;
			}

			$items = array_merge(
				$items,
				$this->parse_import_items(
					isset( $source['content'] ) ? $source['content'] : '',
					isset( $source['filename'] ) ? $source['filename'] : ''
				)
			);
		}

		return $this->deduplicate_import_items( $items );
	}

	/**
	 * Detect whether text appears to be a URL export CSV.
	 *
	 * @param string $raw_import Import text.
	 * @return bool
	 */
	private function looks_like_csv_import( $raw_import ) {
		$line = strtok( (string) $raw_import, "\r\n" );
		if ( false === $line || false === strpos( $line, ',' ) ) {
			return false;
		}

		$headers = array_map( array( $this, 'normalize_import_header' ), str_getcsv( $line ) );
		return (bool) array_intersect( $headers, array( 'url', 'href', 'link', 'resolved_url', 'given_url' ) );
	}

	/**
	 * Parse a CSV import source.
	 *
	 * @param string $raw_import CSV text.
	 * @return array Import items.
	 */
	private function parse_csv_import_items( $raw_import ) {
		// phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fopen -- php://temp is an in-memory stream, not a file on disk, so WP_Filesystem cannot be used.
		$handle = fopen( 'php://temp', 'r+' );
		if ( ! $handle ) {
			return array();
		}

		// phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fwrite -- Writing to the in-memory stream opened above.
		fwrite( $handle, (string) $raw_import );
		rewind( $handle );

		$headers = fgetcsv( $handle );
		if ( ! is_array( $headers ) ) {
			fclose( $handle ); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fclose -- Closing the in-memory php://temp stream opened above.
			return array();
		}

		$headers    = array_map( array( $this, 'normalize_import_header' ), $headers );
		$url_index  = $this->find_import_column( $headers, array( 'url', 'href', 'link', 'resolved_url', 'given_url' ) );
		$title_index = $this->find_import_column( $headers, array( 'title', 'item_title', 'resolved_title', 'given_title', 'name' ) );
		$tags_index = $this->find_import_column( $headers, array( 'tags', 'tag' ) );
		$items      = array();

		if ( null === $url_index ) {
			fclose( $handle ); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fclose -- Closing the in-memory php://temp stream opened above.
			return array();
		}

		while ( false !== ( $row = fgetcsv( $handle ) ) ) {
			$items[] = $this->normalize_import_item(
				array(
					'url'   => isset( $row[ $url_index ] ) ? $row[ $url_index ] : '',
					'title' => null !== $title_index && isset( $row[ $title_index ] ) ? $row[ $title_index ] : '',
					'tags'  => null !== $tags_index && isset( $row[ $tags_index ] ) ? $this->split_import_tags( $row[ $tags_index ] ) : array(),
				)
			);
		}

		fclose( $handle ); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fclose -- Closing the in-memory php://temp stream opened above.
		return $items;
	}

	/**
	 * Parse RSS or Atom feed text.
	 *
	 * @param string $raw_import XML text.
	 * @return array Import items.
	 */
	private function parse_feed_import_items( $raw_import ) {
		if ( ! function_exists( 'simplexml_load_string' ) ) {
			return array();
		}

		$previous = libxml_use_internal_errors( true );
		$xml      = simplexml_load_string( (string) $raw_import, 'SimpleXMLElement', LIBXML_NONET | LIBXML_NOCDATA );
		libxml_clear_errors();
		libxml_use_internal_errors( $previous );

		if ( ! $xml ) {
			return array();
		}

		$items = array();
		if ( 'opml' === strtolower( $xml->getName() ) ) {
			return $this->parse_opml_outlines( $xml->body );
		}

		if ( isset( $xml->channel->item ) ) {
			foreach ( $xml->channel->item as $item ) {
				$tags = array();
				foreach ( $item->category as $category ) {
					$tags[] = (string) $category;
				}
				$items[] = $this->normalize_import_item(
					array(
						'url'   => (string) $item->link,
						'title' => (string) $item->title,
						'tags'  => $tags,
					)
				);
			}
		} elseif ( 'feed' === strtolower( $xml->getName() ) ) {
			foreach ( $xml->entry as $entry ) {
				$url = '';
				foreach ( $entry->link as $link ) {
					$attrs = $link->attributes();
					$rel   = isset( $attrs['rel'] ) ? (string) $attrs['rel'] : 'alternate';
					if ( isset( $attrs['href'] ) && 'alternate' === $rel ) {
						$url = (string) $attrs['href'];
						break;
					}
				}
				$tags = array();
				foreach ( $entry->category as $category ) {
					$attrs = $category->attributes();
					$tags[] = isset( $attrs['term'] ) ? (string) $attrs['term'] : (string) $category;
				}
				$items[] = $this->normalize_import_item(
					array(
						'url'   => $url,
						'title' => (string) $entry->title,
						'tags'  => $tags,
					)
				);
			}
		}

		return $items;
	}

	/**
	 * Recursively collect link outlines from an OPML body.
	 *
	 * Outlines are read in document order. Each outline that carries a URL
	 * becomes an item; nested outlines are visited too, so folders work.
	 *
	 * @param \SimpleXMLElement|null $node Parent element.
	 * @return array Import items.
	 */
	private function parse_opml_outlines( $node ) {
		$items = array();
		if ( ! $node instanceof \SimpleXMLElement ) {
			return $items;
		}

		foreach ( $node->outline as $outline ) {
			$attrs = $outline->attributes();
			$url   = '';
			foreach ( array( 'url', 'htmlUrl', 'xmlUrl' ) as $attribute ) {
				if ( isset( $attrs[ $attribute ] ) && trim( (string) $attrs[ $attribute ] ) ) {
					$url = (string) $attrs[ $attribute ];
					break;
				}
			}

			if ( $url ) {
				$title = isset( $attrs['title'] ) ? (string) $attrs['title'] : '';
				if ( '' === $title && isset( $attrs['text'] ) ) {
					$title = (string) $attrs['text'];
				}

				$tags = array();
				if ( isset( $attrs['category'] ) ) {
					foreach ( explode( ',', (string) $attrs['category'] ) as $category ) {
						$tags[] = ltrim( trim( $category ), '/' );
					}
				}

				$items[] = $this->normalize_import_item(
					array(
						'url'   => $url,
						'title' => $title,
						'tags'  => $tags,
					)
				);
			}

			$items = array_merge( $items, $this->parse_opml_outlines( $outline ) );
		}

		return $items;
	}

	/**
	 * Build a Netscape bookmarks HTML file.
	 *
	 * This is the format browsers, Pinboard, Raindrop and most read-later
	 * services import. Each group becomes a folder. Tags go into the TAGS
	 * attribute, the note into DD and unread items are flagged with TOREAD,
	 * all of which Pinboard-style importers understand and others ignore.
	 *
	 * @param array $groups Groups with title and items keys (see get_collection_export_items()).
	 * @return string
	 */
	public function build_bookmarks_html_export( array $groups ) {
		$now   = time();
		$lines = array(
			'<!DOCTYPE NETSCAPE-Bookmark-file-1>',
			'<!-- This is an automatically generated file.',
			'     It will be read and overwritten.',
			'     DO NOT EDIT! -->',
			'<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8">',
			'<TITLE>Bookmarks</TITLE>',
			'<H1>Bookmarks</H1>',
			'<DL><p>',
		);

		foreach ( $groups as $group ) {
			$lines[] = '    <DT><H3 ADD_DATE="' . $now . '" LAST_MODIFIED="' . $now . '">' . esc_html( $group['title'] ) . '</H3>';
			$lines[] = '    <DL><p>';

			foreach ( $group['items'] as $item ) {
				$item  = $this->normalize_export_item( $item );
				$attrs = ' HREF="' . esc_url( $item['url'] ) . '" ADD_DATE="' . $item['created'] . '"';
				if ( $item['modified'] ) {
					$attrs .= ' LAST_MODIFIED="' . $item['modified'] . '"';
				}
				if ( $item['tags'] ) {
					$attrs .= ' TAGS="' . esc_attr( implode( ',', $item['tags'] ) ) . '"';
				}
				if ( $item['unread'] ) {
					$attrs .= ' TOREAD="1"';
				}
				$lines[] = '        <DT><A' . $attrs . '>' . esc_html( $item['title'] ? $item['title'] : $item['url'] ) . '</A>';
				if ( '' !== $item['description'] ) {
					$lines[] = '        <DD>' . esc_html( $item['description'] );
				}
			}

			$lines[] = '    </DL><p>';
		}

		$lines[] = '</DL><p>';

		return implode( "\n", $lines ) . "\n";
	}

	/**
	 * Build an OPML 2.0 file of link outlines.
	 *
	 * Each group becomes an outline holding one outline of type "link" per
	 * article; tags are in the OPML category attribute and the note in
	 * description.
	 *
	 * @param array  $groups Groups with title and items keys (see get_collection_export_items()).
	 * @param string $title  Document title.
	 * @param string $owner  Optional owner name.
	 * @return string
	 */
	public function build_opml_export( array $groups, $title, $owner = '' ) {
		$now   = gmdate( DATE_RFC2822 );
		$lines = array(
			'<?xml version="1.0" encoding="UTF-8"?>',
			'<opml version="2.0">',
			'	<head>',
			'		<title>' . esc_html( $title ) . '</title>',
			'		<dateCreated>' . $now . '</dateCreated>',
		);
		if ( '' !== $owner ) {
			$lines[] = '		<ownerName>' . esc_html( $owner ) . '</ownerName>';
		}
		$lines[] = '	</head>';
		$lines[] = '	<body>';

		foreach ( $groups as $group ) {
			$lines[] = '		<outline text="' . esc_attr( $group['title'] ) . '" title="' . esc_attr( $group['title'] ) . '">';

			foreach ( $group['items'] as $item ) {
				$item  = $this->normalize_export_item( $item );
				$label = esc_attr( $item['title'] ? $item['title'] : $item['url'] );
				$attrs = ' type="link" text="' . $label . '" title="' . $label . '" url="' . esc_url( $item['url'] ) . '"';
				$attrs .= ' created="' . gmdate( DATE_RFC2822, $item['created'] ) . '"';
				if ( $item['tags'] ) {
					$attrs .= ' category="' . esc_attr( implode( ',', $item['tags'] ) ) . '"';
				}
				if ( '' !== $item['description'] ) {
					$attrs .= ' description="' . esc_attr( $item['description'] ) . '"';
				}
				$lines[] = '			<outline' . $attrs . '/>';
			}

			$lines[] = '		</outline>';
		}

		$lines[] = '	</body>';
		$lines[] = '</opml>';

		return implode( "\n", $lines ) . "\n";
	}

	/**
	 * Fill in defaults for an export item.
	 *
	 * @param array $item Export item.
	 * @return array
	 */
	private function normalize_export_item( array $item ) {
		$item = wp_parse_args(
			$item,
			array(
				'url'         => '',
				'title'       => '',
				'tags'        => array(),
				'created'     => time(),
				'modified'    => 0,
				'description' => '',
				'unread'      => false,
			)
		);

		$item['tags']        = array_values( array_filter( array_map( 'strval', (array) $item['tags'] ) ) );
		$item['created']     = (int) $item['created'];
		$item['modified']    = (int) $item['modified'];
		$item['description'] = trim( wp_strip_all_tags( (string) $item['description'] ) );
		$item['unread']      = ! empty( $item['unread'] );

		return $item;
	}

	/**
	 * Parse loose text and bookmark HTML.
	 *
	 * @param string $raw_import Import text.
	 * @return array Import items.
	 */
	private function parse_text_import_items( $raw_import ) {
		$charset    = function_exists( 'get_bloginfo' ) && get_bloginfo( 'charset' ) ? get_bloginfo( 'charset' ) : 'UTF-8';
		$raw_import = html_entity_decode( (string) $raw_import, ENT_QUOTES, $charset );
		$items      = array();

		if ( preg_match_all( '/<a\b[^>]*href=[\'"]([^\'"]+)[\'"][^>]*>(.*?)<\/a>/is', $raw_import, $matches, PREG_SET_ORDER ) ) {
			foreach ( $matches as $match ) {
				$items[] = $this->normalize_import_item(
					array(
						'url'   => $match[1],
						'title' => wp_strip_all_tags( $match[2] ),
					)
				);
			}
		}

		if ( preg_match_all( '#https?://[^\s<>"\']+#i', $raw_import, $matches ) ) {
			foreach ( $matches[0] as $url ) {
				$items[] = $this->normalize_import_item( array( 'url' => $url ) );
			}
		}

		return $items;
	}

	/**
	 * Normalize an import item.
	 *
	 * @param array $item Import item.
	 * @return array
	 */
	private function normalize_import_item( array $item ) {
		$url    = isset( $item['url'] ) ? trim( (string) $item['url'] ) : '';
		$url    = preg_replace( '/[)\].,;:]+$/', '', $url );
		$url    = esc_url_raw( $url );
		$scheme = strtolower( (string) wp_parse_url( $url, PHP_URL_SCHEME ) );

		if ( ! in_array( $scheme, array( 'http', 'https' ), true ) || ! $url || ! $this->check_url( $url ) ) {
			$url = '';
		}

		return array(
			'url'   => $url,
			'title' => isset( $item['title'] ) ? wp_strip_all_tags( trim( sanitize_text_field( $item['title'] ) ) ) : '',
			'tags'  => isset( $item['tags'] ) && is_array( $item['tags'] ) ? $this->sanitize_import_tags( $item['tags'] ) : array(),
		);
	}

	/**
	 * Deduplicate and remove invalid import items.
	 *
	 * @param array $items Import items.
	 * @return array
	 */
	private function deduplicate_import_items( array $items ) {
		$clean_items = array();
		foreach ( $items as $item ) {
			if ( empty( $item['url'] ) ) {
				continue;
			}

			$key = strtolower( $item['url'] );
			if ( isset( $clean_items[ $key ] ) ) {
				continue;
			}

			$clean_items[ $key ] = $item;
		}

		return array_values( $clean_items );
	}

	/**
	 * Normalize a CSV header.
	 *
	 * @param string $header Header text.
	 * @return string
	 */
	private function normalize_import_header( $header ) {
		return trim( preg_replace( '/[^a-z0-9]+/', '_', strtolower( (string) $header ) ), '_' );
	}

	/**
	 * Find a matching CSV column index.
	 *
	 * @param array $headers Header names.
	 * @param array $candidates Candidate names.
	 * @return int|null
	 */
	private function find_import_column( array $headers, array $candidates ) {
		foreach ( $candidates as $candidate ) {
			$index = array_search( $candidate, $headers, true );
			if ( false !== $index ) {
				return (int) $index;
			}
		}

		return null;
	}

	/**
	 * Split tag text from imports.
	 *
	 * @param string $raw_tags Raw tag text.
	 * @return array
	 */
	private function split_import_tags( $raw_tags ) {
		return $this->sanitize_import_tags( preg_split( '/[,|;]+/', (string) $raw_tags ) );
	}

	/**
	 * Sanitize import tag names.
	 *
	 * @param array $tags Tag names.
	 * @return array
	 */
	private function sanitize_import_tags( array $tags ) {
		$tags = array_map(
			function ( $tag ) {
				return sanitize_text_field( wp_strip_all_tags( trim( (string) $tag ) ) );
			},
			$tags
		);

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

	/**
	 * Import URLs into a taxonomy-backed collection.
	 *
	 * @param \WP_Term $collection Collection term.
	 * @param string   $raw_import Plain text or exported bookmark HTML.
	 * @return array Import summary.
	 */
	public function import_urls_to_collection( \WP_Term $collection, $raw_import, $filename = '' ) {
		$all_items = array();
		if ( is_array( $raw_import ) ) {
			$all_items = $this->parse_import_sources( $raw_import );
		} else {
			$all_items = $this->parse_import_items( $raw_import, $filename );
		}

		$items    = $all_items;
		$max      = (int) apply_filters( 'post_collection_import_url_limit', 100, $collection );

		if ( $max > 0 && count( $items ) > $max ) {
			$items = array_slice( $items, 0, $max );
		}

		$result = array(
			'total'     => count( $items ),
			'created'   => 0,
			'existing'  => 0,
			'imported'  => 0,
			'failed'    => 0,
			'errors'    => array(),
			'truncated' => $max > 0 && count( $all_items ) > $max,
			'limit'     => $max,
		);

		foreach ( $items as $item ) {
			$save = $this->import_item_to_collection( $collection, $item );

			if ( is_wp_error( $save ) ) {
				$result['failed']++;
				$result['errors'][] = array(
					'url'     => $item['url'],
					'message' => $save->get_error_message(),
				);
				continue;
			}

			$result['imported']++;
			if ( ! empty( $save['created'] ) ) {
				$result['created']++;
			} else {
				$result['existing']++;
			}
		}

		return $result;
	}

	/**
	 * Import one normalized item into a taxonomy-backed collection.
	 *
	 * @param \WP_Term $collection Collection term.
	 * @param array    $item Import item.
	 * @return array|\WP_Error Imported item result.
	 */
	public function import_item_to_collection( \WP_Term $collection, array $item ) {
		$item = $this->normalize_import_item( $item );
		if ( empty( $item['url'] ) ) {
			return new \WP_Error( 'invalid-url', __( 'You entered an invalid URL.', 'post-collection' ), array( 'status' => 400 ) );
		}

		$save = $this->save_url_to_collection_term(
			$item['url'],
			$collection,
			null,
			array(
				'title'          => $item['title'],
				'tags'           => $item['tags'],
				'return_details' => true,
			)
		);

		if ( is_wp_error( $save ) ) {
			return $save;
		}

		$post_id = (int) $save['post_id'];

		return array(
			'post_id'           => $post_id,
			'url'               => $item['url'],
			'title'             => get_the_title( $post_id ),
			'created'           => ! empty( $save['created'] ),
			'content_extracted' => ! empty( $save['content_extracted'] ),
			'word_count'        => isset( $save['word_count'] ) ? (int) $save['word_count'] : 0,
		);
	}

	/**
	 * Download and save the URL content
	 *
	 * @param  string $url The URL to save.
	 * @param  User   $friend_user  The user.
	 * @param  string $content      The content.
	 * @return \WP_Error    Potentially an error message.
	 */
	public function save_url( $url, User $friend_user, $content = null ) {
		$post_id = $this->save_url_to_collection( $url, $friend_user, $content );
		if ( is_wp_error( $post_id ) ) {
			return $post_id;
		}

		wp_safe_redirect( $friend_user->get_local_friends_page_url( $post_id ) );
		exit;
	}

	/**
	 * Save a URL to a post collection without redirecting.
	 *
	 * @param  string $url         The URL to save.
	 * @param  User   $friend_user The post collection user.
	 * @param  string $content     Optional HTML content.
	 * @param  array  $args        Optional arguments: title, tags, and return_details.
	 * @return int|array|\WP_Error The saved post ID, details, or an error.
	 */
	private function save_url_to_collection( $url, User $friend_user, $content = null, $args = array() ) {
		if ( ! is_string( $url ) || ! $this->check_url( $url ) ) {
			return new \WP_Error( 'invalid-url', __( 'You entered an invalid URL.', 'post-collection' ) );
		}

		$return_details = ! empty( $args['return_details'] );
		$title_override = '';
		if ( isset( $args['title'] ) ) {
			$title_override = wp_strip_all_tags( trim( sanitize_text_field( $args['title'] ) ) );
		}

		$tags = array();
		if ( isset( $args['tags'] ) && is_array( $args['tags'] ) ) {
			$tags = array_values(
				array_filter(
					array_map(
						function ( $tag ) {
							return sanitize_text_field( wp_strip_all_tags( trim( $tag ) ) );
						},
						$args['tags']
					)
				)
			);
		}

		$post_id = $this->url_to_postid( $url, $friend_user->ID );
		$created           = false;
		$content_extracted = false;
		if ( is_null( $post_id ) ) {
			$item = $this->download( $url, $content );
			if ( is_wp_error( $item ) ) {
				return $item;
			}

			if ( ! $item->content ) {
				return new \WP_Error(
					'invalid-content',
					__( 'No content was extracted.', 'post-collection' ),
					array(
						'status' => 422,
						'url'    => $url,
					)
				);
			}

			$title = '';
			if ( $item->title ) {
				$title = wp_strip_all_tags( trim( $item->title ) );
			}
			if ( ! $title ) {
				$path = wp_parse_url( $url, PHP_URL_PATH );
				$path = trim( $path, '/' );
				$path = explode( '/', $path );
				$slug = end( $path );
				$slug = strtr( $slug, '-', ' ' );
				$title = ucwords( $slug );
			}
			if ( $title_override ) {
				$title = $title_override;
			}

			$post_data = array(
				'post_status'  => 'private',
				'post_author'  => $friend_user->ID,
				'guid'         => $url,
				'post_type'    => self::CPT,
				'post_title'   => $title,
				'post_content' => ! empty( $item->raw_html ) ? $item->raw_html : '',
			);

			$post_id = wp_insert_post( $post_data, true );
			if ( is_wp_error( $post_id ) ) {
				return $post_id;
			}

			if ( $item->content ) {
				$extracted_content = force_balance_tags( trim( wp_kses_post( $item->content ) ) );
				wp_update_post(
					array(
						'ID'           => $post_id,
						'post_content' => $extracted_content,
					)
				);
				$content_extracted = true;
			}

			if ( $item->author ) {
				update_post_meta( $post_id, 'author', $item->author );
			}
			$created = true;
		} elseif ( $title_override ) {
			$updated_post = wp_update_post(
				array(
					'ID'         => $post_id,
					'post_title' => $title_override,
				),
				true
			);
			if ( is_wp_error( $updated_post ) ) {
				return $updated_post;
			}
		}

		wp_untrash_post( $post_id );

		if ( $tags ) {
			$terms = wp_set_post_terms( $post_id, $tags, $this->get_tag_taxonomy(), true );
			if ( is_wp_error( $terms ) ) {
				return $terms;
			}
		}

		if ( $return_details ) {
			return array(
				'post_id'           => (int) $post_id,
				'created'           => $created,
				'content_extracted' => $content_extracted,
			);
		}

		return (int) $post_id;
	}

	/**
	 * Save a URL to a post collection and return the saved post ID.
	 *
	 * @param  string $url         The URL to save.
	 * @param  User   $friend_user The post collection user.
	 * @param  string $content     Optional HTML content.
	 * @param  array  $args        Optional arguments: title and tags.
	 * @return int|\WP_Error The saved post ID or an error.
	 */
	public function save_url_for_collection( $url, User $friend_user, $content = null, $args = array() ) {
		return $this->save_url_to_collection( $url, $friend_user, $content, $args );
	}

	/**
	 * Handle inline save actions relayed by the Friends browser extension.
	 *
	 * @param mixed            $response     The previous action response.
	 * @param \WP_REST_Request $request      The REST request.
	 * @param \WP_User         $current_user The user authenticated by Friends.
	 * @param array            $context      Browser extension request context.
	 * @return array|\WP_Error The action response.
	 */
	public function friends_browser_extension_action_save( $response, \WP_REST_Request $request, \WP_User $current_user, $context ) {
		if ( null !== $response ) {
			return $response;
		}

		if ( ! current_user_can( $this->get_required_role() ) ) {
			return new \WP_Error(
				'forbidden',
				__( 'You are not allowed to save to post collections.', 'post-collection' ),
				array( 'status' => 403 )
			);
		}

		$collection_id = absint( $request->get_param( 'collection_id' ) );
		$collection    = get_term( $collection_id, self::COLLECTION_TAXONOMY );
		if ( ! $collection || is_wp_error( $collection ) ) {
			return new \WP_Error(
				'invalid-collection',
				__( 'Invalid post collection.', 'post-collection' ),
				array( 'status' => 404 )
			);
		}

		if ( get_term_meta( $collection->term_id, 'friends_post_collection_inactive', true ) ) {
			return new \WP_Error(
				'inactive-collection',
				__( 'This post collection is inactive.', 'post-collection' ),
				array( 'status' => 403 )
			);
		}

		$url = esc_url_raw( trim( (string) wp_unslash( $request->get_param( 'url' ) ) ) );
		if ( ! $this->check_url( $url ) ) {
			return new \WP_Error(
				'invalid-url',
				__( 'You entered an invalid URL.', 'post-collection' ),
				array( 'status' => 400 )
			);
		}

		$html = $request->get_param( 'html' );
		if ( null === $html ) {
			$html = $request->get_param( 'body' );
		}
		if ( null !== $html ) {
			$html = (string) wp_unslash( $html );
			$source_url = $this->get_source_url_from_site_configs( $url, $html );
			if ( $source_url ) {
				$url = $source_url;
			}
		}

		$title = '';
		if ( null !== $request->get_param( 'title' ) ) {
			$title = wp_strip_all_tags( trim( sanitize_text_field( wp_unslash( $request->get_param( 'title' ) ) ) ) );
		}

		$tags = $this->parse_extension_action_tags( $request->get_param( 'tags' ) );

		$post_id = $this->save_url_to_collection_term(
			$url,
			$collection,
			$html,
			array(
				'title'          => $title,
				'tags'           => $tags,
				'return_details' => true,
			)
		);

		if ( is_wp_error( $post_id ) ) {
			return $post_id;
		}

		$save_details = $post_id;
		$post_id      = $save_details['post_id'];
		$edit_url = get_edit_post_link( $post_id, 'raw' );
		$item_url = home_url( '/post-collection/' . $collection->slug . '/' . $post_id . '/' );
		$word_count = isset( $save_details['word_count'] ) ? (int) $save_details['word_count'] : 0;
		$word_count_label = sprintf(
			// translators: %d is the number of words in the saved article.
			__( '%d words', 'post-collection' ),
			$word_count
		);
		if ( ! empty( $save_details['content_extracted'] ) ) {
			$message = sprintf(
				// translators: 1: post collection name, 2: article word count.
				__( 'Saved extracted content to %1$s. %2$s.', 'post-collection' ),
				$collection->name,
				$word_count_label
			);
		} else {
			$message = sprintf(
				// translators: 1: post collection name, 2: article word count.
				__( 'Saved to %1$s. This URL was already in the collection. %2$s.', 'post-collection' ),
				$collection->name,
				$word_count_label
			);
		}

		return array(
			'success'           => true,
			'message'           => $message,
			'created'           => ! empty( $save_details['created'] ),
			'content_extracted' => ! empty( $save_details['content_extracted'] ),
			'word_count'        => $word_count,
			'word_count_label'  => $word_count_label,
			'edit_url'          => $edit_url ? $edit_url : '',
			'url'               => $item_url ? $item_url : '',
			'link_label'        => __( 'Open', 'post-collection' ),
		);
	}

	/**
	 * Resolve the source URL for posted page content via site configs.
	 *
	 * @param string $url     Submitted URL.
	 * @param string $content Posted page content.
	 * @return string Source URL or an empty string.
	 */
	private function get_source_url_from_site_configs( $url, $content ) {
		foreach ( $this->site_configs as $site_config ) {
			if ( ! $site_config->is_url_supported( $url ) ) {
				continue;
			}

			$source_url = $site_config->get_source_url( $url, $content );
			if ( $source_url && $this->check_url( $source_url ) ) {
				return $source_url;
			}
		}

		return '';
	}

	/**
	 * Parse tags submitted by the browser extension.
	 *
	 * @param string $raw_tags Comma or newline separated tags.
	 * @return array Tag names.
	 */
	private function parse_extension_action_tags( $raw_tags ) {
		if ( null === $raw_tags ) {
			return array();
		}

		$raw_tags = wp_strip_all_tags( trim( (string) wp_unslash( $raw_tags ) ) );
		if ( '' === $raw_tags ) {
			return array();
		}

		$raw_tags = str_replace( array( "\r\n", "\r" ), "\n", $raw_tags );
		$tags     = preg_split( '/[,\n]+/', $raw_tags );
		$tags     = array_values(
			array_filter(
				array_map(
					function ( $tag ) {
						return sanitize_text_field( trim( $tag ) );
					},
					$tags
				)
			)
		);

		return array_values( array_unique( $tags ) );
	}

	/**
	 * Download the url from the URL
	 *
	 * @param  string $url The URL to download.
	 * @param  string $content      The content.
	 * @return object An item object.
	 */
	public function download( $url, $content = null ) {
		foreach ( $this->site_configs as $site_config ) {
			if ( $site_config->is_url_supported( $url ) ) {
				$item = $site_config->download( $url, $content );
				if ( is_wp_error( $item ) ) {
					continue;
				}
				return $item;
			}
		}

		global $wp_version;
		$args = array(
			'timeout'     => 20,
			'redirection' => 5,
			'headers'     => array(
				'user-agent' => 'WordPress/' . $wp_version . '; ' . home_url( '/' ) . '; Friends/' . $this->get_friends_version(),
			),
		);

		if ( ! $content ) {
			$response = wp_safe_remote_get( $url, $args );
			if ( is_wp_error( $response ) ) {
				$error_data = $response->get_error_data();
				if ( ! is_array( $error_data ) ) {
					$error_data = array( 'error_data' => $error_data );
				}
				$error_data['status'] = 502;
				$error_data['url']    = $url;
				$response->add_data( $error_data );
				return $response;
			}
			if ( 200 !== wp_remote_retrieve_response_code( $response ) ) {
				$fallback_item = $this->maybe_download_cloudflare_protected_url( $url, wp_remote_retrieve_body( $response ), $response );
				if ( ! is_wp_error( $fallback_item ) ) {
					return $fallback_item;
				}

				return new \WP_Error(
					'could-not-download',
					__( 'Could not download the URL.', 'post-collection' ),
					array(
						'status'      => 502,
						'url'         => $url,
						'http_status' => wp_remote_retrieve_response_code( $response ),
						'http_body'   => wp_remote_retrieve_body( $response ),
					)
				);
			}
			$content = wp_remote_retrieve_body( $response );
		}

		$fallback_item = $this->maybe_download_cloudflare_protected_url( $url, $content, isset( $response ) ? $response : null );
		if ( ! is_wp_error( $fallback_item ) ) {
			return $fallback_item;
		}

		$item = $this->extract_content( $content, $url );
		if ( is_wp_error( $item ) ) {
			return $item;
		}
		$item->raw_html = $content;
		return $item;
	}

	/**
	 * Fetch URLs through Jina when a direct response is a Cloudflare challenge.
	 *
	 * @param string $url      The URL to download.
	 * @param string $content  Response body.
	 * @param array  $response Optional HTTP response.
	 * @return ExtractedPage|\WP_Error Extracted item or a non-fallback error.
	 */
	private function maybe_download_cloudflare_protected_url( $url, $content, $response = null ) {
		$cloudflare = new SiteConfig\Cloudflare_Protected();
		if ( ! $cloudflare->is_challenge_response( (string) $content, $response ) ) {
			return new \WP_Error( 'not-cloudflare-challenge', __( 'The response is not a Cloudflare challenge.', 'post-collection' ) );
		}

		return $cloudflare->download( $url );
	}

	/**
	 * Extract the content of a URL
	 *
	 * @param  string $html        The HTML from which to extract the content.
	 * @param  array  $url The url.
	 * @return object The parsed content.
	 */
	public function extract_content( $html, $url ) {
		$item = new ExtractedPage( $url );
		$html = $this->prepare_html_for_readability( $html );

		$config = new \andreskrey\Readability\Configuration();
		$logger = null;
		if ( class_exists( '\\Ozh\\Log\\Logger' ) ) {
			$logger = new \Ozh\Log\Logger();
			$config->setLogger( $logger );
		}
		$config->setFixRelativeURLs( true );
		$config->setOriginalURL( $url );
		$readability = new \andreskrey\Readability\Readability( $config );

		try {
			$readability->parse( $html );
			$item->title = $readability->getTitle();
			$item->content = $readability->getContent();
			$item->author = $readability->getAuthor();

			$item->content = str_replace( '&#xD;', '', $item->content );
			$item->content = $this->remove_artificial_line_breaks( $item->content );
		} catch ( \andreskrey\Readability\ParseException $e ) {
			return new \WP_Error(
				'could-not-extract-content',
				sprintf(
				// translators: $s is an error message.
					__( 'Error processing HTML: %s', 'post-collection' ),
					$e->getMessage()
				),
				array(
					'status' => 422,
					'logger' => $logger,
				)
			);
		} catch ( \Throwable $e ) {
			return new \WP_Error(
				'could-not-extract-content',
				sprintf(
				// translators: $s is an error message.
					__( 'Error processing HTML: %s', 'post-collection' ),
					$e->getMessage()
				),
				array(
					'status' => 422,
					'logger' => $logger,
				)
			);
		}

		return $item;
	}

	/**
	 * Remove obvious non-content markup before handing HTML to Readability.
	 *
	 * @param string $html HTML to prepare.
	 * @return string Prepared HTML.
	 */
	private function prepare_html_for_readability( $html ) {
		if ( ! class_exists( '\DOMDocument' ) || ! class_exists( '\DOMXPath' ) ) {
			return $html;
		}

		$previous_errors = libxml_use_internal_errors( true );
		$dom             = new \DOMDocument();
		$loaded          = $dom->loadHTML( '<?xml encoding="UTF-8">' . $html, LIBXML_NOWARNING | LIBXML_NOERROR );

		if ( ! $loaded ) {
			libxml_clear_errors();
			libxml_use_internal_errors( $previous_errors );
			return $html;
		}

		$xpath = new \DOMXPath( $dom );
		$title = '';
		$title_nodes = $xpath->query( '//title' );
		if ( $title_nodes && $title_nodes->length ) {
			$title = trim( $title_nodes->item( 0 )->textContent );
		}

		$rich_text_blocks = $xpath->query(
			'//*[contains(concat(" ", normalize-space(@class), " "), " u-rich-text-blog ") and contains(concat(" ", normalize-space(@class), " "), " w-richtext ")]'
		);

		if ( $rich_text_blocks && $rich_text_blocks->length ) {
			$body = '';
			foreach ( $rich_text_blocks as $node ) {
				$text = trim( preg_replace( '/\s+/', ' ', $node->textContent ) );
				if ( strlen( $text ) < 100 ) {
					continue;
				}
				$body .= $dom->saveHTML( $node );
			}

			if ( $body ) {
				libxml_clear_errors();
				libxml_use_internal_errors( $previous_errors );
				return '<html><head><title>' . htmlspecialchars( $title, ENT_QUOTES, 'UTF-8' ) . '</title></head><body><article>' . $body . '</article></body></html>';
			}
		}

		$remove_nodes = $xpath->query( '//script|//style|//noscript|//svg|//nav|//header|//footer|//template|//iframe' );
		if ( $remove_nodes ) {
			foreach ( iterator_to_array( $remove_nodes ) as $node ) {
				if ( $node->parentNode ) {
					$node->parentNode->removeChild( $node );
				}
			}
		}

		$prepared_html = $dom->saveHTML();
		libxml_clear_errors();
		libxml_use_internal_errors( $previous_errors );

		return $prepared_html ? $prepared_html : $html;
	}

	public function remove_artificial_line_breaks( $html ) {
		preg_match_all( '/<p[^>]*>(.*?)<\/p>/is', $html, $matches, PREG_SET_ORDER );

		foreach ( $matches as $match ) {
			$original = $match[0];
			$inner_html = $match[1];

			$cleaned = $this->remove_artificial_brs_from_paragraph( $inner_html );

			if ( $cleaned !== $inner_html ) {
				$replacement = str_replace( $inner_html, $cleaned, $original );
				$html = str_replace( $original, $replacement, $html );
			}
		}

		preg_match_all( '/<li[^>]*>(.*?)<\/li>/is', $html, $matches, PREG_SET_ORDER );

		foreach ( $matches as $match ) {
			$original = $match[0];
			$inner_html = $match[1];

			$cleaned = $this->remove_artificial_brs_from_paragraph( $inner_html );

			if ( $cleaned !== $inner_html ) {
				$replacement = str_replace( $inner_html, $cleaned, $original );
				$html = str_replace( $original, $replacement, $html );
			}
		}

		return $html;
	}

	private function remove_artificial_brs_from_paragraph( $text ) {
		$br_positions = array();
		$offset = 0;

		while ( false !== ( $pos = stripos( $text, '<br', $offset ) ) ) {
			$end = strpos( $text, '>', $pos );
			if ( false === $end ) {
				break;
			}

			$br_tag = substr( $text, $pos, $end - $pos + 1 );
			$br_positions[] = array(
				'pos'   => $pos,
				'end'   => $end + 1,
				'tag'   => $br_tag,
				'after' => substr( $text, $end + 1, 1 ),
			);

			$offset = $end + 1;
		}

		if ( empty( $br_positions ) ) {
			return $text;
		}

		if ( count( $br_positions ) < 2 ) {
			return $text;
		}

		$text_between_brs = array();
		for ( $i = 0; $i < count( $br_positions ) - 1; $i++ ) {
			$start = $br_positions[ $i ]['end'];
			$end = $br_positions[ $i + 1 ]['pos'];
			$between = substr( $text, $start, $end - $start );

			$text_between_brs[] = array(
				'text'   => $between,
				'length' => strlen( wp_strip_all_tags( $between ) ),
			);
		}

		$lengths = array_column( $text_between_brs, 'length' );
		$lengths = array_filter( $lengths, function( $len ) {
			return $len > 0;
		} );

		if ( empty( $lengths ) ) {
			return $text;
		}

		$avg_length = array_sum( $lengths ) / count( $lengths );
		$stddev = 0;
		if ( count( $lengths ) > 1 ) {
			$variance = 0;
			foreach ( $lengths as $len ) {
				$variance += pow( $len - $avg_length, 2 );
			}
			$stddev = sqrt( $variance / count( $lengths ) );
		}

		$coefficient_of_variation = $avg_length > 0 ? $stddev / $avg_length : 1;

		if ( $coefficient_of_variation > 0.3 ) {
			return $text;
		}

		$brs_to_remove = array();
		foreach ( $br_positions as $i => $br ) {
			$before = substr( $text, 0, $br['pos'] );
			$after = substr( $text, $br['end'] );

			$before_trimmed = rtrim( $before );
			$after_trimmed = ltrim( $after );

			if ( empty( $before_trimmed ) || empty( $after_trimmed ) ) {
				continue;
			}

			$last_char = substr( $before_trimmed, -1 );
			if ( in_array( $last_char, array( '.', '!', '?', ':', ';' ) ) ) {
				continue;
			}

			if ( preg_match( '/<\/[^>]+>$/', $before_trimmed ) ) {
				continue;
			}

			if ( preg_match( '/^<[^>]+>/', $after_trimmed ) && ! preg_match( '/^<(em|strong|i|b|a|code|span)[\s>]/i', $after_trimmed ) ) {
				continue;
			}

			$brs_to_remove[] = $br;
		}

		foreach ( array_reverse( $brs_to_remove ) as $br ) {
			$text = substr_replace( $text, ' ', $br['pos'], $br['end'] - $br['pos'] );
		}

		$text = preg_replace( '/\s+/', ' ', $text );

		return $text;
	}

	/**
	 * Extract the innerHTML of a node
	 *
	 * @param  object $node The DOM node or a DOMNodeList.
	 * @return string The innerHTML.
	 */
	private function get_inner_html( $node ) {
		$html = '';
		if ( $node instanceof \DOMNodeList ) {
			$nodelist = $node;
		} elseif ( isset( $node->childNodes ) ) { // @codingStandardsIgnoreLine
			$nodelist = $node->childNodes; // @codingStandardsIgnoreLine
		} else {
			return false;
		}

		foreach ( $nodelist as $child ) {
			$html .= $child->innerHTML; // @codingStandardsIgnoreLine
		}
		return $html;
		return $this->clean_html( $html );
	}

	/**
	 * Remove the node from the DOM.
	 *
	 * @param  object $node The DOM node or a DOMNodeList to remove.
	 */
	private function remove_node( $node ) {
		if ( $node instanceof \DOMNodeList ) {
			$nodelist = $node;
		} elseif ( isset( $node->childNodes ) ) { // @codingStandardsIgnoreLine
			$nodelist = $node->childNodes; // @codingStandardsIgnoreLine
		} else {
			return false;
		}

		foreach ( $nodelist as $child ) {
			$child->parentNode->removeChild( $child ); // @codingStandardsIgnoreLine
		}
	}

	/**
	 * Clean the HTML
	 *
	 * @param  string $html The HTML to be cleaned.
	 * @return string       The cleaned HTML.
	 */
	private function clean_html( $html ) {
		$html = preg_replace( '#\n\s*\n\s*#', PHP_EOL . PHP_EOL, trim( $html ) );

		return $html;
	}

	public function prevent_autop_brs( $text ) {
		// We do the same as wpautop but we replace the newline with a space.
		$br = true;

		$pre_tags = array();

		if ( trim( $text ) === '' ) {
			return '';
		}

		// Just to make things a little easier, pad the end.
		$text = $text . "\n";

		/*
		 * Pre tags shouldn't be touched by autop.
		 * Replace pre tags with placeholders and bring them back after autop.
		 */
		if ( str_contains( $text, '<pre' ) ) {
			$text_parts = explode( '</pre>', $text );
			$last_part  = array_pop( $text_parts );
			$text       = '';
			$i          = 0;

			foreach ( $text_parts as $text_part ) {
				$start = strpos( $text_part, '<pre' );

				// Malformed HTML?
				if ( false === $start ) {
					$text .= $text_part;
					continue;
				}

				$name              = "<pre wp-pre-tag-$i></pre>";
				$pre_tags[ $name ] = substr( $text_part, $start ) . '</pre>';

				$text .= substr( $text_part, 0, $start ) . $name;
				++$i;
			}

			$text .= $last_part;
		}
		// Change multiple <br>'s into two line breaks, which will turn into paragraphs.
		$text = preg_replace( '|<br\s*/?>\s*<br\s*/?>|', "\n\n", $text );

		$allblocks = '(?:table|thead|tfoot|caption|col|colgroup|tbody|tr|td|th|div|dl|dd|dt|ul|ol|li|pre|form|map|area|blockquote|address|style|p|h[1-6]|hr|fieldset|legend|section|article|aside|hgroup|header|footer|nav|figure|figcaption|details|menu|summary)';

		// Add a double line break above block-level opening tags.
		$text = preg_replace( '!(<' . $allblocks . '[\s/>])!', "\n\n$1", $text );

		// Add a double line break below block-level closing tags.
		$text = preg_replace( '!(</' . $allblocks . '>)!', "$1\n\n", $text );

		// Add a double line break after hr tags, which are self closing.
		$text = preg_replace( '!(<hr\s*?/?>)!', "$1\n\n", $text );

		// Standardize newline characters to "\n".
		$text = str_replace( array( "\r\n", "\r" ), "\n", $text );

		// Find newlines in all elements and add placeholders.
		$text = wp_replace_in_html_tags( $text, array( "\n" => ' <!-- wpnl --> ' ) );

		// Collapse line breaks before and after <option> elements so they don't get autop'd.
		if ( str_contains( $text, '<option' ) ) {
			$text = preg_replace( '|\s*<option|', '<option', $text );
			$text = preg_replace( '|</option>\s*|', '</option>', $text );
		}

		/*
		 * Collapse line breaks inside <object> elements, before <param> and <embed> elements
		 * so they don't get autop'd.
		 */
		if ( str_contains( $text, '</object>' ) ) {
			$text = preg_replace( '|(<object[^>]*>)\s*|', '$1', $text );
			$text = preg_replace( '|\s*</object>|', '</object>', $text );
			$text = preg_replace( '%\s*(</?(?:param|embed)[^>]*>)\s*%', '$1', $text );
		}

		/*
		 * Collapse line breaks inside <audio> and <video> elements,
		 * before and after <source> and <track> elements.
		 */
		if ( str_contains( $text, '<source' ) || str_contains( $text, '<track' ) ) {
			$text = preg_replace( '%([<\[](?:audio|video)[^>\]]*[>\]])\s*%', '$1', $text );
			$text = preg_replace( '%\s*([<\[]/(?:audio|video)[>\]])%', '$1', $text );
			$text = preg_replace( '%\s*(<(?:source|track)[^>]*>)\s*%', '$1', $text );
		}

		// Collapse line breaks before and after <figcaption> elements.
		if ( str_contains( $text, '<figcaption' ) ) {
			$text = preg_replace( '|\s*(<figcaption[^>]*>)|', '$1', $text );
			$text = preg_replace( '|</figcaption>\s*|', '</figcaption>', $text );
		}

		// Remove more than two contiguous line breaks.
		$text = preg_replace( "/\n\n+/", "\n\n", $text );

		// Split up the contents into an array of strings, separated by double line breaks.
		$paragraphs = preg_split( '/\n\s*\n/', $text, -1, PREG_SPLIT_NO_EMPTY );

		// Reset $text prior to rebuilding.
		$text = '';

		// Rebuild the content as a string, wrapping every bit with a <p>.
		foreach ( $paragraphs as $paragraph ) {
			$text .= '<p>' . trim( $paragraph, "\n" ) . "</p>\n";
		}

		// Under certain strange conditions it could create a P of entirely whitespace.
		$text = preg_replace( '|<p>\s*</p>|', '', $text );

		// Add a closing <p> inside <div>, <address>, or <form> tag if missing.
		$text = preg_replace( '!<p>([^<]+)</(div|address|form)>!', '<p>$1</p></$2>', $text );

		// If an opening or closing block element tag is wrapped in a <p>, unwrap it.
		$text = preg_replace( '!<p>\s*(</?' . $allblocks . '[^>]*>)\s*</p>!', '$1', $text );

		// In some cases <li> may get wrapped in <p>, fix them.
		$text = preg_replace( '|<p>(<li.+?)</p>|', '$1', $text );

		// If a <blockquote> is wrapped with a <p>, move it inside the <blockquote>.
		$text = preg_replace( '|<p><blockquote([^>]*)>|i', '<blockquote$1><p>', $text );
		$text = str_replace( '</blockquote></p>', '</p></blockquote>', $text );

		// If an opening or closing block element tag is preceded by an opening <p> tag, remove it.
		$text = preg_replace( '!<p>\s*(</?' . $allblocks . '[^>]*>)!', '$1', $text );

		// If an opening or closing block element tag is followed by a closing <p> tag, remove it.
		$text = preg_replace( '!(</?' . $allblocks . '[^>]*>)\s*</p>!', '$1', $text );

		// Optionally insert line breaks.
		if ( $br ) {
			// Replace newlines that shouldn't be touched with a placeholder.
			$text = preg_replace_callback( '/<(script|style|svg|math).*?<\/\\1>/s', '_autop_newline_preservation_helper', $text );

			// Normalize <br>
			$text = str_replace( array( '<br>', '<br/>' ), '<br />', $text );

			// Replace any new line characters that aren't preceded by a <br /> with a <br />.
			// Post Collection: This is the curical modification.
			$text = preg_replace( '|(?<!<br />)\s*\n|', ' ', $text );

			// Replace newline placeholders with newlines.
			$text = str_replace( '<WPPreserveNewline />', "\n", $text );
		}

		// If a <br /> tag is after an opening or closing block tag, remove it.
		$text = preg_replace( '!(</?' . $allblocks . '[^>]*>)\s*<br />!', '$1', $text );

		// If a <br /> tag is before a subset of opening or closing block tags, remove it.
		$text = preg_replace( '!<br />(\s*</?(?:p|li|div|dl|dd|dt|th|pre|td|ul|ol)[^>]*>)!', '$1', $text );
		$text = preg_replace( "|\n</p>$|", '</p>', $text );

		// Replace placeholder <pre> tags with their original content.
		if ( ! empty( $pre_tags ) ) {
			$text = str_replace( array_keys( $pre_tags ), array_values( $pre_tags ), $text );
		}

		// Restore newlines in all elements.
		if ( str_contains( $text, '<!-- wpnl -->' ) ) {
			$text = str_replace( array( ' <!-- wpnl --> ', '<!-- wpnl -->' ), "\n", $text );
		}

		return $text;
	}

	/**
	 * Overwrite the role name for a post collection user.
	 *
	 * @param      string   $name   The name.
	 * @param      \WP_User $user   The user.
	 *
	 * @return     string The potentially modified name.
	 */
	public function friend_user_role_name( $name, \WP_User $user ) {
		if ( ! $name && $user->has_cap( 'post_collection' ) ) {
			$name = _x( 'Post Collection', 'User role', 'post-collection' );
		}

		return $name;
	}

	/**
	 * Associate the role with the Friends plugin.
	 *
	 * @param      array $roles  The roles.
	 *
	 * @return     array  The roles with the added Post Collection.
	 */
	public function associate_friend_user_role( $roles ) {
		$roles[] = 'post_collection';
		return $roles;
	}

	public function friends_search_autocomplete( $results, $q ) {
		if ( $this->check_url( $q ) ) {
			foreach ( $this->get_post_collection_users()->get_results() as $user ) {
				if ( get_user_option( 'friends_post_collection_inactive', $user->ID ) ) {
					continue;
				}

				$result = '<a href="' . esc_url(
					add_query_arg(
						array(
							'collect-post' => $q,
							'user'         => $user->ID,
						),
						home_url()
					)
				) . '" class="has-icon-left">';
				$result .= '<span class="ab-icon dashicons dashicons-download"></span>';
				$result .= 'Save ';
				$result .= ' <small>';
				$result .= esc_html( $this->url_truncate( $q ) );
				$result .= '</small> to ';
				$result .= esc_html( $user->display_name );
				$result .= '</a>';
				$results[] = $result;
			}
		}
		return $results;
	}

	public function friends_browser_extension_actions( $actions, $current_user = null, $context = null ) {
		if ( ! is_array( $actions ) ) {
			$actions = array();
		}

		$extension_version = $this->get_browser_extension_version( $context );
		$browser_key       = $this->get_browser_extension_key( $context );
		$use_inline        = method_exists( '\Friends\REST', 'rest_extension_action' ) && $browser_key && ( ! $extension_version || version_compare( $extension_version, '1.6.0', '>=' ) );

		foreach ( $this->get_post_collection_terms() as $collection ) {
			if ( get_term_meta( $collection->term_id, 'friends_post_collection_inactive', true ) ) {
				continue;
			}

			if ( $use_inline ) {
				$actions[] = array(
					'id'               => 'save-to-post-collection-' . $collection->term_id,
					'name'             => sprintf(
						// translators: %s is the name of a post collection.
						__( 'Save to %s', 'post-collection' ),
						$collection->name
					),
					'category'         => __( 'Save', 'post-collection' ),
					'url'              => rest_url( 'friends/v1/extension/action' ),
					'method'           => 'POST',
					'run'              => 'inline',
					'submit_label'     => __( 'Save', 'post-collection' ),
					'progress_message' => __( 'Saving...', 'post-collection' ),
					'success_message'  => __( 'Saved.', 'post-collection' ),
					'fields'           => array(
						'action'        => 'post_collection_save',
						'key'           => $browser_key,
						'collection_id' => (string) $collection->term_id,
						'url'           => '{current_url}',
						'html'          => '{page_html}',
					),
					'inputs'           => array(
						array(
							'name'     => 'title',
							'label'    => __( 'Title', 'post-collection' ),
							'type'     => 'text',
							'default'  => '{page_title}',
							'required' => true,
						),
						array(
							'name'        => 'tags',
							'label'       => __( 'Tags', 'post-collection' ),
							'type'        => 'tags',
							'placeholder' => __( 'tag-one, tag-two', 'post-collection' ),
						),
					),
				);
				continue;
			}

			$actions[] = $this->get_legacy_browser_extension_action( $collection );
		}

		return $actions;
	}

	/**
	 * Get the legacy browser extension action.
	 *
	 * @param \WP_Term $collection The post collection term.
	 * @return array The action definition.
	 */
	private function get_legacy_browser_extension_action( \WP_Term $collection ) {
		return array(
			'name'     => $collection->name,
			'url'      => home_url( '/?collection=' . $collection->term_id . '&post-only=1&collect-post={current_url}' ),
			'method'   => 'POST',
			'fields'   => array( 'body' => '{page_html}' ),
			'category' => __( 'Collect Post', 'post-collection' ),
		);
	}

	/**
	 * Get the browser extension version from the filter context or request.
	 *
	 * @param mixed $context Filter context from Friends.
	 * @return string The extension version.
	 */
	private function get_browser_extension_version( $context = null ) {
		if ( is_array( $context ) ) {
			if ( isset( $context['extension_version'] ) ) {
				return sanitize_text_field( $context['extension_version'] );
			}
			if ( isset( $context['version'] ) ) {
				return sanitize_text_field( $context['version'] );
			}
		} elseif ( is_object( $context ) ) {
			if ( isset( $context->extension_version ) ) {
				return sanitize_text_field( $context->extension_version );
			}
			if ( isset( $context->version ) ) {
				return sanitize_text_field( $context->version );
			}
		}

		if ( isset( $_REQUEST['version'] ) ) {
			return sanitize_text_field( wp_unslash( $_REQUEST['version'] ) );
		}

		return '';
	}

	/**
	 * Get the browser extension key from the filter context or request.
	 *
	 * @param mixed $context Filter context from Friends.
	 * @return string The browser extension key.
	 */
	private function get_browser_extension_key( $context = null ) {
		if ( is_array( $context ) ) {
			if ( isset( $context['browser_extension_key'] ) ) {
				return sanitize_text_field( $context['browser_extension_key'] );
			}
			if ( isset( $context['key'] ) ) {
				return sanitize_text_field( $context['key'] );
			}
		} elseif ( is_object( $context ) ) {
			if ( isset( $context->browser_extension_key ) ) {
				return sanitize_text_field( $context->browser_extension_key );
			}
			if ( isset( $context->key ) ) {
				return sanitize_text_field( $context->key );
			}
		}

		if ( isset( $_REQUEST['key'] ) ) {
			return sanitize_text_field( wp_unslash( $_REQUEST['key'] ) );
		}

		return '';
	}

	/**
	 * Register post collections as My Apps launcher entries.
	 *
	 * @param array $apps The registered My Apps entries.
	 * @return array The filtered My Apps entries.
	 */
	public function my_apps_plugins( $apps ) {
		if ( current_user_can( $this->get_required_role() ) ) {
			$apps['post-collection-configure'] = array(
				'name'            => __( 'Configure Post Collections', 'post-collection' ),
				'url'             => home_url( '/post-collection/' ),
				'dashicon'        => 'dashicons-admin-settings',
				'icon_background' => 'linear-gradient(135deg, #64748b, #334155)',
				'icon_color'      => '#fff',
				'icon_shadow'     => true,
			);
		}

		foreach ( $this->get_post_collection_users()->get_results() as $user ) {
			$apps[ 'post-collection-' . $user->ID ] = array(
				'name'            => $user->display_name,
				'url'             => $user->get_local_friends_page_url(),
				// Same tile as the WordPress/blueprints catalog entry.
				'dashicon'        => 'dashicons-book',
				'icon_background' => 'linear-gradient(135deg, #614385, #516395)',
				'icon_color'      => '#fff',
				'icon_shadow'     => true,
			);
		}

		return $apps;
	}

	/**
	 * Potentially override the post author name with metadata.
	 *
	 * @param      string $overridden_author_name  The already overridden author name.
	 * @param      string $author_name  The author name.
	 * @param      int    $post_id      The post id.
	 *
	 * @return     string  The modified author name.
	 */
	public function friends_override_author_name( $overridden_author_name, $author_name, $post_id ) {
		if ( $overridden_author_name && $overridden_author_name !== $author_name ) {
			return $overridden_author_name;
		}
		$post = get_post( $post_id );
		$author = new \WP_User( $post->post_author );
		if ( is_wp_error( $author ) ) {
			return $author_name;
		}

		if ( ! $author->has_cap( 'post_collection' ) ) {
			return $author_name;
		}

		$host = wp_parse_url( $post->guid, PHP_URL_HOST );

		return sanitize_text_field( preg_replace( '#^www\.#', '', preg_replace( '#[^a-z0-9.-]+#i', ' ', strtolower( $host ) ) ) );
	}

	/**
	 * Prefer assigned post collection names for generated ePub book authors.
	 *
	 * @param string $author Current ePub book author.
	 * @param array  $posts  Posts included in the ePub.
	 * @return string Filtered ePub book author.
	 */
	public function filter_ebook_author( $author, array $posts ) {
		$collection_names = array();

		foreach ( $posts as $post ) {
			if ( ! $post instanceof \WP_Post ) {
				continue;
			}

			$terms = get_the_terms( $post, self::COLLECTION_TAXONOMY );
			if ( is_wp_error( $terms ) || empty( $terms ) ) {
				continue;
			}

			foreach ( $terms as $term ) {
				if ( empty( $term->name ) || in_array( $term->name, $collection_names, true ) ) {
					continue;
				}

				$collection_names[] = $term->name;
			}
		}

		if ( $collection_names ) {
			return implode( ', ', $collection_names );
		}

		return $author;
	}

	/**
	 * Expose the feed for the specific user.
	 *
	 * @param      bool   $viewable      Whether it's viewable.
	 * @param      string $author_login  The author login.
	 *
	 * @return     bool    Whether it's viewable.
	 */
	function friends_friend_feed_viewable( $viewable, $author_login ) {
		$collection = get_term_by( 'slug', sanitize_title( $author_login ), self::COLLECTION_TAXONOMY );
		if ( $collection && ! is_wp_error( $collection ) && get_term_meta( $collection->term_id, 'friends_publish_post_collection', true ) ) {
			add_filter( 'pre_option_rss_use_excerpt', '__return_true', 30 );
			return true;
		}
		return $viewable;
	}

	/**
	 * Expose public collection front pages by collection term.
	 *
	 * @param bool   $viewable     Whether the Friends page is viewable.
	 * @param string $author_login The first path segment after /friends/.
	 * @return bool Whether it is viewable.
	 */
	public function collection_friend_posts_query_viewable( $viewable, $author_login ) {
		$collection = get_term_by( 'slug', sanitize_title( $author_login ), self::COLLECTION_TAXONOMY );
		if ( $collection && ! is_wp_error( $collection ) && get_term_meta( $collection->term_id, 'friends_publish_post_collection', true ) ) {
			return true;
		}

		return $viewable;
	}

	/**
	 * Amend the Friends List widget
	 *
	 * @param object $widget  The widget.
	 * @param array  $args Sidebar arguments.
	 */
	public function friends_widget_friend_list_after( $widget, $args ) {
		$post_collections = $this->get_post_collection_users();
		if ( 0 !== $post_collections->get_total() ) {
			?>
			<details class="accordion" open>
				<summary class="accordion-header">
					<?php
					echo wp_kses_post( $args['before_title'] );
					echo esc_html( _ex( 'Post Collections', 'widget-header', 'post-collection' ) );
					echo wp_kses_post( $args['after_title'] );
					?>
				</summary>
				<ul class="subscriptions-list menu menu-nav accordion-body">
					<?php
					$widget->get_list_items( $post_collections->get_results() );
					?>
				</ul>
			</details>
			<?php
		}
	}

	/**
	 * Amend the Friends author header.
	 *
	 * @param      \WP_User $user   The user.
	 */
	public function friends_author_header( $user ) {
		if ( $user->has_cap( 'post_collection' ) ) {
			?>
			<a class="chip" href="<?php echo esc_attr( get_edit_user_link( $user->ID ) ); ?>"><?php /* phpcs:ignore WordPress.WP.I18n.MissingArgDomain */ esc_html_e( 'Edit' ); ?></a>
			<?php
		}
	}

	public function share_button() {
		$this->template_loader()->get_template_part(
			'frontend/share',
			null,
			array(
				'post-collections' => $this->get_post_collection_users()->get_results(),
			)
		);
	}

	public function enter_url_field( $user ) {
		if ( $user->has_cap( 'post_collection' ) ) {
			$this->template_loader()->get_template_part(
				'frontend/enter-url',
				null,
				array(
					'friend_user' => $user,
				)
			);
		}
	}

	public function feed_table_header() {
		?>
		<th><?php esc_html_e( 'Fetch Full Content', 'post-collection' ); ?></th>
		<?php
	}

	public function feed_table_row( $feed, $term_id ) {
		if ( ! $feed ) {
			return;
		}
		?>
		<td style="padding-left: 1em"><input type="checkbox" name="feeds[<?php echo esc_attr( $term_id ); ?>][fetch-full-content]" value="1" aria-label="<?php esc_attr_e( 'Fetch Full Content', 'post-collection' ); ?>" <?php checked( $feed->get_metadata( 'fetch-full-content' ) ); ?> /></td>
		<?php
	}

	public function feed_list_item( $feed, $term_id ) {
		if ( ! $feed ) {
			return;
		}
		?>
		<tr>
			<th><?php esc_html_e( 'Fetch Full Content', 'post-collection' ); ?></th>
			<td><input type="checkbox" name="feeds[<?php echo esc_attr( $term_id ); ?>][fetch-full-content]" value="1" aria-label="<?php esc_attr_e( 'Fetch Full Content', 'post-collection' ); ?>" <?php checked( $feed->get_metadata( 'fetch-full-content' ) ); ?> /></td>
		</tr>
		<?php
	}

	public function after_register_feed_taxonomy() {
		register_term_meta(
			'friend-user-feed',
			'fetch-full-content',
			array(
				'type'   => 'boolean',
				'single' => true,
			)
		);
	}

	public function feed_item_submit( $user_feed, $feed ) {
		if ( isset( $feed['fetch-full-content'] ) ) {
			$user_feed->update_metadata( 'fetch-full-content', true );
		} else {
			$user_feed->delete_metadata( 'fetch-full-content' );
		}
	}

	public function modify_feed_item( $item, $user_feed, $friend_user, $post_id ) {
		if ( $user_feed && $user_feed->get_metadata( 'fetch-full-content' ) ) {
			if ( $post_id ) {
				return $item;
			}

			$fetched_item = $this->download( $item->permalink );
			if ( is_wp_error( $fetched_item ) ) {
				return $item;
			}

			if ( ! $fetched_item->content && ! $fetched_item->title ) {
				return $item;
			}

			$item->title   = wp_strip_all_tags( trim( $fetched_item->title ) );
			$item->post_content = force_balance_tags( trim( wp_kses_post( $fetched_item->content ) ) );
			$item->_full_content_fetched = true;
		}
		return $item;
	}

	public function can_update_modified_feed_posts( $can_update, $item, $user_feed, $friend_user, $post_id ) {
		if ( $user_feed->get_metadata( 'fetch-full-content' ) && $post_id && get_post_meta( $post_id, 'full-content-fetched', true ) ) {
			// Prevent later feed refreshes from overwriting extracted full content with shorter feed content.
			return false;
		}
		return $can_update;
	}

	function wp_ajax_mark_private() {
		check_ajax_referer( self::AJAX_NONCE );

		if ( ! current_user_can( $this->get_required_role() ) ) {
			wp_send_json_error( 'error' );
		}

		$post = get_post( isset( $_POST['id'] ) ? absint( wp_unslash( $_POST['id'] ) ) : 0 );
		if ( ! $post ) {
			wp_send_json_error( 'error' );
		}
		$post->post_status = 'private';
		wp_update_post( $post );

		wp_send_json_success(
			array(
				'new_text' => __( 'Make post public', 'post-collection' ),
			)
		);
	}

	function wp_ajax_mark_publish() {
		check_ajax_referer( self::AJAX_NONCE );

		if ( ! current_user_can( $this->get_required_role() ) ) {
			wp_send_json_error( 'error' );
		}

		$post = get_post( isset( $_POST['id'] ) ? absint( wp_unslash( $_POST['id'] ) ) : 0 );
		if ( ! $post ) {
			wp_send_json_error( 'error' );
		}
		$post->post_status = 'publish';
		wp_update_post( $post );

		wp_send_json_success(
			array(
				'new_text' => __( 'Make post private', 'post-collection' ),
			)
		);
	}

	function wp_ajax_change_author() {
		check_ajax_referer( self::AJAX_NONCE );

		if ( ! current_user_can( $this->get_required_role() ) ) {
			wp_send_json_error( 'error' );
		}

		$new_author = new User( isset( $_POST['author'] ) ? absint( wp_unslash( $_POST['author'] ) ) : 0 );
		if ( is_wp_error( $new_author ) ) {
			wp_send_json_error( 'error' );
		}
		if ( ! User::is_friends_plugin_user( $new_author ) && ! $new_author->has_cap( 'post_collection' ) ) {
			wp_send_json_error( 'error' );
		}

		$originalauthor = User::get_user_by_id( isset( $_POST['originalauthor'] ) ? absint( wp_unslash( $_POST['originalauthor'] ) ) : 0 );
		$new_text = __( 'Undo' ); // phpcs:ignore WordPress.WP.I18n.MissingArgDomain

		$post = get_post( isset( $_POST['id'] ) ? absint( wp_unslash( $_POST['id'] ) ) : 0 );
		if ( ! $post ) {
			wp_send_json_error( 'error' );
		}

		$old_author = User::get_post_author( $post );

		$post->post_author = $new_author->ID;
		if ( $new_author->has_cap( 'post_collection' ) ) {
			$post->post_type   = self::CPT;
			$post->post_status = 'private';
		}
		if ( get_user_option( 'friends_post_collection_copy_mode', $new_author->ID ) ) {
			unset( $post->ID );
			$new_author->insert_post( (array) $post );
			$new_text = sprintf(
				// translators: %s is the name of a post collection.
				_x( 'Copied to %s!', 'post-collection', 'post-collection' ),
				$new_author->display_name
			);
		} else {
			$new_author->insert_post( (array) $post );
			if ( class_exists( 'Friends\Subscription' ) && $old_author instanceof \Friends\Subscription ) {
				wp_remove_object_terms( $post->ID, $old_author->get_term_id(), 'friend-subscription' );
			}
			if ( $new_author->ID !== $originalauthor->ID ) {
				$new_text = sprintf(
					// translators: %s is the name of a post collection.
					_x( 'Moved to %s!', 'post-collection', 'post-collection' ),
					$new_author->display_name
				);
			}
		}

		wp_send_json_success(
			array(
				'new_text'   => $new_text,
				'old_author' => $old_author->ID,
			)
		);
	}

	function wp_ajax_save_to_collection() {
		check_ajax_referer( self::AJAX_NONCE );

		if ( ! current_user_can( $this->get_required_role() ) ) {
			wp_send_json_error( __( 'Sorry, you are not allowed to do that' ) ); // phpcs:ignore WordPress.WP.I18n.MissingArgDomain
		}

		$post = get_post( isset( $_POST['id'] ) ? absint( $_POST['id'] ) : 0 );
		if ( ! $post ) {
			wp_send_json_error( __( 'That post does not exist.' ) ); // phpcs:ignore WordPress.WP.I18n.MissingArgDomain
		}

		$collection = get_term( isset( $_POST['collection'] ) ? absint( $_POST['collection'] ) : 0, self::COLLECTION_TAXONOMY );
		if ( ! $collection || is_wp_error( $collection ) ) {
			wp_send_json_error( __( 'Invalid post collection.', 'post-collection' ) );
		}

		if ( get_term_meta( $collection->term_id, 'friends_post_collection_inactive', true ) ) {
			wp_send_json_error( __( 'This post collection is inactive.', 'post-collection' ) );
		}

		$url = $post->guid;
		if ( ! $this->check_url( $url ) ) {
			$url = get_permalink( $post );
		}

		$post_id = $this->save_url_to_collection_term(
			$url,
			$collection,
			$post->post_content,
			array(
				'title'          => $post->post_title,
				'return_details' => true,
			)
		);

		if ( is_wp_error( $post_id ) ) {
			wp_send_json_error( $post_id->get_error_message() );
		}

		$save_details = $post_id;
		$copy_mode    = (bool) get_term_meta( $collection->term_id, 'friends_post_collection_copy_mode', true );
		if ( ! $copy_mode && self::CPT !== $post->post_type ) {
			wp_trash_post( $post->ID );
		}

		wp_send_json_success(
			array(
				'post_id'  => $save_details['post_id'],
				'new_text' => sprintf(
					// translators: %s is the name of a post collection.
					$copy_mode ? _x( 'Copied to %s!', 'post-collection', 'post-collection' ) : _x( 'Moved to %s!', 'post-collection', 'post-collection' ),
					$collection->name
				),
			)
		);
	}

	function wp_ajax_fetch_full_content() {
		check_ajax_referer( self::AJAX_NONCE );

		if ( ! current_user_can( $this->get_required_role() ) ) {
			wp_send_json_error( __( 'Sorry, you are not allowed to do that' ) ); // phpcs:ignore WordPress.WP.I18n.MissingArgDomain
			exit;
		}
		$post = get_post( isset( $_POST['id'] ) ? absint( wp_unslash( $_POST['id'] ) ) : 0 );
		if ( ! $post ) {
			wp_send_json_error( __( 'That post does not exist.' ) ); // phpcs:ignore WordPress.WP.I18n.MissingArgDomain
			exit;
		}

		$user = User::get_post_author( $post );
		if ( ! $user || is_wp_error( $user ) ) {
			wp_send_json_error( __( 'That user does not exist.' ) ); // phpcs:ignore WordPress.WP.I18n.MissingArgDomain
			exit;
		}

		$url = get_permalink( $post );
		$href = null;

		// Check if the post content contains as "read more" link.
		$parser = new WP_HTML_Tag_Processor( $post->post_content );
		while ( $parser->next_tag( 'a' ) ) {
			$href = $parser->get_attribute( 'href' );
			$parser->next_token();
			if ( 'read more' === strtolower( trim( $parser->get_modifiable_text() ) ) ) {
				$url = $href;
				break;
			}
			$href = null;
		}

		$item = $this->download( $url );
		if ( is_wp_error( $item ) ) {
			wp_send_json_error( $item );
			exit;
		}

		if ( ! $item->content && ! $item->title ) {
			wp_send_json_error( new \WP_Error( 'invalid-content', __( 'No content was extracted.', 'post-collection' ) ) );
			exit;
		}

		$title   = wp_strip_all_tags( trim( $item->title ) );
		$content = force_balance_tags( trim( wp_kses_post( $item->content ) ) );

		if ( $href ) {
			// The permalink is not the same as the original URL, so we add it to the content.
			$content = 'Source: <a href="' . esc_url( $href ) . '">' . esc_html( $href ) . "</a><br>\n<br>\n" . $content;
		}

		$post_data = array(
			'ID'           => $post->ID,
			'post_title'   => $title,
			'post_content' => $content,
			'meta_input'   => array(
				'full-content-fetched' => true,
			),
		);

		wp_update_post( $post_data );

		wp_send_json_success(
			array(
				'url'         => $url,
				'post_title'   => $title,
				'post_content' => $content,
			)
		);
	}

	function wp_ajax_download_images() {
		check_ajax_referer( self::AJAX_NONCE );

		if ( ! current_user_can( $this->get_required_role() ) ) {
			wp_send_json_error( __( 'Sorry, you are not allowed to do that' ) ); // phpcs:ignore WordPress.WP.I18n.MissingArgDomain
			exit;
		}
		$post = get_post( isset( $_POST['id'] ) ? absint( wp_unslash( $_POST['id'] ) ) : 0 );
		if ( ! $post ) {
			wp_send_json_error( __( 'That post does not exist.' ) ); // phpcs:ignore WordPress.WP.I18n.MissingArgDomain
			exit;
		}

		$user = User::get_post_author( $post );
		if ( ! $user || is_wp_error( $user ) ) {
			wp_send_json_error( __( 'That user does not exist.' ) ); // phpcs:ignore WordPress.WP.I18n.MissingArgDomain
			exit;
		}

		$home_host = wp_parse_url( home_url(), PHP_URL_HOST );

		$processor = new WP_HTML_Tag_Processor( $post->post_content );
		while ( $processor->next_tag( 'IMG' ) ) {
			$src = $processor->get_attribute( 'src' );
			if ( ! is_string( $src ) ) {
				$src = '';
			}
			$p = wp_parse_url( $src );
			if ( $p['host'] === $home_host ) {
				continue;
			}
			$filename = basename( $p['path'] );

			// download the url to a temp file
			$tmp_file = download_url( $src );

			// now put that file into the media library
			$attachment_id = media_handle_sideload(
				array(
					'name'     => $filename,
					'tmp_name' => $tmp_file,
				),
				$post->ID
			);

			// delete the temp file
			wp_delete_file( $tmp_file );

			if ( is_wp_error( $attachment_id ) ) {
				continue;
			}

			$new_src = wp_get_attachment_url( $attachment_id );
			$processor->set_attribute( 'src', $new_src );

			$old_srcset = $processor->get_attribute( 'srcset' );
			if ( is_string( $old_srcset ) ) {
				$new_srcset = str_replace( $src, $new_src, $old_srcset );
				$processor->set_attribute( 'srcset', $new_srcset );
			}
		}

		$post_data = array(
			'ID'           => $post->ID,
			'post_content' => force_balance_tags( wp_kses_post( $processor->get_updated_html() ) ),
			'meta_input'   => array(
				'images-downloaded' => true,
			),
		);
		$updated_post = wp_update_post( $post_data );

		if ( is_wp_error( $updated_post ) ) {
			wp_send_json_error( $updated_post );
			exit;
		}

		wp_update_post( $post_data );

		wp_send_json_success(
			array(
				'post_title'   => $post->post_title,
				'post_content' => $post_data['post_content'],
			)
		);
	}

	/**
	 * Re-extract content from the original HTML stored in revisions.
	 */
	function wp_ajax_re_extract() {
		check_ajax_referer( self::AJAX_NONCE );

		if ( ! current_user_can( $this->get_required_role() ) ) {
			wp_send_json_error( __( 'Sorry, you are not allowed to do that' ) ); // phpcs:ignore WordPress.WP.I18n.MissingArgDomain
			exit;
		}

		$post = get_post( isset( $_POST['id'] ) ? absint( wp_unslash( $_POST['id'] ) ) : 0 );
		if ( ! $post ) {
			wp_send_json_error( __( 'That post does not exist.' ) ); // phpcs:ignore WordPress.WP.I18n.MissingArgDomain
			exit;
		}

		$revisions = wp_get_post_revisions(
			$post->ID,
			array(
				'order'          => 'ASC',
				'posts_per_page' => 1,
			)
		);

		if ( empty( $revisions ) ) {
			wp_send_json_error( new \WP_Error( 'no-revisions', __( 'No original HTML revision found.', 'post-collection' ) ) );
			exit;
		}

		$first_revision = reset( $revisions );
		$raw_html = $first_revision->post_content;

		if ( empty( $raw_html ) ) {
			wp_send_json_error( new \WP_Error( 'empty-revision', __( 'The original HTML revision is empty.', 'post-collection' ) ) );
			exit;
		}

		$url = get_post_meta( $post->ID, 'url', true );
		if ( ! $url ) {
			$url = $post->guid;
		}

		$item = $this->extract_content( $raw_html, $url );
		if ( is_wp_error( $item ) ) {
			wp_send_json_error( $item );
			exit;
		}

		if ( ! $item->content && ! $item->title ) {
			wp_send_json_error( new \WP_Error( 'invalid-content', __( 'No content was extracted.', 'post-collection' ) ) );
			exit;
		}

		$title   = wp_strip_all_tags( trim( $item->title ) );
		$content = force_balance_tags( trim( wp_kses_post( $item->content ) ) );

		$post_data = array(
			'ID'           => $post->ID,
			'post_title'   => $title ? $title : $post->post_title,
			'post_content' => $content,
		);

		wp_update_post( $post_data );

		wp_send_json_success(
			array(
				'post_title'   => $post_data['post_title'],
				'post_content' => $content,
			)
		);
	}

	/**
	 * Actions to take upon plugin activation.
	 *
	 * @param      bool $network_activate  Whether the plugin has been activated network-wide.
	 */
	public static function activate_plugin( $network_activate = null ) {
		if ( function_exists( 'is_multisite' ) && is_multisite() ) {
			if ( $network_activate ) {
				// Only Super Admins can use Network Activate.
				if ( ! is_super_admin() ) {
					return;
				}

				// Activate for each site.
				foreach ( get_sites() as $blog ) {
					switch_to_blog( $blog->blog_id );
					self::setup();
					restore_current_blog();
				}
			} elseif ( current_user_can( 'activate_plugins' ) ) {
				self::setup();
			}
			return;
		}

		self::setup();
	}

	/**
	 * Make sure that setup actions are executed.
	 *
	 * @param      int|WP_Site $blog_id  Blog ID.
	 */
	public static function activate_for_blog( $blog_id ) {
		if ( ! function_exists( 'is_plugin_active_for_network' ) ) {
			require_once ABSPATH . 'wp-admin/includes/plugin.php';
		}

		if ( $blog_id instanceof \WP_Site ) {
			$blog_id = (int) $blog_id->blog_id;
		}

		$is_network_active = defined( 'FRIENDS_PLUGIN_BASENAME' ) && is_plugin_active_for_network( FRIENDS_PLUGIN_BASENAME );
		$is_network_active = $is_network_active || is_plugin_active_for_network( plugin_basename( POST_COLLECTION_PLUGIN_FILE ) );

		if ( $is_network_active ) {
			switch_to_blog( $blog_id );
			self::setup();
			restore_current_blog();
		}
	}


	public static function get_role_capabilities( $role ) {
		$capabilities = array();

		$capabilities['post_collection'] = array(
			'post_collection'      => true,
			'edit_posts'           => true,
			'edit_post_collection' => true,
		);

		// All roles belonging to this plugin have the friends_plugin capability.
		foreach ( array_keys( $capabilities ) as $type ) {
			$capabilities[ $type ]['friends_plugin'] = true;
		}

		if ( ! isset( $capabilities[ $role ] ) ) {
			return array();
		}

		return $capabilities[ $role ];
	}

	/**
	 * Create the user roles
	 */
	private static function setup_roles() {
		$default_roles = array(
			'post_collection' => _x( 'Post Collection', 'User role', 'post-collection' ),
		);

		$roles = new \WP_Roles();

		foreach ( $default_roles as $type => $name ) {
			$role = false;
			foreach ( $roles->roles as $slug => $data ) {
				if ( isset( $data['capabilities'][ $type ] ) ) {
					$role = get_role( $slug );
					break;
				}
			}
			if ( ! $role ) {
				$role = add_role( $type, $name, self::get_role_capabilities( $type ) );
				continue;
			}

			// This might update missing capabilities.
			foreach ( array_keys( self::get_role_capabilities( $type ) ) as $cap ) {
				$role->add_cap( $cap );
			}
		}
	}

	private static function setup_default_user() {
		$default_user_id = get_option( 'post-collection_default_user' );
		$default_user = false;
		if ( $default_user_id ) {
			$default_user = new \WP_User( $default_user_id );
			if ( ! $default_user->exists() ) {
				$default_user = false;
			}
		}
		if ( ! $default_user ) {
			$userdata  = array(
				'user_login'   => sanitize_user( sanitize_title_with_dashes( remove_accents( __( 'Collected Posts', 'post-collection' ) ) ) ),
				'display_name' => __( 'Collected Posts', 'post-collection' ),
				'user_pass'    => wp_generate_password( 256 ),
				'role'         => 'post_collection',
			);
			$user_id = wp_insert_user( $userdata );
			update_option( 'post-collection_default_user', $user_id );
		}
	}

	/**
	 * Get the tag taxonomy for static contexts (migration, etc).
	 *
	 * @return string The taxonomy name.
	 */
	private static function get_tag_taxonomy_static() {
		if ( class_exists( 'Friends\Friends' ) && defined( 'Friends\Friends::TAG_TAXONOMY' ) ) {
			return Friends::TAG_TAXONOMY;
		}
		return 'friend_tag';
	}

	/**
	 * Actions to take upon plugin activation.
	 */
	public static function setup() {
		self::setup_roles();
		self::setup_default_user();
	}
}