<?php
namespace JVBase\rest;

use JVBase\managers\Cache;
use JVBase\meta\Meta;
use JVBase\registrar\Registrar;
use JVBase\base\Site;
use WP_REST_Request;
use WP_REST_Response;
use Exception;

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

/**
 * Base REST Route Manager
 *
 * Provides shared utilities for route handlers. Route registration
 * should use the Route builder class.
 *
 * Responsibilities:
 * - Cache management (headers, invalidation)
 * - Query building helpers
 * - Validation utilities
 * - Audit logging
 */
abstract class Rest
{
	protected string $namespace = 'jvb/v1';
	protected ?Cache $cache = null;
	protected string $cacheName = '';
	protected int $cacheTtl = 3600;
	protected static ?string $action;

	public function __construct()
	{
		if ($this->cacheName !== '') {
			$this->cache = Cache::for($this->cacheName, $this->cacheTtl);
		}

		add_action('rest_api_init', [$this, 'registerRoutes']);
	}

	/**
	 * Register routes - implement using Route builder
	 */
	abstract public function registerRoutes(): void;

	// =========================================================================
	// RESPONSE HELPERS
	// =========================================================================

	protected function success(array $data = [], int $status = 200): WP_REST_Response
	{
		return Response::success($data, $status);
	}

	protected function error(string $message, string $code = 'error', int $status = 400, ?string $field = null): WP_REST_Response
	{
		return Response::error($message, $code, $status, $field);
	}

	protected function validationError(array $errors): WP_REST_Response
	{
		return Response::validationError($errors);
	}

	protected function notFound(string $message = 'Not found'): WP_REST_Response
	{
		return Response::notFound($message);
	}

	protected function forbidden(string $message = 'Forbidden'): WP_REST_Response
	{
		return Response::forbidden($message);
	}

	protected function unauthorized(string $message = 'Unauthorized'): WP_REST_Response
	{
		return Response::unauthorized($message);
	}

	protected function queued(string $operationId, string $message = 'Queued for processing'): WP_REST_Response
	{
		return Response::queued($operationId, $message);
	}

	// =========================================================================
	// CACHE MANAGEMENT
	// =========================================================================

	protected function checkCache(string $key, $request):WP_REST_Response|false
	{
		// Check HTTP cache headers with the specific content type
		$cache_check = $this->checkHeaders($request, $key);
		if ($cache_check) {
			return $cache_check;
		}

		$cache = $this->cache->get($key);
		if ($cache) {
			$response = Response::success($cache);
			return $this->addCacheHeaders($response);
		}
		return false;
	}
	/**
	 * Check request headers for conditional caching (ETag, If-Modified-Since)
	 */
	protected function checkHeaders(WP_REST_Request $request, string $cacheKey): ?WP_REST_Response
	{
		if (!$this->cache) {
			return null;
		}

		$cached = $this->cache->get($cacheKey);
		if (!$cached) {
			return null;
		}

		$etag = $request->get_header('If-None-Match');
		$cachedEtag = $cached['etag'] ?? null;

		if ($etag && $cachedEtag && $etag === $cachedEtag) {
			return new WP_REST_Response(null, 304);
		}

		$ifModifiedSince = $request->get_header('If-Modified-Since');
		$lastModified = $cached['last_modified'] ?? null;

		if ($ifModifiedSince && $lastModified) {
			if (strtotime($ifModifiedSince) >= strtotime($lastModified)) {
				return new WP_REST_Response(null, 304);
			}
		}

		return null;
	}

	/**
	 * Add cache headers to response
	 */
	protected function addCacheHeaders(WP_REST_Response $response, int $maxAge = 300): WP_REST_Response
	{
		$response->header('Cache-Control', "private, max-age={$maxAge}");
		$response->header('Vary', 'Cookie');
		$response->header('ETag', '"' . md5(serialize($response->get_data())) . '"');
		$response->header('Last-Modified', gmdate('D, d M Y H:i:s') . ' GMT');

		return $response;
	}

	/**
	 * Store response in cache with metadata
	 */
	protected function cacheResponse(string $key, array $data): void
	{
		if (!$this->cache) {
			return;
		}

		$this->cache->set($key, [
			'data' => $data,
			'etag' => '"' . md5(serialize($data)) . '"',
			'last_modified' => gmdate('D, d M Y H:i:s') . ' GMT',
		]);
	}

	// =========================================================================
	// TIMESTAMP FORMATTING
	// =========================================================================

