<?php
declare( strict_types=1 );

namespace ExtCPTs;

use WP_Post_Type;
use WP_Post;
use WP_Query;
use WP_Taxonomy;
use WP_Term;
use WP;

class PostType {

	/**
	 * Default arguments for custom post types.
	 *
	 * The arguments listed are the ones which differ from the defaults in `register_post_type()`.
	 *
	 * @var array<string,mixed>
	 */
	protected array $defaults = [
		'public'          => true,
		'menu_position'   => 6,
		'capability_type' => 'page',
		'hierarchical'    => true,
		'supports'        => [
			'title',
			'editor',
			'thumbnail',
		],
		'site_filters'    => null,  # Custom arg
		'site_sortables'  => null,  # Custom arg
		'show_in_feed'    => false, # Custom arg
		'archive'         => null,  # Custom arg
		'featured_image'  => null,  # Custom arg
	];

	public string $post_type;

	public string $post_slug;

	public string $post_singular;

	public string $post_plural;

	public string $post_singular_low;

	public string $post_plural_low;

	/**
	 * @var array<string,mixed>
	 */
	public array $args;

	/**
	 * Class constructor.
	 *
	 * @see register_extended_post_type()
	 *
	 * @param string               $post_type The post type name.
	 * @param array<string,mixed>  $args      Optional. The post type arguments.
	 * @param array<string,string> $names     Optional. The plural, singular, and slug names.
	 * @phpstan-param array{
	 *   plural?: string,
	 *   singular?: string,
	 *   slug?: string,
	 * } $names
	 */
	public function __construct( string $post_type, array $args = [], array $names = [] ) {
		/**
		 * Filter the arguments for a post type.
		 *
		 * @since 4.4.1
		 *
		 * @param array<string,mixed> $args      The post type arguments.
		 * @param string              $post_type The post type name.
		 */
		$args = apply_filters( 'ext-cpts/args', $args, $post_type );

		/**
		 * Filter the arguments for this post type.
		 *
		 * @since 2.4.0
		 *
		 * @param array<string,mixed> $args The post type arguments.
		 */
		$args = apply_filters( "ext-cpts/{$post_type}/args", $args );

		/**
		 * Filter the plural, singular, and slug names for a post type.
		 *
		 * @since 4.4.1
		 *
		 * @param array<string,string> $names     The plural, singular, and slug names (if any were specified).
		 * @param string               $post_type The post type name.
		 */
		$names = apply_filters( 'ext-cpts/names', $names, $post_type );

		/**
		 * Filter the plural, singular, and slug names for this post type.
		 *
		 * @since 2.4.0
		 *
		 * @param array<string,string> $names The plural, singular, and slug names (if any were specified).
		 */
		$names = apply_filters( "ext-cpts/{$post_type}/names", $names );

		if ( isset( $names['singular'] ) ) {
			$this->post_singular = $names['singular'];
		} else {
			$this->post_singular = ucwords(
				str_replace(
					[
						'-',
						'_',
					],
					' ',
					$post_type
				)
			);
		}

		if ( isset( $names['slug'] ) ) {
			$this->post_slug = $names['slug'];
		} elseif ( isset( $names['plural'] ) ) {
			$this->post_slug = $names['plural'];
		} else {
			$this->post_slug = $post_type . 's';
		}

		if ( isset( $names['plural'] ) ) {
			$this->post_plural = $names['plural'];
		} else {
			$this->post_plural = $this->post_singular . 's';
		}

		$this->post_type = strtolower( $post_type );
		$this->post_slug = strtolower( $this->post_slug );

		# Build our base post type names:
		# Lower-casing is not forced if the name looks like an initialism, eg. FAQ.
		if ( ! preg_match( '/[A-Z]{2,}/', $this->post_singular ) ) {
			$this->post_singular_low = strtolower( $this->post_singular );
		} else {
			$this->post_singular_low = $this->post_singular;
		}

		if ( ! preg_match( '/[A-Z]{2,}/', $this->post_plural ) ) {
			$this->post_plural_low = strtolower( $this->post_plural );
		} else {
			$this->post_plural_low = $this->post_plural;
		}

		# Build our labels:
		# Why aren't these translatable?
		# Answer: https://github.com/johnbillion/extended-cpts/pull/5#issuecomment-33756474
		$this->defaults['labels'] = [
			'name'                     => $this->post_plural,
			'singular_name'            => $this->post_singular,
			'menu_name'                => $this->post_plural,
			'name_admin_bar'           => $this->post_singular,
			'add_new'                  => sprintf( 'Add New %s', $this->post_singular ),
			'add_new_item'             => sprintf( 'Add New %s', $this->post_singular ),
			'edit_item'                => sprintf( 'Edit %s', $this->post_singular ),
			'new_item'                 => sprintf( 'New %s', $this->post_singular ),
			'view_item'                => sprintf( 'View %s', $this->post_singular ),
			'view_items'               => sprintf( 'View %s', $this->post_plural ),
			'search_items'             => sprintf( 'Search %s', $this->post_plural ),
			'not_found'                => sprintf( 'No %s found.', $this->post_plural_low ),
			'not_found_in_trash'       => sprintf( 'No %s found in trash.', $this->post_plural_low ),
			'parent_item_colon'        => sprintf( 'Parent %s:', $this->post_singular ),
			'all_items'                => sprintf( 'All %s', $this->post_plural ),
			'archives'                 => sprintf( '%s Archives', $this->post_singular ),
			'attributes'               => sprintf( '%s Attributes', $this->post_singular ),
			'insert_into_item'         => sprintf( 'Insert into %s', $this->post_singular_low ),
			'uploaded_to_this_item'    => sprintf( 'Uploaded to this %s', $this->post_singular_low ),
			'filter_items_list'        => sprintf( 'Filter %s list', $this->post_plural_low ),
			'filter_by_date'           => 'Filter by date',
			'items_list_navigation'    => sprintf( '%s list navigation', $this->post_plural ),
			'items_list'               => sprintf( '%s list', $this->post_plural ),
			'item_published'           => sprintf( '%s published.', $this->post_singular ),
			'item_published_privately' => sprintf( '%s published privately.', $this->post_singular ),
			'item_reverted_to_draft'   => sprintf( '%s reverted to draft.', $this->post_singular ),
			'item_scheduled'           => sprintf( '%s scheduled.', $this->post_singular ),
			'item_updated'             => sprintf( '%s updated.', $this->post_singular ),
			'item_link'                => sprintf( '%s Link', $this->post_singular ),
			'item_link_description'    => sprintf( 'A link to a %s.', $this->post_singular_low ),
			'item_trashed'             => sprintf( '%s trashed.', $this->post_singular ),
			'template_name'            => sprintf( 'Single item: %s', $this->post_singular ),
		];

		# Build the featured image labels:
		if ( isset( $args['featured_image'] ) ) {
			$featured_image_low = strtolower( $args['featured_image'] );
			$this->defaults['labels']['featured_image'] = $args['featured_image'];
			$this->defaults['labels']['set_featured_image'] = sprintf( 'Set %s', $featured_image_low );
			$this->defaults['labels']['remove_featured_image'] = sprintf( 'Remove %s', $featured_image_low );
			$this->defaults['labels']['use_featured_image'] = sprintf( 'Use as %s', $featured_image_low );
		}

		# Only set default rewrites if we need them
		if ( isset( $args['public'] ) && ! $args['public'] ) {
			$this->defaults['rewrite'] = false;
		} else {
			$this->defaults['rewrite'] = [
				'slug'       => $this->post_slug,
				'with_front' => false,
			];
		}

		# Merge our args with the defaults:
		$this->args = array_merge( $this->defaults, $args );

		# This allows the 'labels' and 'rewrite' args to contain all, some, or no values:
		foreach ( [ 'labels', 'rewrite' ] as $arg ) {
			if ( isset( $args[ $arg ] ) && is_array( $args[ $arg ] ) && is_array( $this->defaults[ $arg ] ) ) {
				$this->args[ $arg ] = array_merge( $this->defaults[ $arg ], $args[ $arg ] );
			}
		}

		# Enable post type archives by default
		if ( ! isset( $this->args['has_archive'] ) ) {
			$this->args['has_archive'] = $this->args['public'];
		}
	}

