<?php
namespace JVBase\registrar;


use JVBase\base\Site;
use JVBase\inc\registrar\helpers\HideSingle;
use JVBase\managers\Cache;
use JVBase\managers\CRUD;
use JVBase\managers\IconsManager;
use JVBase\managers\KarmaManager;
use JVBase\meta\Meta;
use JVBase\registrar\config\Breadcrumbs;
use JVBase\registrar\config\Dashboard;
use JVBase\registrar\config\Directory;
use JVBase\registrar\config\Feed;
use JVBase\registrar\config\Integration;
use JVBase\registrar\config\Section;
use JVBase\registrar\config\SEO;
use JVBase\registrar\helpers\AddIntegrationFields;
use JVBase\registrar\helpers\MakeCalendarType;
use JVBase\registrar\helpers\MakeTimelineType;
use JVBase\registrar\helpers\MakeTrackChanges;
use JVBase\registrar\helpers\MakeVerification;
use WP_Query;

if (!defined('ABSPATH')) {
	exit;
}

class Registrar {
	protected string $slug;
	protected string $type;
	protected string $singular;
	protected string $plural;
	protected string $profile;
	protected string $description ='';
	protected Fields $fields;
	protected array $sections = [];
	//For the Terms/Post Registrar
	protected array $args= [];
	protected array $sectionOrder = [];
	public Posts|Terms|false $registrar = false;
	protected ?string $icon = null;

	protected ?string $upload_title = null;

	protected int|false $page = false;

	public ?string $rewrite_taxonomy = null;

	public bool $add_image_column = false;

	protected static array $allFlags = [
		//Shared Flags
		'favouritable', 'karma', 'show_feed', 'show_directory', 'approve_new', 'has_responses', 'invitable',
		//Post Flags
		'hide_single', 'redirect_to_author', 'is_calendar', 'single_image', 'is_timeline', 'is_gallery', 'is_faq', 'is_glossary', 'rewrite_taxonomy', 'add_image_column',
		//Taxonomy Flags
		'is_content', 'is_ownable', 'verify_entry', 'track_changes', 'associate_user_content',
		//User Flags
		'has_dashboard', 'can_register', 'can_create', 'keep_stats', 'can_favourite', 'member_verified', 'profile_link', 'manage_others'
	];
	/**********************************************************************************************
	SHARED FLAGS
	 **********************************************************************************************/
	/**
	 * @var bool Whether this can be favourited
	 */
	protected bool $favouritable = false;
	/**
	 * @var bool Whether to setup karma for this content
	 */
	protected bool $karma = false;
	protected ?KarmaManager $karmaManager = null;
	/**
	 * @var bool Whether this should be available in the feed block
	 */
	protected bool $show_feed = true;
	/**
	 * @var bool Whether this should get a directory page
	 */
	protected bool $show_directory = false;
	/**
	 * @var bool Whether these should be approved by admin/verified users before being public
	 */
	protected bool $approve_new;
	/**
	 * @var bool Whether this item can have responses
	 */
	protected bool $has_responses;
	/**
	 * @var bool For Terms: Whether members in this taxonomy can invite other members to join
	 * For User Roles: Whether verified members can invite people to join the site
	 */
	protected bool $invitable;
	/**********************************************************************************************
	POST FLAGS
	 **********************************************************************************************/
	/**
	 * @var bool Whether single items of this content should be hidden
	 */
	protected bool $hide_single = false;
	protected ?HideSingle $hideSingleHandler = null;

	/**
	 * @var bool Whether single items should just go to the author's page
	 */
	protected bool $redirect_to_author;
	/**
	 * @var bool Whether to make this a calendar type (example: events)
	 */
	protected bool $is_calendar = false;
	protected ?MakeCalendarType $isCalendarHandler = null;
	/**
	 * @var bool Whether this is a before/after post type
	 */
	protected bool $is_timeline = false;
	protected ?MakeTimelineType $isTimelineHandler = null;
	/**
	 * @var bool Whether this is a defined term post type
	 */
	protected bool $is_glossary = false;
	/**
	 * @var bool Whether this is a faq post type
	 */
	protected bool $is_faq = false;
	/**
	 * @var bool Whether the uploader can group images prior to upload
	 */
	protected bool $single_image;
	/**********************************************************************************************
	TAXONOMY FLAGS
	 ********************************************************************************************/
	/**
	 * @var bool For taxonomy types only. Treats the taxonomy as a content (ie: tattoo shops))
	 */
	protected bool $is_content = false;
	/**
	 * @var bool Whether this taxonomy can be owned/managed by specific people only
	 */
	protected bool $is_ownable;
	/**
	 * @var bool Whether users/content need to request the owner for admission
	 */
	protected bool $verify_entry = false;
	protected ?MakeVerification $verifyEntryHandler = null;
	/**
	 * @var bool Whether we should track post movements from term to term (ie. artists in tattoo shops)
	 */
	protected bool $track_changes = false;
	protected ?MakeTrackChanges $trackChangesHandler = null;