	/**
	 * Convert MySQL datetime to ISO 8601 timestamp
	 */
	protected function formatTimestamp(?string $mysqlDatetime): ?string
	{
		return Response::formatTimestamp($mysqlDatetime);
	}

	// =========================================================================
	// QUERY BUILDING
	// =========================================================================

	/**
	 * Apply taxonomy filters to WP_Query args
	 */
	protected function applyTaxonomyFilters(array $args, array $data):array
	{
		// Handle JSON-encoded taxonomy data
		if (array_key_exists('taxonomy', $data) && is_string($data['taxonomy'])) {
			$data['taxonomy'] = json_decode($data['taxonomy'], true);
		}

		$taxonomies = $data['taxonomies'] ?? $data['taxonomy'] ?? [];
		$taxQuery = [];

		foreach($taxonomies as $taxonomy => $terms) {
			// Better validation: check if taxonomy actually exists
			if (!taxonomy_exists(jvbCheckBase($taxonomy))) {
				continue;
			}

			$taxQuery[] = [
				'taxonomy'	=> jvbCheckBase($taxonomy),
				'field'     => 'term_id',
				'terms'		=> array_map(
					'absint',
					is_array($terms) ? $terms : explode(',', $terms)
				),
				'operator'  => 'IN'
			];
		}

		if (!empty($taxQuery)) {
			// Match 'all' = AND, anything else = OR
			$relation = ($data['match'] ?? 'all') === 'all' ? 'AND' : 'OR';

			$args['tax_query'] = array_merge([
				'relation'  => $relation,
			], $taxQuery);
		}

		// Keep existing author filtering logic
		$authorQuery = [];
		foreach (Registrar::getFeatured('can_create', 'user') as $type) {
			if (array_key_exists($type, $data)) {
				$artist_ids = array_map(
					'absint',
					is_array($data[$type]) ?
						$data[$type] :
						explode(',', $data[$type])
				);
				$authorQuery = array_merge($authorQuery, $artist_ids);
			}
		}
		if (!empty($authorQuery)) {
			$args['author__in'] = array_unique($authorQuery);
		}

		return $args;
	}

	/**
	 * Apply order/sort filters to WP_Query args
	 */
	protected function applyOrderFilters(array $args, array $data):array
	{
		// Check for custom order first
		$customArgs = $this->applyCustomOrder($args, $data);
		if ($customArgs !== null) {
			$order = (array_key_exists('order', $data)) ? strtoupper($data['order']) : 'DESC';
			$customArgs['order'] = (in_array($order, ['ASC', 'DESC'])) ? $order : 'DESC';
			return $customArgs;
		}

		//Handle random
		if (array_key_exists('orderby', $data) && $data['orderby'] === 'random') {
			$current_seed = floor(time() / 1800);
			$args['orderby'] = 'RAND(' . $current_seed . ')';
			unset($args['order']);
			return $args;
		}

		if (in_array($data['orderby'], ['date', 'modified', 'title', 'alphabetical'])) {
			if ($data['orderby'] === 'date' && $this->isTimeline($args, $data)) {
				$args['meta_key'] = BASE . 'latest_date';
				$args['orderby'] = 'meta_value_num';
			} else {
				$args['orderby'] = ($data['orderby'] === 'alphabetical') ? 'title' : $data['orderby'];
			}

		} else {
			switch ($data['orderby']) {
				case 'popularity':
					$args['meta_key'] = BASE.'upvotes';
					$args['orderby'] = 'meta_value_num';
					break;
				case 'karma':
					$args['meta_key'] = BASE.'karma';
					$args['orderby'] = 'meta_value_num';
					break;
				case 'unpopularity':
					$args['meta_key'] = BASE.'downvotes';
					$args['orderby'] = 'meta_value_num';
					break;
				case 'favourites':
					$args['meta_key'] = BASE.'total_favourites';
					$args['orderby'] = 'meta_value_num';
					break;
				case 'date':
				default:
					$args['orderby'] = 'date';
					break;
			}
		}
		$order = (array_key_exists('order', $data)) ? strtoupper($data['order']) : 'DESC';
		$args['order'] = (in_array($order, ['ASC', 'DESC'])) ? $order : 'DESC';

		return $args;
	}