	/**
	 * Initialise the post type by adding the necessary actions and filters.
	 */
	public function init(): void {
		# Front-end sortables:
		if ( $this->args['site_sortables'] && ! is_admin() ) {
			add_action( 'pre_get_posts', [ $this, 'maybe_sort_by_fields' ] );
			add_filter( 'posts_clauses', [ $this, 'maybe_sort_by_taxonomy' ], 10, 2 );
		}

		# Front-end filters:
		if ( $this->args['site_filters'] && ! is_admin() ) {
			add_action( 'pre_get_posts', [ $this, 'maybe_filter' ] );
			add_filter( 'query_vars',    [ $this, 'add_query_vars' ] );
		}

		# Post type in the site's main feed:
		if ( $this->args['show_in_feed'] ) {
			add_filter( 'request', [ $this, 'add_to_feed' ] );
		}

		# Post type archive query vars:
		if ( $this->args['archive'] && ! is_admin() ) {
			add_filter( 'parse_request', [ $this, 'override_private_query_vars' ], 1 );
		}

		# Custom post type permastruct:
		if ( $this->args['rewrite'] && ! empty( $this->args['rewrite']['permastruct'] ) ) {
			add_action( 'registered_post_type', [ $this, 'registered_post_type' ], 1, 2 );
			add_filter( 'post_type_link',       [ $this, 'post_type_link' ], 1, 2 );
		}

		# Rewrite testing:
		if ( $this->args['rewrite'] ) {
			add_filter( 'rewrite_testing_tests', [ $this, 'rewrite_testing_tests' ], 1 );
		}

		# Register post type:
		$this->register_post_type();

		/**
		 * Fired when the extended post type instance is set up.
		 *
		 * @since 3.1.0
		 *
		 * @param \ExtCPTs\PostType $instance The extended post type instance.
		 */
		do_action( "ext-cpts/{$this->post_type}/instance", $this );
	}