	/**
	 * @var bool Whether any content by members in this taxonomy should show up in this taxonomy
	 */
	protected bool $associate_user_content;

	/*************************************************************************************
	USER FLAGS
	*************************************************************************************/
	/**
	 * @var bool Whether this user role has access to the dashboard
	 */
	protected bool $has_dashboard;
	/**
	 * @var bool Whether this user role can register
	 */
	protected bool $can_register;
	/**
	 * @var bool Whether to track basic statistics for this role
	 */
	protected bool $keep_stats;
	/**
	 * @var bool Whether this role can favourite
	 */
	protected bool $can_favourite;
	/**
	 * @var bool Whether this role should be verified before they can publish anything
	 */
	protected bool $member_verified;
	/**
	 * @var bool Whether to generate a profile for this user role
	 */
	public bool $profile_link;
	/**
	 * @var array|string
	 */
	protected array $can_create = [];
	/**
	 * @var array slugs of other user roles this role can manage
	 */
	protected array $manage_others = [];
	/**
	 * @var string The slug of the taxonomy that defines different access points
	 * Example, for edmonton.ink, we have artist_type, and $this->>can_create would be:
	 * 		[
	 * 			'piercer'	=> ['piercings', 'artwork', 'events'],
	 * 			'tattoo_artist'=> ['tattoos', 'artwork', 'events'],
	 * 			'artist'	=> ['artwork']
	 * 		]
	 */
	protected string $user_subtype;

	/** Configs **/
	protected Breadcrumbs $breadcrumbs;
	protected Dashboard $dashboard;
	protected Directory|false $directory;
	protected Feed|false $feed;
//	protected Management $management;
//	protected Responses $responses;
	protected ?SEO $seo = null;

	/** Helpers **/
	protected MakeCalendarType|false $calendar = false;
	protected array $integrationConfigs = [];
	protected array $integrationFields = [];
	protected MakeTrackChanges $trackChanges;
	protected MakeVerification $verification;

	private static array $instances = [];

	protected string $based;
	private function __construct(string $slug, string $singular, string $plural, string $type) {
		$this->slug = $slug;
		$this->based = jvbCheckBase($slug);
		$this->type = $type;
		$this->singular = $singular;
		$this->plural = $plural;

//		$this->init();

//		$this->initClasses();
		$this->setFields();

		add_action('init', [$this, 'register'], 2);
		add_filter('jvbDashboardPage', [$this, 'renderDashPage'], 10, 3);
	}

	protected function initRegistrar():void {
		$this->registrar = match ($this->type) {
			'post' => new Posts($this->slug, $this->singular, $this->plural),
			'term' => new Terms($this->slug, $this->singular, $this->plural),
			default => false,
		};
	}

	protected function initClasses():void {
		$this->breadcrumbs 	= new Breadcrumbs($this->slug);
		$this->dashboard 	= new Dashboard($this->slug);
		$this->directory 	= new Directory($this->singular);
		$this->feed 		= new Feed($this->slug);
//		$this->management 	= new Management($this->slug);
//		$this->responses 	= new Responses($this->slug);
		$this->seo 			= new SEO($this->slug);
//		$this->trackChanges = new TrackChanges($this->slug);
//		$this->Verification = new Verification($this->slug);
	}

	/**
	 * Instantiates for post types
	 * @param string $slug
	 * @return self
	 */
	public static function forPost(string $slug, string $singular, string $plural):self
	{
		if (!isset(self::$instances[$slug])) {
			self::$instances[$slug] = new self($slug, $singular, $plural,'post');
		}
		return self::$instances[$slug];
	}

	/**
	 * Instantiates for term types
	 * @param string $slug
	 * @return self
	 */
	public static function forTerm(string $slug, string $singular, string $plural):self
	{
		if (!isset(self::$instances[$slug])) {
			self::$instances[$slug] = new self($slug, $singular, $plural,'term');
		}
		return self::$instances[$slug];
	}