	/**
	 * Apply custom order if defined in content/taxonomy/user config
	 *
	 * @param array $args WP_Query args
	 * @param array $data Request data
	 * @return array|null Modified args if custom order found, null otherwise
	 */
	protected function applyCustomOrder(array $args, array $data): ?array
	{
		$orderby = $data['orderby'] ?? '';

		// Skip if no orderby or it's a standard order
		if (empty($orderby) || in_array($orderby, ['date', 'modified', 'title', 'alphabetical', 'random', 'popularity', 'karma', 'unpopularity', 'favourites'])) {
			return null;
		}

		// Determine content type
		$post_type = is_array($args['post_type']) ? $args['post_type'][0] : $args['post_type'];
		$content = jvbNoBase($post_type);

		// Get config for this content type
		$registrar = Registrar::getInstance($content);
		if (!$registrar) {
			return null;
		}

		// Check if this orderby is a custom order
		$customOrders = $registrar->custom_order??[];
		if (empty($customOrders) || !isset($customOrders[$orderby])) {
			return null;
		}

		// Get field definition
		$fields = $registrar->getFields() ?? [];
		if (!isset($fields[$orderby])) {
			return null;
		}

		$field = $fields[$orderby];

		// Set meta_key
		$args['meta_key'] = BASE . $orderby;

		// Determine orderby and meta_type based on field type
		$fieldType = $field['type'] ?? 'text';
		$subtype = $field['subtype'] ?? '';

		switch ($fieldType) {
			case 'number':
				$args['orderby'] = 'meta_value_num';
				break;

			case 'text':
				$args['orderby'] = ($subtype === 'number') ? 'meta_value_num' : 'meta_value';
				break;

			case 'date':
				$args['orderby'] = 'meta_value';
				$args['meta_type'] = 'DATE';
				break;

			case 'datetime':
				$args['orderby'] = 'meta_value';
				$args['meta_type'] = 'DATETIME';
				break;

			case 'true_false':
			case 'checkbox':
				$args['orderby'] = 'meta_value';
				$args['meta_type'] = 'BINARY';
				break;

			default:
				$args['orderby'] = 'meta_value';
		}

		return $args;
	}

	protected function applyDateFilters(array $args, array $data):array
	{
		if (!array_key_exists('date-filter', $data) && !array_key_exists('dateFrom', $data)) {
			return $args;
		}
		if (array_key_exists('dateFrom', $data)) {
			$dateFrom = strtotime(sanitize_text_field($data['dateFrom']));
			$dateTo = strtotime(sanitize_text_field($data['dateTo']));
			if ($dateFrom && $dateTo) {
				$args['date_query'] = [
					[
						'after'     => date('c', $dateFrom),
						'before'    => date('c', $dateTo),
						'inclusive' => true,
					]
				];
			}
		} else {
			switch ($data['date-filter']) {
				case 'today':
					$args['date_query'] = [['after' => '1 day ago']];
					break;
				case 'week':
					$args['date_query'] = [['after' => '1 week ago']];
					break;
				case 'month':
					$args['date_query'] = [['after' => '1 month ago']];
					break;
				case 'year':
					$args['date_query'] = [['after' => '1 year ago']];
					break;
			}
		}
		return $args;
	}

	protected function applyCalendarFilters(array $args, array $data):array
	{
		$meta_query = [];
		$today = date('Y-m-d');
		if (in_array('future', $args['post_status'])) {
			$meta_query[] = [
				'key'	=> 'jvb_start_date',
				'value'	=> $today,
				'compare'	=> '>=',
				'type'	=> 'DATE'
			];
		}
		if (in_array('past', $args['post_status'])) {
			$meta_query[] = [
				'key' => 'jvb_end_date',
				'value' => $today,
				'compare' => '<',
				'type' => 'DATE'
			];
		}
		if (in_array('recurring', $args['post_status'])) {
			$meta_query[] = [
				'key' => 'jvb_is_recurring',
				'value' => true,
				'compare' => '='
			];
		}
		if (!empty($meta_query)) {
			$args['meta_query'] = (array_key_exists('meta_query', $args)) ? array_merge($args['meta_query'], $meta_query) : $meta_query;
		}
		return $args;

	}

	/**
	 * Apply pagination to WP_Query args
	 */
	protected function applyPagination(array $args, array $data): array
	{
		$args['posts_per_page'] = min(absint($data['per_page'] ?? 20), 100);
		$args['paged'] = max(absint($data['page'] ?? 1), 1);
		return $args;
	}

	// =========================================================================
	// VALIDATION
	// =========================================================================