	/**
	 * Set the relevant query vars for filtering posts by our front-end filters.
	 *
	 * @param WP_Query $wp_query The current WP_Query object.
	 */
	public function maybe_filter( WP_Query $wp_query ): void {
		if ( empty( $wp_query->query['post_type'] ) || ! in_array( $this->post_type, (array) $wp_query->query['post_type'], true ) ) {
			return;
		}

		$vars = self::get_filter_vars( $wp_query->query, $this->args['site_filters'], $this->post_type );

		if ( empty( $vars ) ) {
			return;
		}

		foreach ( $vars as $key => $value ) {
			if ( is_array( $value ) ) {
				$query = $wp_query->get( $key );
				if ( empty( $query ) ) {
					$query = [];
				}
				$value = array_merge( $query, $value );
			}
			$wp_query->set( $key, $value );
		}
	}

	/**
	 * Set the relevant query vars for sorting posts by our front-end sortables.
	 *
	 * @param WP_Query $wp_query The current WP_Query object.
	 */
	public function maybe_sort_by_fields( WP_Query $wp_query ): void {
		if ( empty( $wp_query->query['post_type'] ) || ! in_array( $this->post_type, (array) $wp_query->query['post_type'], true ) ) {
			return;
		}

		// If we've not specified an order:
		if ( empty( $wp_query->query['orderby'] ) ) {
			// Loop over our sortables to find the default sort field (if there is one):
			foreach ( $this->args['site_sortables'] as $id => $col ) {
				if ( is_array( $col ) && isset( $col['default'] ) ) {
					// @TODO Don't set 'order' if 'orderby' is an array (WP 4.0+)
					$wp_query->query['orderby'] = $id;
					$wp_query->query['order'] = ( 'desc' === strtolower( $col['default'] ) ? 'desc' : 'asc' );
					break;
				}
			}
		}

		$sort = self::get_sort_field_vars( $wp_query->query, $this->args['site_sortables'] );

		if ( empty( $sort ) ) {
			return;
		}

		foreach ( $sort as $key => $value ) {
			$wp_query->set( $key, $value );
		}
	}