	/**
	 * Instantiates for user types
	 * @param string $slug
	 * @return self
	 */
	public static function forUser(string $slug, string $singular, string $plural):self
	{
		if (!isset(self::$instances[$slug])) {
			self::$instances[$slug] = new self($slug, $singular, $plural, 'user');
		}
		return self::$instances[$slug];
	}

	/**
	 * Adds the properties for register_post_type or register_taxonomy
	 * @param array $args
	 * @return $this
	 */
	public function make(array $args):self
	{
		$this->initRegistrar();
		if (!$this->registrar) {
			return $this;
		}
		$this->args = $args;

		foreach ($args as $property => $value) {
			if (property_exists($this->registrar, $property)) {
				$this->registrar->$property = $value;
			}

			if (property_exists($this, $property)) {
				$this->$property = $value;
			}

		}
		if (isset($this->icon) && !str_contains($this->icon, 'dashicons')){
			$this->registrar->menu_icon = IconsManager::for()->getCSSIcon($this->icon);
		}
		return $this;
	}

	public function fields():Fields
	{
		return $this->fields;
	}

	public function args():array
	{
		return $this->args;
	}

	public function setFields():void
	{
		$this->fields = new Fields($this->type, $this);
	}
	public function getFields():array
	{
		return array_map(function ($field) {
			return $field->getConfig();
		},
			$this->fields->getFields()
		);
	}
	public function setIcon(string $icon):self
	{
		$this->icon = $icon;
		return $this;
	}
	public function getIcon(?string $default = null):string
	{
		if (!$default) {
			$default = jvbDefaultIcon();
		}

		return $this->icon ?: $default;
	}
	public function getSingular():string
	{
		return $this->singular;
	}
	public function getPlural():string
	{
		return $this->plural;
	}
	public function getDescription():string
	{
		return $this->description;
	}
	public function setDescription(string $description):self
	{
		$this->description = $description;
		return $this;
	}

	public function getType():string
	{
		return $this->type;
	}
	public function setIntegration(string $integration):self
	{

		if (!Site::hasIntegration($integration)){
			error_log('Integration not available for '.$this->slug.': '.$integration);
			return $this;
		}
		$this->integrationConfigs[$integration] = new Integration($integration, $this);
		$this->integrationFields[$integration] = new AddIntegrationFields($integration, $this);
		return $this;
	}
	public function getIntegrationFields(string $integration):AddIntegrationFields|false
	{

		if (!Site::has($integration)){
			error_log('Integration not available for '.$this->slug.': '.$integration);
			return false;
		}
		if (!in_array($integration, $this->integrationFields)) {
			error_log('No integration fields intitialized for '.$integration);
			return false;
		}
		return $this->integrationFields[$integration];
	}
	public function getIntegrations():array
	{
		return $this->integrationConfigs;
	}
	public function hasIntegration(string $integration) {
		return in_array($integration, $this->integrationConfigs);
	}
    public function hasAnyIntegrations(array $integrations = []):bool
    {
        if (empty($integrations)) {
            $integrations = array_keys($this->integrationConfigs);
            return !empty($integrations);
        }
        return !empty(array_intersect($integrations, array_keys($this->integrationConfigs)));
    }
	public function setUploadTitle(string $title):self
	{
		$this->upload_title = $title;
		return $this;
	}

	public function getUploadTitle():string {
		return ($this->upload_title) ?: 'Upload '.$this->plural;
	}

	public function getSlug():string
	{
		return $this->slug;
	}

	public function getBased():string
	{
		return $this->based;
	}

	public function setGlossary(bool $set):self
	{
		$this->is_glossary = $set;
//		if ($set) {
//			$this->timeline = new MakeTimelineType($this->slug, $this);
//		}
		return $this;
	}
	public function isGlossary():bool
	{
		return $this->is_glossary;
	}
	public function setFaq(bool $set):self
	{
		$this->is_faq = $set;
//		if ($set) {
//			$this->timeline = new MakeTimelineType($this->slug, $this);
//		}
		return $this;
	}
	public function isFaq():bool
	{
		return $this->is_faq;
	}
	public function setTimeline(bool $set):self
	{
		$this->is_timeline = $set;
//		if ($set) {
//			$this->timeline = new MakeTimelineType($this->slug, $this);
//		}
		return $this;
	}
	public function isTimeline():bool
	{
		return $this->is_timeline;
	}
	public function setCalendar(bool $set):self
	{
		$this->is_calendar = $set;
		if ($set) {
			$this->calendar = new MakeCalendarType($this->slug, $this);
		}
		return $this;
	}