	/**
	 * Check if user ID matches current logged-in user
	 */
	protected function userCheck(int $userId): bool
	{
		return $userId === get_current_user_id();
	}

	/**
	 * Check if user exists (cached)
	 */
	protected function checkUser(int $userId): bool
	{
		$cache = Cache::for('checkUser', DAY_IN_SECONDS)->connect('user');
		return $cache->remember($userId, fn() => (bool) get_userdata($userId));
	}

	/**
	 * Check if term exists (cached)
	 */
	protected function checkTerm(array $args): bool
	{
		$termId = $args['term_id'] ?? $args['to_term'] ?? false;
		$taxonomy = $args['taxonomy'] ?? false;

		if (!$termId || !$taxonomy) {
			return false;
		}

		$cache = Cache::for('checkTerm', DAY_IN_SECONDS)->connect('taxonomy');
		return $cache->remember($termId, fn() => (bool) term_exists($termId, jvbCheckBase($taxonomy)));
	}

	/**
	 * Check if user is verified
	 */
	protected function isVerifiedUser(int $userId): bool
	{
		$cache = Cache::for('verifiedUsers', DAY_IN_SECONDS)->connect('user');
		return $cache->remember($userId, fn() => user_can($userId, 'skip_moderation'));
	}

	/**
	 * Sanitize array of IDs
	 */
	protected function sanitizeIds(array $ids): array
	{
		return array_values(array_filter(array_map('absint', $ids), fn($id) => $id > 0));
	}

	/**
	 * Get and validate meta values
	 */
	protected function getMetaValues(mixed $value): mixed
	{
		$decoded = is_string($value) ? json_decode($value, true) : $value;

		if (!is_array($decoded)) {
			return $value;
		}

		return array_map(fn($item) => is_object($item) ? (array) $item : $item, $decoded);
	}

	/***************************************************************************
	 * UTILITY
	***************************************************************************/
	protected function isTimeline($args, $data):bool
	{
		if (!array_key_exists('post_type', $args)) {
			return false;
		}
		$post_types = is_array($args['post_type']) ? $args['post_type'] : [$args['post_type']];
		$hasTimeline = array_map(function($item) { return jvbCheckBase($item); },Registrar::getFeatured('is_timeline', 'post'));
		return !empty(array_intersect($post_types, $hasTimeline));
	}
	// =========================================================================
	// SECURITY
	// =========================================================================

	/**
	 * Verify Cloudflare Turnstile token
	 */
	protected function verifyTurnstile(string $token): bool
	{
		if (!Site::hasIntegration('cloudflare') || !JVB()->connect('cloudflare')->isSetUp()) {
			return true;
		}

		return !empty($token) && JVB()->connect('cloudflare')->verifyTurnstile($token);
	}

	/**
	 * Generate CSRF token for user
	 */
	protected function generateCsrfToken(int $userId): string
	{
		$token = wp_generate_password(32, false);
		set_transient(BASE . 'csrf_' . $userId, $token, HOUR_IN_SECONDS);
		return $token;
	}

	/**
	 * Validate CSRF token from request header
	 */
	protected function validateCsrfToken(WP_REST_Request $request): bool
	{
		if (!is_user_logged_in() || in_array($request->get_method(), ['GET', 'HEAD', 'OPTIONS'])) {
			return true;
		}

		$userId = get_current_user_id();
		$token = $request->get_header('X-CSRF-Token');
		$stored = get_transient(BASE . 'csrf_' . $userId);

		return !empty($stored) && !empty($token) && hash_equals($stored, $token);
	}

	// =========================================================================
	// OPERATION LOCKING
	// =========================================================================

	/**
	 * Prevent concurrent requests for the same operation
	 */
	protected function acquireOperationLock(string $key, int $duration = 5): bool
	{
		$lockKey = 'op_lock_' . md5($key);

		if (get_transient($lockKey)) {
			return false;
		}

		set_transient($lockKey, true, $duration);
		return true;
	}

	/**
	 * Release operation lock
	 */
	protected function releaseOperationLock(string $key): void
	{
		delete_transient('op_lock_' . md5($key));
	}

	// =========================================================================
	// LOGGING
	// =========================================================================

	/**
	 * Log security-relevant events
	 */
	protected function auditLog(string $event, array $data = []): void
	{
		$context = array_merge($data, [
			'timestamp' => current_time('mysql'),
			'user_id' => get_current_user_id() ?: 0,
			'ip' => $_SERVER['REMOTE_ADDR'] ?? '',
			'user_agent' => $_SERVER['HTTP_USER_AGENT'] ?? '',
		]);

		try {
			JVB()->error()->log('security_audit', $event, $context, 'info');
		} catch (Exception $e) {
			error_log("Security Audit: {$event} - " . json_encode($context));
		}
	}