	/**
	 * Filter the query's SQL clauses so we can sort posts by taxonomy terms.
	 *
	 * @param array<string,string> $clauses  Array of the current query's SQL clauses.
	 * @param WP_Query             $wp_query The current `WP_Query` object.
	 * @return array<string,string> Array of SQL clauses.
	 */
	public function maybe_sort_by_taxonomy( array $clauses, WP_Query $wp_query ): array {
		if ( empty( $wp_query->query['post_type'] ) || ! in_array( $this->post_type, (array) $wp_query->query['post_type'], true ) ) {
			return $clauses;
		}

		$sort = self::get_sort_taxonomy_clauses( $clauses, $wp_query->query, $this->args['site_sortables'] );

		if ( empty( $sort ) ) {
			return $clauses;
		}

		return array_merge( $clauses, $sort );
	}

	/**
	 * Get the array of private query vars for the given filters, to apply to the current query in order to filter it by the
	 * given public query vars.
	 *
	 * @param array<string,mixed> $query     The public query vars, usually from `$wp_query->query`.
	 * @param array<string,mixed> $filters   The filters valid for this query (usually the value of the `admin_filters` or
	 *                                       `site_filters` argument when registering an extended post type).
	 * @param string              $post_type The post type name.
	 * @return array<string,mixed> The list of private query vars to apply to the query.
	 */
	public static function get_filter_vars( array $query, array $filters, string $post_type ): array {
		$return = [];

		foreach ( $filters as $filter_key => $filter ) {
			$meta_query = [];
			$date_query = [];

			if ( ! isset( $query[ $filter_key ] ) || ( '' === $query[ $filter_key ] ) ) {
				continue;
			}

			if ( isset( $filter['cap'] ) && ! current_user_can( $filter['cap'] ) ) {
				continue;
			}

			$hook = "ext-cpts/{$post_type}/filter-query/{$filter_key}";

			if ( has_filter( $hook ) ) {
				/**
				 * Allows a filter's private query vars to be overridden.
				 *
				 * @since 4.3.0
				 *
				 * @param array<string,mixed> $return The private query vars.
				 * @param array<string,mixed> $query  The public query vars.
				 * @param array<string,mixed> $filter The filter arguments.
				 */
				$return = apply_filters( $hook, $return, $query, $filter );
				continue;
			}

			if ( isset( $filter['meta_key'] ) ) {
				$meta_query = [
					'key'   => $filter['meta_key'],
					'value' => wp_unslash( $query[ $filter_key ] ),
				];
			} elseif ( isset( $filter['meta_search_key'] ) ) {
				$meta_query = [
					'key'     => $filter['meta_search_key'],
					'value'   => wp_unslash( $query[ $filter_key ] ),
					'compare' => 'LIKE',
				];
			} elseif ( isset( $filter['meta_key_exists'] ) ) {
				$meta_query = [
					'key'     => wp_unslash( $query[ $filter_key ] ),
					'compare' => 'EXISTS',
				];
			} elseif ( isset( $filter['meta_exists'] ) ) {
				$meta_query = [
					'key'     => wp_unslash( $query[ $filter_key ] ),
					'compare' => 'NOT IN',
					'value'   => [ '', '0', 'false', 'null' ],
				];
			} elseif ( isset( $filter['post_date'] ) ) {
				$date_query = [
					$filter['post_date'] => wp_unslash( $query[ $filter_key ] ),
					'inclusive'          => true,
				];
			} else {
				continue;
			}

			if ( isset( $filter['meta_query'] ) ) {
				$meta_query = array_merge( $meta_query, $filter['meta_query'] );
			}

			if ( isset( $filter['date_query'] ) ) {
				$date_query = array_merge( $date_query, $filter['date_query'] );
			}

			if ( ! empty( $meta_query ) ) {
				$return['meta_query'][] = $meta_query;
			}

			if ( ! empty( $date_query ) ) {
				$return['date_query'][] = $date_query;
			}
		}

		return $return;
	}