	public function setAll(array $flags):self
	{
		$flags = array_filter($flags, function($flag) {
			return in_array($flag, static::$allFlags);
		});
		foreach ($flags as $flag) {
			$this->$flag = true;
			switch ($flag) {
				case 'is_content':
					add_action('init', [$this, 'setupContent'], 20);
					break;
				case 'is_glossary':
					$this->hide_single = true;
					break;
			}
		}
		return $this;
	}
	public function removeAll(array $flags):self
	{
		$flags = array_filter($flags, function($flag) {
			return in_array($flag, static::$allFlags);
		});
		foreach ($flags as $flag) {
			$this->$flag = false;
		}
		return $this;
	}


	public function hasFeature(string $feature):bool
	{
		if (!in_array($feature, static::$allFlags)) {
			return false;
		}
		return isset($this->$feature) && $this->$feature === true;
	}
	public static function getFeatured(string $feature, ?string $type = null):array
	{
		self::ensureInstanced();

		if (!in_array($feature, static::$allFlags)) {
			error_log('Feature requested not found: '.$feature);
			return [];
		}

		return array_map(function($inst) { return $inst->slug; },array_filter(self::$instances, function ($inst) use ($feature, $type){
			if (!is_null($type) && $inst->type !== $type) {
				return false;
			}
			return property_exists($inst, $feature) && isset($inst->$feature) && $inst->$feature === true;
		}));
	}

	public function config(string $config):mixed
	{
		$allowed = ['breadcrumbs','calendar','dashboard','directory','feed','management','has_responses','seo','trackchanges','verification'];
		if (!in_array(strtolower($config), $allowed)) {
			error_log('Invalid config requested from Registrar: '.$config);
			return [];
		}
		return match(strtolower($config)) {
			'breadcrumbs' 	=> $this->getBreadcrumbs(),
			'dashboard'		=> $this->getDashboard(),
			'directory'		=> $this->getDirectory(),
			'feed'			=> $this->getFeed(),
			'management'	=> $this->getManagement(),
			'has_responses'	=> $this->getResponses(),
			'seo'			=> $this->getSEO(),
			'trackchanges'	=> $this->getTrackChanges(),
			'verification'	=> $this->getVerification()
		};
	}
		protected function getBreadcrumbs():Breadcrumbs
		{
			if (!isset($this->breadcrumbs)) {
				$this->breadcrumbs = new Breadcrumbs($this->slug, $this);
			}

			return $this->breadcrumbs;
		}
		protected function getCalendar():MakeCalendarType|false
		{
			if ($this->is_calendar && !isset($this->calendar)){
				$this->calendar = new MakeCalendarType($this->slug, $this);
			} else {
				$this->calendar = false;
			}
			return $this->calendar;
		}

		protected function getDashboard():Dashboard
		{
			if (!isset($this->dashboard)) {
				$this->dashboard = new Dashboard($this->plural, $this);
			}

			return $this->dashboard;
		}

		protected function getDirectory():Directory|false
		{
			if (!isset($this->directory)) {
				$this->directory = new Directory($this->singular);
			}
			return $this->directory;
		}

		protected function getFeed():Feed|false
		{
			if (!isset($this->feed)) {
				$this->feed = new Feed($this->slug);
			}
			return $this->feed;
		}

		public function getSEO():SEO
		{
			if (!isset($this->seo)){
				$this->seo = new SEO($this->slug);
			}
			return $this->seo;
		}

	public function getSections():array
	{
		$allSections = array_map(function($section) {
			return $section->getConfig;
		}, $this->sections);

		if (!empty($this->sectionOrder)) {
			$allSections['order'] = $this->sectionOrder;
		}
		return $allSections;
	}
	public function addSection(string $title):Section
	{
		$section = new Section($title, $this);
		$this->sections[] = $section;
		return $section;
	}

	public function setSectionOrder(array $sections):self
	{
		$allSections = array_map(function($section) {
			return $section->getSlug;
		}, $this->sections);
		$this->sectionOrder = array_intersect($allSections, $sections);
		return $this;
	}
	public function getSectionOrder():array
	{
		return $this->sectionOrder;
	}