	/**
	 * Log errors with proper context
	 */
	protected function logError(string $message, array $context = [], string $severity = 'error'): void
	{
		try {
			JVB()->error()->log(static::class, $message, $context, $severity);
		} catch (Exception $e) {
			error_log(static::class . " Error: {$message} - " . json_encode($context));
		}
	}

	/************************************************************
	SESSION FINGERPRINT
	 ************************************************************/
	/**
	 * Store session fingerprint for hijacking detection
	 */
	protected function storeSessionFingerprint(int $user_id, WP_REST_Request $request): void
	{
		if (!defined('JVB_SESSION_FINGERPRINT') || !JVB_SESSION_FINGERPRINT) {
			return;
		}

		$fingerprint = $this->generateSessionFingerprint($request);
		update_user_meta($user_id, BASE . 'session_fingerprint', $fingerprint);
		update_user_meta($user_id, BASE . 'session_timestamp', time());
	}
	/**
	 * Generate session fingerprint for hijacking detection
	 *
	 * @param WP_REST_Request $request The REST request
	 * @return string Hashed fingerprint
	 */
	protected function generateSessionFingerprint(WP_REST_Request $request): string
	{
		return hash('sha256', implode('|', [
			$request->get_header('User-Agent') ?? '',
			// Use IP class instead of full IP to allow for mobile network changes
			$this->getIPClass(
				$request->get_header('X-Forwarded-For')
					?: $request->get_header('X-Real-IP')
					?: $_SERVER['REMOTE_ADDR'] ?? ''
			)
		]));
	}

	/**
	 * Get IP class (first 3 octets) for session validation
	 * This allows for minor IP changes (common with mobile networks)
	 *
	 * @param string $ip IP address
	 * @return string First 3 octets
	 */
	protected function getIPClass(string $ip): string
	{
		$parts = explode('.', $ip);
		return implode('.', array_slice($parts, 0, 3));
	}

	/**
	 * Validate session fingerprint against stored value
	 *
	 * @param int $user_id User ID to validate
	 * @param WP_REST_Request $request Current request
	 * @return bool True if valid, false if potential hijacking
	 */
	protected function validateSessionFingerprint(int $user_id, WP_REST_Request $request): bool
	{
		// Only enforce if enabled in config
		if (!defined('JVB_SESSION_FINGERPRINT') || !JVB_SESSION_FINGERPRINT) {
			return true;
		}

		$stored = get_user_meta($user_id, BASE . 'session_fingerprint', true);
		$current = $this->generateSessionFingerprint($request);

		if (empty($stored)) {
			// First request - store fingerprint
			update_user_meta($user_id, BASE . 'session_fingerprint', $current);
			update_user_meta($user_id, BASE . 'session_timestamp', time());
			return true;
		}

		// Compare using timing-safe comparison
		return hash_equals($stored, $current);
	}

	/**
	 * Clear session fingerprint (call on logout)
	 *
	 * @param int $user_id User ID
	 * @return void
	 */
	protected function clearSessionFingerprint(int $user_id): void
	{
		delete_user_meta($user_id, BASE . 'session_fingerprint');
		delete_user_meta($user_id, BASE . 'session_timestamp');
	}

	/*******************************
	 * META HELPERS
	*******************************/
	public function getFieldsOfType(array $fields, string|array $type, Meta $meta, array $subType = []):array
	{
		$gotFields = [];
		if (is_string($type)) {
			$type = [$type];
		}
		foreach ($fields as $field => $value) {
			//Skip empty values
			if (empty($value)) {
				continue;
			}
			$config = $meta->config($field);
			if (in_array($config['type'], ['group', 'repeater', 'tagList'])) {
				foreach ($config['fields'] as $subfield => $subConfig) {
					if (is_numeric($subfield) && array_key_exists('name', $subConfig)) {
						$subfield = $subConfig['name'];
					}
					if (is_numeric($subfield)) continue;
					if (array_key_exists('type', $subConfig) && in_array($subConfig['type'], $type)) {
						$gotFields[] = $field.':'.$subfield;
					}
				}
			} elseif (in_array($config['type'], $type)) {
				$gotFields[] = $field;
			} else if ((!empty($subType) && in_array($config['type'], array_keys($subType)) && in_array($config['subtype'], array_values($subType)))) {
				$gotFields[] = $field;
			}
		}
		return $gotFields;
	}