	/**
	 * Get the array of private and public query vars for the given sortables, to apply to the current query in order to
	 * sort it by the requested orderby field.
	 *
	 * @param array<string,mixed> $vars      The public query vars, usually from `$wp_query->query`.
	 * @param array<string,mixed> $sortables The sortables valid for this query (usually the value of the `admin_cols` or
	 *                                       `site_sortables` argument when registering an extended post type.
	 * @return array<string,mixed> The list of private and public query vars to apply to the query.
	 */
	public static function get_sort_field_vars( array $vars, array $sortables ): array {
		if ( ! isset( $vars['orderby'] ) ) {
			return [];
		}

		if ( ! is_string( $vars['orderby'] ) ) {
			return [];
		}

		if ( ! isset( $sortables[ $vars['orderby'] ] ) ) {
			return [];
		}

		$orderby = $sortables[ $vars['orderby'] ];

		if ( ! is_array( $orderby ) ) {
			return [];
		}

		if ( isset( $orderby['sortable'] ) && ! $orderby['sortable'] ) {
			return [];
		}

		$return = [];

		if ( isset( $orderby['meta_key'] ) ) {
			$return['meta_key'] = $orderby['meta_key'];
			$return['orderby']  = 'meta_value';
			// @TODO meta_value_num
		} elseif ( isset( $orderby['post_field'] ) ) {
			$field = str_replace( 'post_', '', $orderby['post_field'] );
			$return['orderby'] = $field;
		}

		if ( isset( $vars['order'] ) ) {
			$return['order'] = $vars['order'];
		}

		return $return;
	}

	/**
	 * Get the array of SQL clauses for the given sortables, to apply to the current query in order to
	 * sort it by the requested orderby field.
	 *
	 * @param array<string,string> $clauses   The query's SQL clauses.
	 * @param array<string,mixed>  $vars      The public query vars, usually from `$wp_query->query`.
	 * @param array<string,mixed>  $sortables The sortables valid for this query (usually the value of the `admin_cols` or
	 *                                        `site_sortables` argument when registering an extended post type).
	 * @return array<string,string> The list of SQL clauses to apply to the query.
	 */
	public static function get_sort_taxonomy_clauses( array $clauses, array $vars, array $sortables ): array {
		global $wpdb;

		if ( ! isset( $vars['orderby'] ) ) {
			return [];
		}

		if ( ! is_string( $vars['orderby'] ) ) {
			return [];
		}

		if ( ! isset( $sortables[ $vars['orderby'] ] ) ) {
			return [];
		}

		$orderby = $sortables[ $vars['orderby'] ];

		if ( ! is_array( $orderby ) ) {
			return [];
		}

		if ( isset( $orderby['sortable'] ) && ! $orderby['sortable'] ) {
			return [];
		}

		if ( ! isset( $orderby['taxonomy'] ) ) {
			return [];
		}

		# Taxonomy term ordering courtesy of http://scribu.net/wordpress/sortable-taxonomy-columns.html
		$clauses['join'] .= "
			LEFT OUTER JOIN {$wpdb->term_relationships} as ext_cpts_tr
			ON ( {$wpdb->posts}.ID = ext_cpts_tr.object_id )
			LEFT OUTER JOIN {$wpdb->term_taxonomy} as ext_cpts_tt
			ON ( ext_cpts_tr.term_taxonomy_id = ext_cpts_tt.term_taxonomy_id )
			LEFT OUTER JOIN {$wpdb->terms} as ext_cpts_t
			ON ( ext_cpts_tt.term_id = ext_cpts_t.term_id )
		";
		$clauses['where'] .= $wpdb->prepare( ' AND ( taxonomy = %s OR taxonomy IS NULL )', $orderby['taxonomy'] );
		$clauses['groupby'] = 'ext_cpts_tr.object_id';
		$clauses['orderby'] = 'GROUP_CONCAT( ext_cpts_t.name ORDER BY name ASC ) ';
		$clauses['orderby'] .= ( isset( $vars['order'] ) && ( 'ASC' === strtoupper( $vars['order'] ) ) ) ? 'ASC' : 'DESC';

		return $clauses;
	}

	/**
	 * Add our filter names to the public query vars.
	 *
	 * @param array<int,string> $vars Public query variables.
	 * @return array<int,string> Updated public query variables.
	 */
	public function add_query_vars( array $vars ): array {
		/** @var array<string,mixed[]> */
		$site_filters = $this->args['site_filters'];
		$filters = array_keys( $site_filters );

		return array_merge( $vars, $filters );
	}