	public function getConfig(string $config):array
	{
		$allowed = ['breadcrumbs','calendar','dashboard','directory','feed','management','has_responses','seo','trackchanges','verification'];
		if (!in_array(strtolower($config), $allowed)) {
			error_log('Invalid config requested from Registrar: '.$config);
			return [];
		}
		$config = $this->config($config);
		return ($config) ? $config->getConfig() : [];
	}

	public function getIntegration(string $service_name):Integration|false
	{
		if (array_key_exists($service_name, $this->integrationConfigs)) {
			return $this->integrationConfigs[$service_name];
		}
		return false;
	}
	public function getIntegrationConfig(string $service_name):array|false
	{
		$integration = $this->getIntegration($service_name);
		if ($integration){
			return $integration->getConfig();
		}
		return false;
	}

	public function register():void
	{
		if ($this->type === 'post') {
			if ($this->hide_single) {
				$this->hideSingleHandler = new HideSingle($this->slug, $this);
			}
			if ($this->is_timeline) {
				$this->isTimelineHandler = new MakeTimelineType($this->slug, $this);
				$this->registrar->hierarchical = true;
			}
			if ($this->is_calendar) {
				$this->isCalendarHandler = new MakeCalendarType($this->slug, $this);
			}

			if (!is_null($this->rewrite_taxonomy)) {
				$this->registrar->addTaxonomyRewrite($this->rewrite_taxonomy);
			}

			if ($this->registrar) {
				$this->registrar->register();
			}
			if ($this->add_image_column) {
				add_filter("manage_{$this->based}_posts_columns", [$this, 'addImageColumn']);
				add_action("manage_{$this->based}_posts_custom_column", [$this, 'showImageColumn'], 10, 2);
			}
		} elseif ($this->type === 'term') {
			if ($this->is_content) {
				if ($this->verify_entry) {
					$this->verifyEntryHandler = new MakeVerification();
				}
				if ($this->track_changes) {
					$this->trackChangesHandler = new MakeTrackChanges($this->slug);
				}
			}

			if ($this->registrar) {
				$this->registrar->register();
			}
		}

		if ($this->karma) {
			$this->karmaManager = KarmaManager::for($this->slug, $this->type);
		}
	}
	public static function getInstance(string $slug):Registrar|false
	{
		self::ensureInstanced();

		$slug = jvbNoBase($slug);
		if (array_key_exists($slug, static::$instances)) {
			return static::$instances[$slug];
		}
		return false;
	}

	public static function getFieldsFor(string $slug):array
	{
		self::ensureInstanced();
		if (!array_key_exists($slug, static::$instances)) {
			return [];
		}
		$instance = static::$instances[$slug];
		return $instance->getFields();
	}

	public static function getRegistered(?string $type = null):array
	{
		self::ensureInstanced();
		$instances = ($type) ? array_filter(static::$instances, function($instance) use ($type) {
			return $instance->type === $type;
		}) : static::$instances;
		return array_keys($instances);
	}

	public static function getLabels():array
	{
		self::ensureInstanced();
		return array_map(function ($instance) {
			return ['singular' => $instance->getSingular(),
				'plural' => $instance->getPlural()];
		}, static::$instances);
	}

	public function getCreatable(bool $based = false):array
	{
		if ($this->type !== 'user') {
			return [];
		}
		return $based ? array_map(function ($item) { return jvbCheckBase($item); },$this->can_create) : $this->can_create;
	}
	public function setCreatable(string|array $creatable):self
	{
		$this->can_create = is_string($creatable) ? [jvbNoBase($creatable)] : array_map(function ($type) {
            return jvbNoBase($type);
        }, $creatable);
		return $this;
	}


	public function getManageOthers():array
	{
		if ($this->type !== 'user'){
			return [];
		}
		return $this->manage_others;
	}
	public function setManageOthers(array $manageable):self
	{
		$this->manage_others = $manageable;
		return $this;
	}

	public function renderDashPage(string $content, string $page, string $slug):string
	{
		if ($slug === $this->slug) {
			ob_start();
			$crud = new CRUD($slug);
			$crud->render();
			return ob_get_clean();
		}

		return $content;
	}