	protected function extractImages(array $fields, Meta $meta):array
	{
		$images = [];
		$get = $this->getFieldsOfType($fields, ['upload', 'gallery','image'], $meta);
		if (!empty($get)) {
			$baseFields = array_map(function($fieldName) {
				return (str_contains($fieldName, ':')) ? strtok($fieldName, ':') : $fieldName;
			}, $get);

			$temp = array_map(
				function($item) {
					return explode(':', $item);
				},
				array_filter($get, function($fieldName) {
					return str_contains($fieldName, ':');
				})
			);
			$complex = [];
			foreach ($temp as $tmp) {
				$complex[$tmp[0]] = $tmp[1];
			}

			$fields = array_filter($fields, function ($field) use ($baseFields) {
				return in_array($field, $baseFields);
			}, ARRAY_FILTER_USE_KEY);

			foreach ($fields as $fieldName => $value) {
				//Check if it's a complex field
				if (array_key_exists($fieldName, $complex)) {
					$check = $complex[$fieldName];
					foreach ($value as $row) {
						foreach ($row as $fName => $fValue) {
							if ($fName === $check && !empty($fValue)) {
								$images = $this->addImages($fValue, $images);
							}
						}
					}
				} else {
					$images = $this->addImages($value, $images);
				}
			}
		}
		return $images;
	}
	public function addImages(string $imgs, array $images):array
	{
		$temp = explode(',', $imgs);
		foreach ($temp as $img) {
			if (is_numeric($img) && !array_key_exists($img, $images) && $img > 0) {
				$images[$img] = jvbImageData((int)$img);
			}
		}
		return $images;
	}

	protected function extractTerms(array $fields, Meta $meta):array
	{
		$terms = [];
		$get = $this->getFieldsOfType($fields, ['taxonomy'], $meta, ['selector' => 'taxonomy']);
		if (!empty($get)) {
			$baseFields = array_map(function($fieldName) {
				return (str_contains($fieldName, ':')) ? strtok($fieldName, ':') : $fieldName;
			}, $get);

			$complex = array_map(
				function($item) {
					return explode(':', $item);
				},
				array_filter($get, function($fieldName) {
					return str_contains($fieldName, ':');
				})
			);

			$fields = array_filter($fields, function ($field) use ($baseFields) {
				return in_array($field, $baseFields);
			}, ARRAY_FILTER_USE_KEY);

			foreach ($fields as $fieldName => $value) {
				$config = $meta->config($fieldName);
				//Check if it's a complex field
				if (array_key_exists($fieldName, $complex)) {
					foreach ($value as $row) {
						foreach ($row as $fName => $fValue) {
							if (in_array($fName, $complex[$fieldName])) {
								$terms = $this->addTerms($fValue, $terms, $config);
							}
						}
					}
				} else {

					$terms = $this->addTerms($value, $terms, $config);
				}
			}
		}
		return $terms;

	}

	protected function addTerms(string $value, array $terms, array $config):array
	{
		$taxonomy = jvbNoBase($config['taxonomy']);
		if (empty($value)) {
			return $terms;
		}
		$ids = array_map('absint', explode(',',$value));
		$cache = Cache::for('term_data')->connect('taxonomy');
		$cache->flush();
		if (!array_key_exists($taxonomy, $terms)) {
			$terms[$taxonomy] = [];
			$registrar = Registrar::getInstance($taxonomy);
			$terms[$taxonomy]['icon'] = $registrar ? $registrar->getIcon() : jvbDefaultIcon();;
		}
		foreach ($ids as $id) {
			$data = $cache->remember(
				$id,
				function () use ($id, $taxonomy) {
					$term = get_term($id, $taxonomy);
					if ($term && !is_wp_error($term)) {
						return [
							'id'	=> $term->term_id,
							'name'	=> $term->name,
							'slug'	=> $term->slug,
							'parent'	=> $term->parent,
							'path'	=> JVB()->routes('term')->getTermPath($term->term_id, $term->name, $taxonomy),
							'taxonomy'	=> jvbNoBase($term->taxonomy),
							'count'	=> $term->count,
						];
					}
					return [];
				}
			);
			if (!empty($data)) {
				$terms[$taxonomy][$id] = $data;
			}
		}
		return $terms;
	}
}