	/**
	 * Add our post type to the feed.
	 *
	 * @param array<string,mixed> $vars Request parameters.
	 * @return array<string,mixed> Updated request parameters.
	 */
	public function add_to_feed( array $vars ): array {
		# If it's not a feed, we're not interested:
		if ( ! isset( $vars['feed'] ) ) {
			return $vars;
		}

		if ( ! isset( $vars['post_type'] ) ) {
			$vars['post_type'] = [
				'post',
				$this->post_type,
			];
		} elseif ( is_array( $vars['post_type'] ) && ( count( $vars['post_type'] ) > 1 ) ) {
			$vars['post_type'][] = $this->post_type;
		}

		return $vars;
	}

	/**
	 * Add to or override our post type archive's private query vars.
	 *
	 * @param WP $wp The WP request object.
	 * @return WP Updated WP request object.
	 */
	public function override_private_query_vars( WP $wp ): WP {
		# If it's not our post type, bail out:
		if ( ! isset( $wp->query_vars['post_type'] ) || ( $this->post_type !== $wp->query_vars['post_type'] ) ) {
			return $wp;
		}

		# If it's a single post, bail out:
		if ( isset( $wp->query_vars['name'] ) ) {
			return $wp;
		}

		# Set the vars:
		foreach ( $this->args['archive'] as $var => $value ) {
			$wp->query_vars[ $var ] = $value;
		}

		return $wp;
	}

	/**
	 * Action fired after a PostType is registered in order to set up the custom permalink structure for the post type.
	 *
	 * @param string       $post_type        Post type name.
	 * @param WP_Post_Type $post_type_object Post type object.
	 */
	public function registered_post_type( string $post_type, WP_Post_Type $post_type_object ): void {
		if ( $post_type !== $this->post_type ) {
			return;
		}
		if ( ! $post_type_object->rewrite ) {
			return;
		}
		if ( ! is_string( $post_type_object->rewrite['permastruct'] ) ) {
			return;
		}

		$struct = str_replace( "%{$this->post_type}_slug%", $this->post_slug, $post_type_object->rewrite['permastruct'] );
		$struct = str_replace( '%postname%', "%{$this->post_type}%", $struct );

		add_permastruct( $this->post_type, $struct, $post_type_object->rewrite );
	}

	/**
	 * Filter the post type permalink in order to populate its rewrite tags.
	 *
	 * @param string  $post_link The post's permalink.
	 * @param WP_Post $post      The post in question.
	 * @return string The post's permalink.
	 */
	public function post_type_link( string $post_link, WP_Post $post ): string {
		# If it's not our post type, bail out:
		if ( $this->post_type !== $post->post_type ) {
			return $post_link;
		}

		/** @var string */
		$date = mysql2date( 'Y m d H i s', $post->post_date );
		$date = explode( ' ', $date );
		$replacements = [
			'%year%'     => $date[0],
			'%monthnum%' => $date[1],
			'%day%'      => $date[2],
			'%hour%'     => $date[3],
			'%minute%'   => $date[4],
			'%second%'   => $date[5],
			'%post_id%'  => $post->ID,
		];

		if ( false !== strpos( $post_link, '%author%' ) ) {
			$author = get_userdata( (int) $post->post_author );
			if ( $author ) {
				$replacements['%author%'] = $author->user_nicename;
			} else {
				$replacements['%author%'] = '-';
			}
		}

		/** @var string $tax */
		foreach ( get_object_taxonomies( $post ) as $tax ) {
			if ( false === strpos( $post_link, "%{$tax}%" ) ) {
				continue;
			}

			$terms = get_the_terms( $post, $tax );

			if ( $terms && ! is_wp_error( $terms ) ) {
				/**
				 * Filter the term that gets used in the `$tax` permalink token.
				 *
				 * @param WP_Term   $term  The `$tax` term to use in the permalink.
				 * @param WP_Term[] $terms Array of all `$tax` terms associated with the post.
				 * @param WP_Post   $post  The post in question.
				 */
				$term_object = apply_filters( "post_link_{$tax}", reset( $terms ), $terms, $post );

				$term = $term_object->slug;

			} else {
				$term = $post->post_type;

				/**
				 * Filter the default term that gets used in the `$tax` permalink token.
				 *
				 * @param int     $term The ID of the term to use in the permalink.
				 * @param WP_Post $post The post in question.
				 */
				$default_term_id = (int) apply_filters( "default_{$tax}", get_option( "default_{$tax}", 0 ), $post );

				if ( $default_term_id ) {
					$default_term = get_term( $default_term_id, $tax );
					if ( $default_term instanceof WP_Term ) {
						$term = $default_term->slug;
					}
				}
			}

			$replacements[ "%{$tax}%" ] = $term;
		}

		$post_link = str_replace( array_keys( $replacements ), $replacements, $post_link );

		return $post_link;
	}