	public function setupContent():void
	{
		if (!$this->is_content) return;
		//We need a pseudo-archive page for this content taxonomy. We create a post with the plural name
		$this->page = get_option(BASE.$this->slug.'_archive', false);
		if (!$this->page || !(bool)get_post((int)$this->page)) {
			$exists = new WP_Query([
				'post_type'	=> 'page',
				'title'=> $this->plural,
				'posts_per_page'	=> 1,
				'post_status'	=> 'publish',
				'fields'	=> 'ids',
			]);
			if ($exists->have_posts()) {
				$page = $exists->posts[0];
			} else {
				$page = wp_insert_post([
					'post_type'		=> 'page',
					'post_title'	=> $this->plural,
					'post_content'	=> '',
					'post_status'	=> 'publish',
				]);
			}

			if ($page && !is_wp_error($page)) {
				update_post_meta($page, BASE.'for_type', $this->slug);
				update_option(BASE.$this->slug.'_archive', $page);
				$this->page = $page;
			}
			wp_reset_postdata();
		}
		add_filter('jvb_post_content_output', [$this, 'renderContent'], 20, 2);


		//Add a date published and date modified fields, and auto-update them on term creation/modification
		$this->fields()->addField('date_published', [
			'type'	=> 'datetime',
			'label'	=> 'Published',
			'hidden'	=> true,
		]);
		$this->fields()->addField('date_modified', [
			'type'	=> 'datetime',
			'label'	=> 'Modified',
			'hidden'	=> true,
		]);
		add_action('created_'.$this->based, [$this, 'addTermCreatedMeta']);
		add_action('edited_'.$this->based, [$this, 'addTermUpdatedMeta']);
	}
		public function addTermCreatedMeta(int $termId):void
		{
            update_term_meta($termId, BASE . 'date_published', date('Y-m-d H:i:s'));
            update_term_meta($termId, BASE . 'date_modified', date('Y-m-d H:i:s'));
		}
		public function handleContentTermMetaChange(int $meta_id, int $term_id, string $meta_key, $meta_value):void
		{
			$term = get_term($term_id);
			$taxonomy = $term->taxonomy;
			if ($taxonomy === $this->based && $meta_key !== BASE . 'date_modified') {
				$meta = Meta::forTerm($term_id);
				$meta->set('date_modified', date('Y-m-d H:i:s'));
			}

		}
		public function addTermUpdatedMeta(int $termId):void
		{

            static $processing = [];
            if (isset($processing[$termId])) return;
            $processing[$termId] = true;

            update_term_meta($termId, BASE . 'date_modified', date('Y-m-d H:i:s'));

            unset($processing[$termId]);
		}
	public function renderContent(string $content, array $block):string
	{
		if (!is_page($this->page)) {
			return $content;
		}
		if ($block['blockName'] !== 'core/post-content') {
			return $content;
		}
		if (JVB_TESTING) {
			Cache::for($this->slug)->flush();
		}

        $per_page = 10;
        $page = $_GET['tp']??1;

        $args = apply_filters('jvb_content_tax_args_'.$this->slug, [
            'taxonomy'	=> $this->based,
//						'hide_empty' => true,
            'fields'	=> 'ids',
            'number'     => $per_page,
            'offset'    => ($page - 1) * $per_page,
            'meta_key'  => BASE.'date_modified',
            'meta_type' => 'DATETIME',
            'orderby'   => 'meta_value'
        ]);
        $cache = Cache::for($this->slug);

        $max = get_terms([
            'taxonomy'  => $this->based,
            'fields'    => 'ids',
            'number'     => 0,
            'hide_empty'    => true
        ]);
        $max = count($max??[]);
        $totalPages = floor($max/$per_page);

        global $wp;
        $current = get_home_url(null, '/'.$wp->request);

        $pages = '';
        for ($i = 1; $i<=$totalPages; $i++) {
            $pages .= (int)$page === $i ?
                sprintf(
                    '<li class="current">%s</li>',
                    $i
                ): sprintf(
                '<li><a href="%s">%s</a></li>',
                add_query_arg('tp', $i, $current),
                $i
            );
        }

        $nav = sprintf(
            '<nav class="pagination">%s<ul>%s</ul>%s</nav>',
            $page > 1 ? '<a href="'.add_query_arg('tp', $page-1, $current).'" title="Next Page" class="btn">'.jvbIcon('arrow-circle-left').'<span class="screen-reader-text">Previous Page</span></a>' : '',
            $pages,
            $page < $totalPages ? '<a href="'.add_query_arg('tp', $page+1, $current).'" title="Next Page" class="btn">'.jvbIcon('arrow-circle-right').'<span class="screen-reader-text">Next Page</span></a>' : '',
        );

		$out = $nav. Cache::for($this->slug)->remember(
			$cache->generateKey(['type' =>'contentArchive', ... $args]),
			function() use ($args) {


				$items = get_terms($args);
				$out = [];


                $method = BASE.'render_'.$this->slug.'_content';
				if ($items && !is_wp_error($items)) {
					foreach ($items as $termID) {
                        if (function_exists($method)) {
                            $out[] = $method($termID);
                            continue;
                        }
						$meta = Meta::forTerm($termID);
						$slug = sanitize_title($meta->get('name'));
						$item = sprintf(
							'<li id="%s"><h2><a href="%s">%s</a></h2><p>%s</p><ul class="loop scroll">',
							$slug,
							get_term_link($termID, $this->based)??'',
							$meta->get('name'),
							$meta->get('description')
						);
							$postTypes = array_map(function($type) { return jvbCheckBase($type);}, $this->registrar->for);
							$posts = new WP_Query([
								'post_type'		=> $postTypes,
								'post_status'	=> 'publish',
								'posts_per_page'	=> 3,
								'fields'	=> 'ids',
                                'tax_query' => [
                                    [
                                        'taxonomy'  => $this->based,
                                        'terms'     => $termID
                                    ]
                                ]
							]);
							if ($posts->have_posts()) {
								while($posts->have_posts()) {
									$posts->the_post();
									$ID = get_the_id();
									$postMeta = Meta::forPost($ID);
									$img = $postMeta->get('post_thumbnail');
									$img = !empty($img) ? jvbFormatImage((int)$img, 'tiny', 'medium') : '';
									$item .= sprintf(
										'<li id="%s" class="item"><h3><a href="%s">%s</a></h3>%s</li>',
										$slug.'-'.sanitize_title(get_the_title($ID)),
										get_the_permalink($ID),
										$postMeta->get('post_title'),
										$img
									);
								}
							}
							wp_reset_postdata();
						$item .= '</ul></li>';
						$out[] = $item;
					}
				}

                $before = apply_filters(BASE.'before_'.$this->slug.'_content','');
                $out = empty($out) ? '' : '<ul class="content-term-list">'.implode('',$out).'</ul>';
                $after = apply_filters(BASE.'after_'.$this->slug.'_content', '');
                return $before.$out.$after;
			}
		).$nav;
		error_log('Built the '.$this->slug.' page content.');
		return $content . $out;
	}

	public static function ensureInstanced():void
	{
		if (empty(self::$instances)) {
			do_action('jvbDefineRegistrar');
			do_action('jvbDefineRegistrarFields');
		}
	}

	/*****************************************************************
	 * FLAGGED FEATURES
	*****************************************************************/

	public function profile(?string $slug = null, ?string $singular = null, ?string $plural = null):self
	{
		if (!$slug) {
			$slug = $this->slug.'_profile';
		}
		if (!$singular) {
			$singular = $this->singular;
		}
		if (!$plural) {
			$plural = $this->plural;
		}
		$this->profile_link = true;

		$this->profile = $slug;

		return Registrar::forPost($slug, $singular, $plural);
	}
	public function getProfile():self|false
	{
		if (!$this->profile_link) {
			return false;
		}
		return self::getInstance($this->profile);
	}

    public static function getProfileTypes():array
    {
        $hasProfiles = self::getFeatured('profile_link');
        if (empty($hasProfiles)) {
            return [];
        }
        return array_filter(array_map(function($profile) {
            $instance = self::getInstance($profile);
            return $instance->getProfile()->based??false;
        }, $hasProfiles));
    }

	public function setUserSubtype(string $type):self
	{
		$this->user_subtype = sanitize_text_field($type);
		return $this;
	}
	public function getUserSubtype():string|false
	{
		return $this->user_subtype??false;
	}

	public function addImageColumn(array $columns):array
	{
		$keys = array_keys($columns);
		$index = array_search('cb', $keys);
		if ($index !== false) {
			$pos = $index+1;
			$columns = array_slice($columns, 0, $pos, true) + ['jvb_featured_image' => 'Image'] + array_slice($columns, $pos, null, true);
		}
		return $columns;
	}
	public function showImageColumn(string $column, int $postID):void
	{
		if ($column === 'jvb_featured_image') {
			echo get_the_post_thumbnail($postID, 'tiny');
		}
	}
}