	/**
	 * Add our rewrite tests to the Rewrite Rule Testing tests array.
	 *
	 * @codeCoverageIgnore
	 *
	 * @param array<string,array<string,string>> $tests The existing rewrite rule tests.
	 * @return array<string,array<string,string>> Updated rewrite rule tests.
	 */
	public function rewrite_testing_tests( array $tests ): array {
		require_once __DIR__ . '/ExtendedRewriteTesting.php';
		require_once __DIR__ . '/PostTypeRewriteTesting.php';

		$extended = new PostTypeRewriteTesting( $this );

		return array_merge( $tests, $extended->get_tests() );
	}

	/**
	 * Registers our post type.
	 *
	 * The only difference between this and regular `register_post_type()` calls is this will trigger an error of
	 * `E_USER_ERROR` level if a `WP_Error` is returned.
	 *
	 */
	public function register_post_type(): void {
		if ( ! isset( $this->args['query_var'] ) || ( true === $this->args['query_var'] ) ) {
			$query_var = $this->post_type;
		} else {
			$query_var = $this->args['query_var'];
		}

		$existing = get_post_type_object( $this->post_type );
		$taxonomies = get_taxonomies(
			[
				'query_var' => $query_var,
			],
			'objects'
		);

		if ( $query_var && count( $taxonomies ) ) {
			// https://core.trac.wordpress.org/ticket/35089
			foreach ( $taxonomies as $tax ) {
				if ( $tax->query_var === $query_var ) {
					trigger_error(
						esc_html(
							sprintf(
								/* translators: %s: Post type query variable name */
								__( 'Post type query var "%s" clashes with a taxonomy query var of the same name', 'extended-cpts' ),
								$query_var
							)
						),
						E_USER_ERROR
					);
				}
			}
		}

		if ( empty( $existing ) ) {
			$cpt = register_post_type( $this->post_type, $this->args );

			if ( is_wp_error( $cpt ) ) {
				trigger_error( esc_html( $cpt->get_error_message() ), E_USER_ERROR );
			}
		} else {
			# This allows us to call `register_extended_post_type()` on an existing post type to add custom functionality
			# to the post type.
			$this->extend( $existing );
		}
	}

	/**
	 * Extends an existing post type object. Currently only handles labels.
	 *
	 * @param WP_Post_Type $pto A post type object.
	 */
	public function extend( WP_Post_Type $pto ): void {
		# Merge core with overridden labels
		$this->args['labels'] = array_merge( (array) get_post_type_labels( $pto ), $this->args['labels'] );

		$GLOBALS['wp_post_types'][ $pto->name ]->labels = (object) $this->args['labels'];
	}

	/**
	 * Helper function for registering a taxonomy and adding it to this post type.
	 *
	 * Accepts the same parameters as `register_extended_taxonomy()`, minus the `$object_type` parameter.
	 *
	 * Example usage:
	 *
	 *     $events = register_extended_post_type( 'event' );
	 *     $location = $events->add_taxonomy( 'location' );
	 *
	 * @param string               $taxonomy The taxonomy name.
	 * @param array<string,mixed>  $args     Optional. The taxonomy arguments.
	 * @param array<string,string> $names    Optional. An associative array of the plural, singular, and slug names.
	 * @return WP_Taxonomy Taxonomy object.
	 */
	public function add_taxonomy( string $taxonomy, array $args = [], array $names = [] ): WP_Taxonomy {
		if ( taxonomy_exists( $taxonomy ) ) {
			register_taxonomy_for_object_type( $taxonomy, $this->post_type );
		} else {
			register_extended_taxonomy( $taxonomy, $this->post_type, $args, $names );
		}

		/** @var WP_Taxonomy */
		$tax = get_taxonomy( $taxonomy );

		return $tax;
	}

}
