<?php
namespace JVBase\rest\routes;

use JVBase\managers\Cache;
use JVBase\managers\CustomTable;
use JVBase\rest\PermissionHandler;
use JVBase\rest\Response;
use JVBase\rest\Rest;
use JVBase\rest\Route;
use WP_REST_Request;
use WP_REST_Response;
use Exception;

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

/**
 * TODO: Extract business logic into a Favourites.php manager class
 */
class FavouritesRoutes extends Rest
{
	protected array $valid_types;
	protected Cache $listsCache;
	protected Cache $sharedListsCache;
	protected Cache $favouritesCache;
	protected CustomTable $favourites;
	protected CustomTable $lists;
	protected CustomTable $listItems;
	protected CustomTable $listShares;

	public function __construct()
	{
		$this->cacheName = 'favourites';
		$this->cacheTtl = HOUR_IN_SECONDS;
		parent::__construct();

		// Set up cache connections
		$this->cache->connect('post')->connect('user')->connect('taxonomy');
		$this->listsCache = Cache::for('lists')->connect('favourites', true);
		$this->sharedListsCache = Cache::for('sharedLists')->connect('favourites', true);
		$this->favouritesCache = Cache::for('allFavourites')->connect('favourites', true);

		$this->valid_types = array_keys(array_merge(JVB_CONTENT, JVB_TAXONOMY));

		// Initialize CustomTable instances
		$this->favourites = CustomTable::for('favourites');
		$this->lists = CustomTable::for('favourites_lists');
		$this->listItems = CustomTable::for('favourites_list_items');
		$this->listShares = CustomTable::for('favourites_list_shares');

		// Register hooks
		add_filter(BASE.'handle_bulk_operation', [$this, 'processOperation'], 10, 3);
		add_action('before_delete_post', [$this, 'cleanupPostFavourites']);
		add_action('delete_term', [$this, 'cleanupTermFavourites'], 10, 3);
		add_action('jvbUserRegistered', [$this, 'maybeAcceptListInvite'], 10, 3);
		add_action('jvb_cleanupOrphanedFavourites', [$this, 'cleanupOrphanedFavourites']);
	}

	public function registerRoutes(): void
	{
		// Favourites endpoints
		Route::for('favourites')
			->get([$this, 'getFavourites'])
			->args([
				'user' => 'integer|required',
				'type' => 'string',
				'include_all' => 'boolean',
			])
			->auth(PermissionHandler::combine(['user', ['actionNonce' => 'favourites-']]))
			->rateLimit(30)
			->post([$this, 'handleFavourite'])
			->args([
				'user' => 'integer|required',
				'id' => 'string|required',
				'action' => 'string|required|enum:add,remove,toggle,batch,note',
				'type' => 'string',
				'target_id' => 'integer',
				'items' => 'array',
				'notes' => 'string',
			])
			->auth(PermissionHandler::combine(['user', ['actionNonce' => 'favourites-']]))
			->rateLimit(30)
			->register();

		// Lists endpoints
		Route::for('favourites/lists')
			->get([$this, 'getLists'])
			->args(['user' => 'integer|required'])
			->auth(PermissionHandler::combine(['user', ['actionNonce' => 'favourites-']]))
			->rateLimit(30)
			->post([$this, 'handleList'])
			->args([
				'user' => 'integer|required',
				'id' => 'string|required',
				'action' => 'string|required|enum:create,update,delete,share,unshare,add_items,remove_items',
				'list_id' => 'integer',
				'name' => 'string',
				'items' => 'array',
			])
			->auth(PermissionHandler::combine(['user', ['actionNonce' => 'favourites-']]))
			->rateLimit(20)
			->register();

		// Favourite counts
		Route::for('favourites/counts')
			->get([$this, 'getFavouriteCounts'])
			->args(['user' => 'integer|required'])
			->auth(PermissionHandler::combine(['user', ['actionNonce' => 'favourites-']]))
			->register();
	}

	/**
	 * Get user's favourites with optional filtering
	 */
	public function getFavourites(WP_REST_Request $request): WP_REST_Response
	{
		$user_id = absint($request->get_param('user'));

		if (!$this->userCheck($user_id)) {
			return $this->unauthorized();
		}

		$args = $this->buildParams($request);
		$key = $this->cache->generateKey($args);

		// Check cache headers
		$cache_check = $this->checkHeaders($request, $key);
		if ($cache_check) {
			return $cache_check;
		}

		if (count($args) === 1 || ($request->get_param('include_all') === true)) {
			$result = $this->getAllFavourites($user_id);
		} else {
			$result = $this->cache->remember($key, function() use ($args) {
				return $this->getFilteredFavourites($args);
			});
		}

		return $this->addCacheHeaders(Response::success($result));
	}

	/**
	 * Get filtered favourites using CustomTable fluent interface
	 */
	protected function getFilteredFavourites(array $args): array
	{
		try {
			// Build base query
			$query = $this->favourites->where(['user_id' => $args['user']]);

			// Add type filter if specified
			if (!empty($args['content']) && $args['content'] !== 'all') {
				$query = $this->favourites->where([
					'user_id' => $args['user'],
					'type' => BASE . $args['content']
				]);
			}

			// Apply ordering and pagination
			$orderby = in_array($args['orderby'] ?? 'date_added', ['date_added', 'type'])
				? $args['orderby']
				: 'date_added';
			$order = in_array(strtoupper($args['order'] ?? 'DESC'), ['ASC', 'DESC'])
				? strtoupper($args['order'])
				: 'DESC';

			$favourites = $query
				->orderBy($orderby, $order)
				->limit(100, ($args['page'] - 1) * 100)
				->getResults();

			// Get total count
			$count_query = $this->favourites->where(['user_id' => $args['user']]);
			if (!empty($args['content']) && $args['content'] !== 'all') {
				$count_query->where(['type' => BASE . $args['content']]);
			}
			$total_items = $count_query->countResults();

			return [
				'items' => $this->formatItems($favourites),
				'has_more' => ($args['page'] * 100) < $total_items,
				'total' => $total_items,
				'success' => true,
			];

		} catch (Exception $e) {
			$this->logError('getFilteredFavourites', [
				'error' => $e->getMessage(),
				'args' => $args
			]);

			return [
				'success' => false,
				'items' => [],
				'total' => 0,
				'has_more' => false
			];
		}
	}

	/**
	 * Get all user's favourites organized by content type
	 */
	protected function getAllFavourites(int $user_id): array
	{
		return $this->cache->remember($user_id, function() use ($user_id) {
			try {
				$favourites = $this->favourites
					->where(['user_id' => $user_id])
					->getResults();

				$by_type = [];
				foreach ($favourites as $fav) {
					$type = str_replace(BASE, '', $fav->type);
					if (!isset($by_type[$type])) {
						$by_type[$type] = [];
					}
					$by_type[$type][] = (int)$fav->target_id;
				}

				return [
					'success' => true,
					'items' => $by_type,
					'has_more' => false,
				];

			} catch (Exception $e) {
				$this->logError('getAllFavourites', [
					'error' => $e->getMessage(),
					'user_id' => $user_id
				]);

				return [
					'success' => false,
					'items' => [],
				];
			}
		});
	}

	/**
	 * Handle favourite operations
	 */
	public function handleFavourite(WP_REST_Request $request): WP_REST_Response
	{
		$user_id = absint($request->get_param('user'));
		$operation_id = sanitize_text_field($request->get_param('id'));
		$action = sanitize_text_field($request->get_param('action'));

		if (!$this->userCheck($user_id)) {
			return $this->unauthorized();
		}

		$data = [
			'action' => $action,
			'type' => sanitize_text_field($request->get_param('type') ?? ''),
			'target_id' => absint($request->get_param('target_id') ?? 0),
			'items' => $request->get_param('items') ?? [],
			'notes' => sanitize_textarea_field($request->get_param('notes') ?? ''),
		];

		JVB()->queue()->queueOperation(
			'favourite_' . $action,
			$user_id,
			$data,
			[
				'operation_id' => $operation_id,
				'priority' => 'high',
			]
		);

		return $this->queued($operation_id);
	}

	/**
	 * Get user's favourite lists
	 */
	public function getLists(WP_REST_Request $request): WP_REST_Response
	{
		$user_id = absint($request->get_param('user'));

		if (!$this->userCheck($user_id)) {
			return $this->unauthorized();
		}

		$params = ['user' => $user_id];
		if ($request->get_param('id')) {
			$params['list'] = sanitize_text_field($request->get_param('id'));
		}

		$key = $this->listsCache->generateKey($params);

		// Check cache headers
		$cache_check = $this->checkHeaders($request, $key);
		if ($cache_check) {
			return $cache_check;
		}

		$list_id = $request->get_param('id');
		$response = $list_id
			? $this->getListDetails($list_id, $user_id)
			: $this->getAvailableLists($user_id);

		return $this->addCacheHeaders(Response::success($response));
	}

	/**
	 * Get lists available to a user using CustomTable
	 */
	protected function getAvailableLists(int $user_id, bool $include_shared = true): array
	{
		if (!$this->checkUser($user_id)) {
			return [];
		}

		$cache = $include_shared ? $this->sharedListsCache : $this->listsCache;

		return $cache->remember($user_id, function() use ($user_id, $include_shared) {
			try {
				// Get owned lists
				$owned = $this->lists
					->where(['user_id' => $user_id])
					->orderBy('created_at', 'DESC')
					->getResults(ARRAY_A);

				// Add item counts
				foreach ($owned as &$list) {
					$list['item_count'] = $this->listItems
						->where(['list_id' => $list['id']])
						->countResults();
					$list['is_owner'] = true;
					$list['is_shared'] = false;
				}

				if (!$include_shared) {
					return [
						'success' => true,
						'lists' => $owned
					];
				}

				// Get shared lists
				$shares = $this->listShares
					->where(['user_id' => $user_id, 'status' => 'accepted'])
					->getResults();

				$shared_lists = [];
				foreach ($shares as $share) {
					$list = $this->lists
						->where(['id' => $share->list_id])
						->first(ARRAY_A);

					if ($list) {
						$owner = get_userdata($list['user_id']);
						$list['owner_name'] = $owner ? $owner->display_name : 'Unknown';
						$list['item_count'] = $this->listItems
							->where(['list_id' => $list['id']])
							->countResults();
						$list['permission_type'] = $share->permission_type;
						$list['is_owner'] = false;
						$list['is_shared'] = true;

						$shared_lists[] = $list;
					}
				}

				return [
					'success' => true,
					'lists' => [
						'owned' => $owned,
						'shared' => $shared_lists
					]
				];

			} catch (Exception $e) {
				$this->logError('getAvailableLists', [
					'error' => $e->getMessage(),
					'user_id' => $user_id
				]);

				return [];
			}
		});
	}

	/**
	 * Get favourite counts by type
	 */
	public function getFavouriteCounts(WP_REST_Request $request): WP_REST_Response
	{
		$user_id = absint($request->get_param('user'));

		if (!$this->userCheck($user_id)) {
			return $this->unauthorized();
		}

		$key = "counts_{$user_id}";

		$counts = $this->cache->remember($key, function() use ($user_id) {
			try {
				// Get counts grouped by type using raw query
				$results = $this->favourites->queryResults(
					"SELECT type, COUNT(*) as count FROM {table} WHERE user_id = %d GROUP BY type",
					[$user_id],
					OBJECT_K
				);

				$all_counts = array_fill_keys(
					array_map(fn($type) => str_replace(BASE, '', $type), array_keys($this->valid_types)),
					0
				);

				foreach ($results as $type => $data) {
					$type_key = str_replace(BASE, '', $type);
					$all_counts[$type_key] = (int)$data->count;
				}

				return $all_counts;

			} catch (Exception $e) {
				$this->logError('getFavouriteCounts', [
					'error' => $e->getMessage(),
					'user_id' => $user_id
				]);

				return array_fill_keys(array_keys($this->valid_types), 0);
			}
		});

		return Response::success(['counts' => $counts]);
	}

	/**
	 * Process favourite operations using transactions
	 */
	public function processOperation($result, object $operation, array $data)
	{
		$action_map = [
			'favourite_add' => 'addFavourite',
			'favourite_remove' => 'removeFavourite',
			'favourite_batch' => 'batchFavourites',
			'favourite_note' => 'processNote',
			'favourite_list_create' => 'createList',
			'favourite_list_update' => 'updateList',
			'favourite_list_delete' => 'deleteList',
			'favourite_list_add_items' => 'addToList',
			'favourite_list_remove_items' => 'removeFromList',
			'favourite_list_share' => 'shareList',
			'favourite_list_unshare' => 'unshareList',
		];

		if (!isset($action_map[$operation->type])) {
			return $result;
		}

		try {
			$method = $action_map[$operation->type];
			$response = $this->$method($operation->user_id, $data);

			// Clear cache on success
			if ($response['success'] ?? false) {
				Cache::invalidateItem('favourites', $operation->user_id);
				$this->listsCache->flush();
				$this->sharedListsCache->flush();
			}

			return $response;
		} catch (Exception $e) {
			$this->logError('processOperation', [
				'error' => $e->getMessage(),
				'operation_id' => $operation->id,
				'type' => $operation->type
			]);

			return [
				'success' => false,
				'result' => $e->getMessage()
			];
		}
	}

	/**
	 * Add a favourite using findOrCreate pattern
	 */
	protected function addFavourite(int $user_id, array $data): array
	{
		$type = $data['type'];
		$target_id = $data['target_id'];

		if (!str_starts_with($type, BASE)) {
			$type = BASE . $type;
		}

		if (!isset($this->valid_types[$type])) {
			return ['success' => false, 'result' => 'Invalid type'];
		}

		// Use findOrCreate pattern
		$result = $this->favourites->findOrCreate([
			'user_id' => $user_id,
			'type' => $type,
			'target_id' => $target_id
		]);

		if ($result['created']) {
			$this->updateFavouriteCount($type, $target_id);
			$this->maybeNotifyOwner($type, $target_id, $user_id);
		}

		return [
			'success' => true,
			'result' => [
				'action' => $result['created'] ? 'added' : 'already_exists',
				'favourite_id' => $result['id'],
				'count' => $this->getFavouriteCount($type, $target_id)
			]
		];
	}

	/**
	 * Remove a favourite
	 */
	protected function removeFavourite(int $user_id, array $data): array
	{
		$type = $data['type'];
		$target_id = $data['target_id'];

		if (!str_starts_with($type, BASE)) {
			$type = BASE . $type;
		}

		$deleted = $this->favourites->where([
			'user_id' => $user_id,
			'type' => $type,
			'target_id' => $target_id
		])->deleteResults();

		if ($deleted) {
			$this->updateFavouriteCount($type, $target_id);
			$this->removeRelatedNotifications($type, $target_id, $user_id);
		}

		return [
			'success' => true,
			'result' => [
				'action' => $deleted ? 'removed' : 'not_found',
				'count' => $this->getFavouriteCount($type, $target_id)
			]
		];
	}

	/**
	 * Batch favourites using transaction
	 */
	protected function batchFavourites(int $user_id, array $data): array
	{
		$items = $data['items'] ?? [];

		if (empty($items)) {
			return ['success' => false, 'result' => 'No items provided'];
		}

		return $this->favourites->transaction(function($table) use ($user_id, $items) {
			$results = [
				'added' => 0,
				'removed' => 0,
				'errors' => []
			];

			foreach ($items as $item) {
				try {
					$type = BASE . ($item['type'] ?? '');
					$target_id = absint($item['target_id'] ?? 0);
					$action = $item['action'] ?? 'add';

					if ($action === 'add') {
						$result = $table->findOrCreate([
							'user_id' => $user_id,
							'type' => $type,
							'target_id' => $target_id
						]);
						if ($result['created']) $results['added']++;
					} else {
						$deleted = $table->where([
							'user_id' => $user_id,
							'type' => $type,
							'target_id' => $target_id
						])->deleteResults();
						if ($deleted) $results['removed']++;
					}

					$this->updateFavouriteCount($type, $target_id);
				} catch (Exception $e) {
					$results['errors'][] = $item['target_id'] ?? 'unknown';
				}
			}

			return [
				'success' => true,
				'result' => $results
			];
		});
	}

	/**
	 * Create a list using transaction
	 */
	protected function createList(int $user_id, array $data): array
	{
		$name = sanitize_text_field($data['name'] ?? 'Untitled List');
		$description = sanitize_textarea_field($data['description'] ?? '');
		$items = $data['items'] ?? [];

		return $this->lists->transaction(function($table) use ($user_id, $name, $description, $items) {
			$list_id = $table->create([
				'user_id' => $user_id,
				'name' => $name,
				'description' => $description,
			]);

			if (!$list_id) {
				throw new Exception('Failed to create list');
			}

			$added_count = 0;
			if (!empty($items)) {
				$result = $this->addItemsToList($list_id, $items, $user_id);
				$added_count = $result['added'];
			}

			return [
				'success' => true,
				'result' => [
					'list_id' => $list_id,
					'name' => $name,
					'added_items' => $added_count,
				]
			];
		});
	}

	/**
	 * Add items to list with bulk insert
	 */
	protected function addItemsToList(int $list_id, array $items, int $user_id): array
	{
		if (empty($items)) {
			return ['added' => 0, 'errors' => []];
		}

		$added = 0;
		$errors = [];

		try {
			// Group items by type
			$items_by_type = [];
			foreach ($items as $item) {
				if (empty($item['type']) || !isset($item['target_id'])) {
					$errors[] = ['message' => 'Item missing type or target_id', 'item' => $item];
					continue;
				}

				$type = str_starts_with($item['type'], BASE)
					? $item['type']
					: BASE . $item['type'];

				if (!isset($items_by_type[$type])) {
					$items_by_type[$type] = [];
				}

				$items_by_type[$type][] = absint($item['target_id']);
			}

			foreach ($items_by_type as $type => $target_ids) {
				// Get existing items to avoid duplicates
				$existing = $this->listItems
					->where(['list_id' => $list_id, 'item_type' => $type])
					->getResults();

				$existing_map = [];
				foreach ($existing as $item) {
					$existing_map[$item->item_id] = true;
				}

				// Get favourite IDs in bulk
				$favs = $this->favourites
					->where(['user_id' => $user_id, 'type' => $type])
					->getResults();

				$fav_map = [];
				foreach ($favs as $fav) {
					$fav_map[$fav->target_id] = $fav->id;
				}

				// Prepare items for bulk insert
				$to_insert = [];
				foreach ($target_ids as $target_id) {
					if (isset($existing_map[$target_id])) {
						continue;
					}

					$to_insert[] = [
						'list_id' => $list_id,
						'item_type' => $type,
						'item_id' => $target_id,
						'favourite_id' => $fav_map[$target_id] ?? null
					];
				}

				// Bulk insert
				if (!empty($to_insert)) {
					$columns = ['list_id', 'item_type', 'item_id', 'favourite_id'];
					$result = $this->listItems->bulkInsert($to_insert, $columns);
					$added += $result;
				}
			}

			// Update list timestamp
			$this->lists->where(['id' => $list_id])->updateResults([]);

			return ['added' => $added, 'errors' => $errors];

		} catch (Exception $e) {
			$this->logError('addItemsToList', [
				'error' => $e->getMessage(),
				'user_id' => $user_id,
				'list_id' => $list_id,
			]);

			$errors[] = ['message' => $e->getMessage()];
			return ['added' => 0, 'errors' => $errors];
		}
	}

	/**
	 * Clean up favourites when a post is deleted
	 */
	public function cleanupPostFavourites(int $post_id): void
	{
		try {
			$type = get_post_type($post_id);
			if (!$type) return;

			$type = BASE . $type;

			// Delete using fluent interface
			$this->favourites->where([
				'type' => $type,
				'target_id' => $post_id
			])->deleteResults();

			$this->listItems->where([
				'item_type' => $type,
				'item_id' => $post_id
			])->deleteResults();

		} catch (Exception $e) {
			$this->logError('cleanupPostFavourites', [
				'error' => $e->getMessage(),
				'post_id' => $post_id
			]);
		}
	}

	/**
	 * Clean up favourites when a term is deleted
	 */
	public function cleanupTermFavourites(int $term_id, int $tt_id, string $taxonomy): void
	{
		try {
			if (!isset($this->valid_types[$taxonomy])) {
				return;
			}

			// Delete using fluent interface
			$this->favourites->where([
				'type' => $taxonomy,
				'target_id' => $term_id
			])->deleteResults();

			$this->listItems->where([
				'item_type' => $taxonomy,
				'item_id' => $term_id
			])->deleteResults();

		} catch (Exception $e) {
			$this->logError('cleanupTermFavourites', [
				'error' => $e->getMessage(),
				'term_id' => $term_id,
				'taxonomy' => $taxonomy
			]);
		}
	}

	/**
	 * Cleanup orphaned favourites using CustomTable query method
	 */
	public function cleanupOrphanedFavourites(): bool
	{
		try {
			// Delete favourites for non-existent users
			$this->favourites->query(
				"DELETE f FROM {table} f
                 LEFT JOIN {$GLOBALS['wpdb']->users} u ON f.user_id = u.ID
                 WHERE u.ID IS NULL"
			);

			// Delete favourites for non-existent posts
			$post_types = array_filter(
				array_keys($this->valid_types),
				fn($type) => $this->valid_types[$type]['table'] === 'post'
			);

			foreach ($post_types as $type) {
				$this->favourites->query(
					"DELETE f FROM {table} f
                     LEFT JOIN {$GLOBALS['wpdb']->posts} p ON f.target_id = p.ID
                     WHERE f.type = %s AND p.ID IS NULL",
					[$type]
				);
			}

			return true;

		} catch (Exception $e) {
			$this->logError('cleanupOrphanedFavourites', [
				'error' => $e->getMessage()
			]);

			return false;
		}
	}

	/**
	 * Helper methods
	 */
	protected function buildParams(WP_REST_Request $request): array
	{
		$data = $request->get_params();
		$args = ['user' => absint($data['user'])];

		if (!array_key_exists('page', $data)) {
			return $args;
		}

		$args = array_merge($args, [
			'page' => max(1, absint($data['page'] ?? 1)),
			'content' => $this->checkContent($data['content'] ?? 'all')
		]);

		return $this->applyOrderFilters($args, $data);
	}


	/**
	 * Batch format a collection of favourite items
	 *
	 * @param array $items Collection of favourite items
	 * @return array Formatted items
	 */
	protected function formatItems(array $items):array
	{
		if (empty($items)) {
			return [];
		}

		// Group items by type to reduce queries
		$items_by_type = [];
		foreach ($items as $item) {
			if (!isset($item->type) || !isset($item->target_id)) {
				continue;
			}

			// Verify item type is valid
			if (!isset($this->valid_types[$item->type])) {
				continue;
			}

			$type = $item->type;
			if (!isset($items_by_type[$type])) {
				$items_by_type[$type] = [];
			}
			$items_by_type[$type][] = $item;
		}

		$formatted = [];

		// Process post-type items in batches
		foreach ($items_by_type as $type => $type_items) {
			$config = $this->valid_types[$type];

			if ($config['table'] === 'post') {
				$formatted = array_merge($formatted, $this->formatPostFavourites($type_items));
			} else {
				$formatted = array_merge($formatted, $this->formatTermFavourites($type_items));
			}
		}

		return $formatted;
	}
	protected function getFavouriteCount(string $type, int $target_id): int
	{
		return $this->favourites->where([
			'type' => $type,
			'target_id' => $target_id
		])->countResults();
	}

	protected function updateFavouriteCount(string $type, int $target_id): void
	{
		$count = $this->getFavouriteCount($type, $target_id);

		if (str_contains($type, 'post') || in_array($type, array_keys($this->valid_types))) {
			update_post_meta($target_id, BASE.'favourite_count', $count);
		} else {
			update_term_meta($target_id, BASE.'favourite_count', $count);
		}
	}

	/**
	 * Notify content owner of new favourite if configured
	 *
	 * @param string $type Content type
	 * @param int $target_id Content ID
	 * @param int $user_id User who favourited
	 * @return void
	 */
	protected function maybeNotifyOwner(string $type, int $target_id, int $user_id): void
	{
		try {
			$owner_id = $this->getContentOwner($type, $target_id);

			if ($owner_id && $owner_id !== $user_id) {
				JVB()->notification()->addNotification(
					$owner_id,
					'new_favourite',
					[
						'user_id' => $user_id,
						'type' => $type,
						'target_id' => $target_id
					]
				);
			}
		} catch (Exception $e) {
			// Silent fail - notifications are non-critical
		}
	}

	/**
	 * Remove any existing notifications about a favorite action
	 *
	 * @param int $user_id User who removed the favorite
	 * @param string $type Content type
	 * @param int $target_id Content ID
	 * @return void
	 */
	protected function removeRelatedNotifications(int $user_id, string $type, int $target_id):void
	{
		try {
			// Get the content owner(s)
			$owner_ids = $this->getContentOwner($type, $target_id);
			if (!$owner_ids) {
				return;
			}

			$owner_ids = (is_array($owner_ids)) ? $owner_ids : [$owner_ids];

			foreach ($owner_ids as $owner_id) {
				// Skip if owner is the same as the user who unfavorited
				if ($owner_id === $user_id) {
					continue;
				}

				global $wpdb;
				$notifications_table = $wpdb->prefix . BASE . 'notifications';

				// Find recent (within last 30 days) new_favourite notifications from this user for this content
				$notifications = $wpdb->get_results($wpdb->prepare(
					"SELECT id FROM {$notifications_table}
                WHERE owner_id = %d
                AND action_user_id = %d
                AND type = 'new_favourite'
                AND target_id = %d
                AND target_type = %s
                AND created_at > DATE_SUB(%s, INTERVAL 30 DAY)",
					$owner_id,
					$user_id,
					$target_id,
					$type,
					current_time('mysql')
				));

				if (empty($notifications)) {
					continue;
				}

				// Delete the notifications
				foreach ($notifications as $notification) {
					$wpdb->delete(
						$notifications_table,
						['id' => $notification->id],
						['%d']
					);
				}

				// Invalidate notification cache for this user
//                if (method_exists(JVB()->notification(), 'clearNotificationCache')) {
//                    JVB()->notification()->clearNotificationCache($owner_id);
//                }
			}
		} catch (Exception $e) {
			// Log but continue
			JVB()->error()->log(
				'favourites',
				'Error removing related notifications: ' . $e->getMessage(),
				['type' => $type, 'target_id' => $target_id, 'user_id' => $user_id],
				'warning'
			);
		}
	}

	public function maybeAcceptListInvite(int $user_id, string $email, array $data):void
	{
		if (array_key_exists('list_token', $data) && !empty($data['list_token'])) {
			$this->acceptListInvitation($data['list_token'], $email);
		}
	}

	/**
	 * Get detailed information for a single list
	 */
	protected function getListDetails(int $list_id, int $user_id): array
	{
		$key = "list_{$list_id}_user_{$user_id}";

		return $this->listsCache->remember($key, function () use ($list_id, $user_id) {
			try {
				// Check access - either owner or has share
				$is_owner = $this->lists->where([
					'id' => $list_id,
					'user_id' => $user_id
				])->existsInQuery();

				$share = null;
				if (!$is_owner) {
					$share = $this->listShares->where([
						'list_id' => $list_id,
						'user_id' => $user_id,
						'status' => 'accepted'
					])->first();
				}

				if (!$is_owner && !$share) {
					return [
						'success' => false,
						'message' => 'You do not have access to this list'
					];
				}

				// Get list details
				$list = $this->lists->where(['id' => $list_id])->first(ARRAY_A);
				if (!$list) {
					return [
						'success' => false,
						'message' => 'List not found'
					];
				}

				// Get list items
				$items = $this->listItems
					->where(['list_id' => $list_id])
					->orderBy('added_at', 'DESC')
					->getResults();

				// Format items - convert to favourite-like objects
				$formatted_items = [];
				foreach ($items as $item) {
					// Try to get the actual favourite record if it exists
					if ($item->favourite_id) {
						$fav = $this->favourites->where(['id' => $item->favourite_id])->first();
						if ($fav) {
							$formatted_items[] = $fav;
							continue;
						}
					}

					// Create dummy favourite object for formatting
					$formatted_items[] = (object)[
						'type' => $item->item_type,
						'target_id' => $item->item_id,
						'date_added' => $item->added_at
					];
				}

				// Get shared users if owner
				$shared_users = [];
				if ($is_owner) {
					$shares = $this->listShares
						->where(['list_id' => $list_id])
						->orderBy('created_at', 'DESC')
						->getResults();

					foreach ($shares as $share_item) {
						$shared_user = [
							'email' => $share_item->email,
							'status' => $share_item->status,
							'date_added' => $share_item->created_at,
						];

						if ($share_item->status === 'accepted' && $share_item->user_id) {
							$user = get_userdata($share_item->user_id);
							$shared_user['name'] = $user ? $user->display_name : 'Unknown';
							$shared_user['permission_type'] = $share_item->permission_type;
						}

						$shared_users[] = $shared_user;
					}
				}

				return [
					'success' => true,
					'list' => [
						'id' => (int)$list['id'],
						'name' => $list['name'],
						'description' => $list['description'] ?? '',
						'created_at' => $list['created_at'],
						'is_owner' => $is_owner,
						'is_shared' => !$is_owner,
						'items' => $this->formatItems($formatted_items),
						'shared_users' => $shared_users
					]
				];

			} catch (Exception $e) {
				$this->logError('getListDetails', [
					'error' => $e->getMessage(),
					'user_id' => $user_id,
					'list_id' => $list_id
				]);

				return [
					'success' => false,
					'message' => 'Error retrieving list details'
				];
			}
		});
	}

	/**
	 * Process favourite notes update
	 */
	protected function processNote(int $user_id, array $data): array
	{
		$target_ids = isset($data['target_id'])
			? array_map('absint', explode(',', $data['target_id']))
			: [];
		$notes = sanitize_textarea_field($data['notes'] ?? '');

		if (empty($target_ids)) {
			return ['success' => false, 'result' => 'No target IDs provided'];
		}

		return $this->favourites->transaction(function ($table) use ($user_id, $target_ids, $notes) {
			$results = [];

			foreach ($target_ids as $target_id) {
				if ($target_id <= 0) {
					$results[] = [
						'success' => false,
						'target_id' => $target_id,
						'message' => 'Invalid target ID'
					];
					continue;
				}

				$favourite = $table->where([
					'user_id' => $user_id,
					'target_id' => $target_id
				])->first();

				if (!$favourite) {
					$results[] = [
						'success' => false,
						'target_id' => $target_id,
						'message' => 'Favourite not found'
					];
					continue;
				}

				$table->where(['id' => $favourite->id])->updateResults([
					'notes' => $notes
				]);

				$results[] = [
					'success' => true,
					'action' => 'updated_notes',
					'favourite_id' => $favourite->id,
					'target_id' => $target_id
				];
			}

			return [
				'success' => true,
				'result' => $results
			];
		});
	}

	/**
	 * Update list
	 */
	protected function updateList(int $user_id, array $data): array
	{
		$list_id = absint($data['list_id'] ?? 0);

		if (!$list_id) {
			return ['success' => false, 'result' => 'List ID is required'];
		}

		try {
			// Verify ownership
			$is_owner = $this->lists->where([
				'id' => $list_id,
				'user_id' => $user_id
			])->existsInQuery();

			if (!$is_owner) {
				return [
					'success' => false,
					'result' => 'You do not have permission to update this list'
				];
			}

			// Build update data
			$update_data = [];

			if (isset($data['name'])) {
				$update_data['name'] = sanitize_text_field($data['name']);
			}

			if (isset($data['description'])) {
				$update_data['description'] = sanitize_textarea_field($data['description']);
			}

			if (empty($update_data)) {
				return [
					'success' => true,
					'result' => 'No changes to update'
				];
			}

			// Update the list
			$this->lists->where(['id' => $list_id])->updateResults($update_data);

			return [
				'success' => true,
				'result' => [
					'message' => 'List updated successfully',
					'list_id' => $list_id,
					'updates' => array_keys($update_data)
				]
			];

		} catch (Exception $e) {
			$this->logError('updateList', [
				'error' => $e->getMessage(),
				'user_id' => $user_id,
				'list_id' => $list_id
			]);

			return [
				'success' => false,
				'result' => $e->getMessage()
			];
		}
	}

	/**
	 * Delete list
	 */
	protected function deleteList(int $user_id, array $data): array
	{
		$list_id = absint($data['list_id'] ?? 0);

		if (!$list_id) {
			return ['success' => false, 'result' => 'List ID is required'];
		}

		return $this->lists->transaction(function ($table) use ($user_id, $list_id) {
			// Verify ownership
			$is_owner = $table->where([
				'id' => $list_id,
				'user_id' => $user_id
			])->existsInQuery();

			if (!$is_owner) {
				throw new Exception('You do not have permission to delete this list');
			}

			// Delete related data (foreign keys should handle this, but being explicit)
			$this->listItems->where(['list_id' => $list_id])->deleteResults();
			$this->listShares->where(['list_id' => $list_id])->deleteResults();

			// Delete the list
			$table->where(['id' => $list_id])->deleteResults();

			return [
				'success' => true,
				'result' => [
					'message' => 'List deleted successfully',
					'list_id' => $list_id
				]
			];
		});
	}

	/**
	 * Add items to list
	 */
	protected function addToList(int $user_id, array $data): array
	{
		$list_ids = isset($data['list_id'])
			? array_map('absint', explode(',', $data['list_id']))
			: [];
		$items = $data['items'] ?? [];

		if (empty($list_ids) || empty($items)) {
			return ['success' => false, 'result' => 'List ID and items are required'];
		}

		return $this->listItems->transaction(function ($table) use ($user_id, $list_ids, $items) {
			$results = [];
			$total_added = 0;
			$all_errors = [];

			foreach ($list_ids as $list_id) {
				if (!$list_id) {
					$all_errors[] = ['message' => 'Invalid list ID', 'list_id' => $list_id];
					continue;
				}

				// Check permission - either owner or has edit permission
				$is_owner = $this->lists->where([
					'id' => $list_id,
					'user_id' => $user_id
				])->existsInQuery();

				$has_edit = $this->listShares->where([
					'list_id' => $list_id,
					'user_id' => $user_id,
					'permission_type' => 'edit',
					'status' => 'accepted'
				])->existsInQuery();

				if (!$is_owner && !$has_edit) {
					$all_errors[] = [
						'message' => 'You do not have permission to add items to this list',
						'list_id' => $list_id
					];
					continue;
				}

				// Add items to this list
				$add_result = $this->addItemsToList($list_id, $items, $user_id);
				$total_added += $add_result['added'];

				if (!empty($add_result['errors'])) {
					$all_errors = array_merge($all_errors, $add_result['errors']);
				}

				$results[] = [
					'list_id' => $list_id,
					'added_count' => $add_result['added']
				];
			}

			if ($total_added == 0 && !empty($all_errors)) {
				throw new Exception('Failed to add any items');
			}

			return [
				'success' => true,
				'result' => [
					'lists' => $results,
					'total_added' => $total_added,
					'errors' => $all_errors
				]
			];
		});
	}

	/**
	 * Remove items from list
	 */
	protected function removeFromList(int $user_id, array $data): array
	{
		$list_id = absint($data['list_id'] ?? 0);
		$items = $data['items'] ?? [];

		if (!$list_id || empty($items)) {
			return ['success' => false, 'result' => 'List ID and items are required'];
		}

		try {
			// Check permission
			$is_owner = $this->lists->where([
				'id' => $list_id,
				'user_id' => $user_id
			])->existsInQuery();

			$has_edit = $this->listShares->where([
				'list_id' => $list_id,
				'user_id' => $user_id,
				'permission_type' => 'edit',
				'status' => 'accepted'
			])->existsInQuery();

			if (!$is_owner && !$has_edit) {
				return [
					'success' => false,
					'result' => 'You do not have permission to remove items from this list'
				];
			}

			// Remove items
			$removed = 0;
			foreach ($items as $item) {
				if (empty($item['type']) || !isset($item['target_id'])) {
					continue;
				}

				$type = str_starts_with($item['type'], BASE)
					? $item['type']
					: BASE . $item['type'];

				$deleted = $this->listItems->where([
					'list_id' => $list_id,
					'item_type' => $type,
					'item_id' => absint($item['target_id'])
				])->deleteResults();

				if ($deleted) {
					$removed += $deleted;
				}
			}

			return [
				'success' => true,
				'result' => [
					'message' => "{$removed} items removed from list",
					'list_id' => $list_id,
					'removed_count' => $removed
				]
			];

		} catch (Exception $e) {
			$this->logError('removeFromList', [
				'error' => $e->getMessage(),
				'user_id' => $user_id,
				'list_id' => $list_id
			]);

			return [
				'success' => false,
				'result' => $e->getMessage()
			];
		}
	}

	/**
	 * Share list with another user
	 */
	protected function shareList(int $user_id, array $data): array
	{
		$list_id = absint($data['list_id'] ?? 0);
		$email = sanitize_email($data['email'] ?? '');
		$permission_type = in_array($data['permission_type'] ?? '', ['view', 'edit'])
			? $data['permission_type']
			: 'view';

		if (!$list_id || !$email) {
			return ['success' => false, 'result' => 'List ID and email are required'];
		}

		return $this->listShares->transaction(function ($table) use ($user_id, $list_id, $email, $permission_type) {
			// Verify ownership
			$list = $this->lists->where([
				'id' => $list_id,
				'user_id' => $user_id
			])->first();

			if (!$list) {
				throw new Exception('You do not have permission to share this list');
			}

			// Get owner details
			$owner = get_userdata($user_id);
			$owner_name = $owner ? $owner->display_name : 'Someone';

			// Look up user by email
			$share_user = get_user_by('email', $email);

			if ($share_user) {
				// User exists - check for existing share
				$existing = $table->where([
					'list_id' => $list_id,
					'user_id' => $share_user->ID
				])->first();

				if ($existing) {
					// Update if different
					if ($existing->permission_type !== $permission_type || $existing->status !== 'accepted') {
						$table->where(['id' => $existing->id])->updateResults([
							'permission_type' => $permission_type,
							'status' => 'accepted',
						]);

						return [
							'success' => true,
							'result' => [
								'action' => 'updated',
								'message' => "Updated sharing permissions for {$email}",
							]
						];
					}

					return [
						'success' => true,
						'result' => [
							'action' => 'already_shared',
							'message' => "List is already shared with {$email}",
						]
					];
				}

				// Create new share
				$table->create([
					'list_id' => $list_id,
					'user_id' => $share_user->ID,
					'email' => $email,
					'permission_type' => $permission_type,
					'status' => 'accepted'
				]);

				// Send notification
				JVB()->notification()->addNotification(
					$share_user->ID,
					'list_shared',
					$user_id,
					sprintf('%s shared a favorites list with you: "%s"', $owner_name, $list->name),
					$list_id,
					'favourites_list',
					[
						'list_id' => $list_id,
						'list_name' => $list->name,
						'permission_type' => $permission_type
					]
				);

				return [
					'success' => true,
					'result' => [
						'action' => 'shared',
						'message' => "List shared with {$email}",
					]
				];
			}

			// User doesn't exist - create pending invitation
			$existing_pending = $table->where([
				'list_id' => $list_id,
				'email' => $email,
				'status' => 'pending'
			])->first();

			if ($existing_pending) {
				return [
					'success' => true,
					'result' => [
						'action' => 'already_pending',
						'message' => "Invitation already sent to {$email}",
					]
				];
			}

			// Create pending share with invitation token
			$token = wp_generate_password(32, false);

			$table->create([
				'list_id' => $list_id,
				'email' => $email,
				'permission_type' => $permission_type,
				'status' => 'pending',
				'invitation_token' => $token,
				'user_id' => 0 // Will be set when they accept
			]);

			// Send invitation email
			$this->sendListInviteEmail($email, [
				'list_id' => $list_id,
				'list_name' => $list->name,
				'token' => $token,
				'owner_name' => $owner_name,
				'user_id' => $user_id
			]);

			return [
				'success' => true,
				'result' => [
					'action' => 'invitation_sent',
					'message' => "Invitation sent to {$email}",
				]
			];
		});
	}

	/**
	 * Unshare list
	 */
	protected function unshareList(int $user_id, array $data): array
	{
		$list_id = absint($data['list_id'] ?? 0);
		$email = sanitize_email($data['email'] ?? '');

		if (!$list_id || !$email) {
			return ['success' => false, 'result' => 'List ID and email are required'];
		}

		try {
			// Verify ownership
			$is_owner = $this->lists->where([
				'id' => $list_id,
				'user_id' => $user_id
			])->existsInQuery();

			if (!$is_owner) {
				return [
					'success' => false,
					'result' => 'You do not have permission to manage shares for this list'
				];
			}

			// Find share by email
			$existing_share = $this->listShares->where([
				'list_id' => $list_id,
				'email' => $email
			])->first();

			if (!$existing_share) {
				return [
					'success' => false,
					'result' => "No active share or invitation found for {$email}"
				];
			}

			// Update status to revoked (or just delete)
			$this->listShares->where(['id' => $existing_share->id])->updateResults([
				'status' => 'revoked'
			]);

			// Notify user if registered and was accepted
			if ($existing_share->status === 'accepted' && $existing_share->user_id) {
				$list = $this->lists->where(['id' => $list_id])->first();

				if ($list) {
					JVB()->notification()->addNotification(
						$existing_share->user_id,
						'list_share_revoked',
						$user_id,
						sprintf('Your access to the list "%s" has been revoked', $list->name),
						$list_id,
						'favourites_list',
						[
							'list_id' => $list_id,
							'list_name' => $list->name
						]
					);
				}
			}

			$action = $existing_share->status === 'accepted' ? 'unshared' : 'invitation_cancelled';
			$message = $existing_share->status === 'accepted'
				? "Removed {$email}'s access to list"
				: "Cancelled invitation to {$email}";

			return [
				'success' => true,
				'result' => [
					'action' => $action,
					'message' => $message,
				]
			];

		} catch (Exception $e) {
			$this->logError('unshareList', [
				'error' => $e->getMessage(),
				'user_id' => $user_id,
				'list_id' => $list_id,
				'email' => $email
			]);

			return [
				'success' => false,
				'result' => $e->getMessage()
			];
		}
	}

	/**
	 * Send list invitation email
	 */
	protected function sendListInviteEmail(string $email, array $data): bool
	{
		$list_name = $data['list_name'];
		$token = $data['token'];
		$owner_name = $data['owner_name'];

		// Generate invitation URL
		$invite_url = add_query_arg([
			'action' => 'accept_list_invite',
			'token' => $token,
			'list' => $data['list_id']
		], home_url('/'));

		$subject = sprintf('%s shared a favourites list with you', $owner_name);

		$message = sprintf(
			'<p>Hi there,</p>
        <p><strong>%s</strong> has shared their list "<strong>%s</strong>" with you.</p>
        <p>To view this list, click the link below:</p>
        <p><a href="%s">Accept List Invitation</a></p>
        <p>Or copy and paste this link: %s</p>
        <p>If you don\'t have an account, you\'ll be guided through creating one.</p>',
			$owner_name,
			$list_name,
			$invite_url,
			$invite_url
		);

		return JVB()->email()->sendEmail($email, $subject, $message);
	}

	/**
	 * Accept a list share invitation
	 */
	protected function acceptListInvitation(string $token, string $email, ?int $user_id = null): array
	{
		if (!$token || !$email) {
			return [
				'success' => false,
				'message' => 'Invalid invitation parameters'
			];
		}

		try {
			// Find the pending invitation
			$invitation = $this->listShares->where([
				'invitation_token' => $token,
				'email' => $email,
				'status' => 'pending'
			])->first();

			if (!$invitation) {
				return [
					'success' => false,
					'message' => 'Invalid or expired invitation'
				];
			}

			// If no user_id provided, check if user exists
			if (!$user_id) {
				$existing_user = get_user_by('email', $email);

				if ($existing_user) {
					$user_id = $existing_user->ID;
				} else {
					// No account - need to register
					$registration_url = add_query_arg([
						'action' => 'register',
						'type' => 'favourites',
						'list_token' => $token,
						'email' => urlencode($email)
					], wp_login_url());

					return [
						'success' => false,
						'message' => 'You need to create an account to access this shared list',
						'needs_registration' => true,
						'registration_url' => $registration_url
					];
				}
			}

			// Get list details
			$list = $this->lists->where(['id' => $invitation->list_id])->first();

			if (!$list) {
				return [
					'success' => false,
					'message' => 'The shared list no longer exists'
				];
			}

			// Update invitation to accepted
			$this->listShares->where(['id' => $invitation->id])->updateResults([
				'status' => 'accepted',
				'user_id' => $user_id,
			]);

			// Notify list owner
			$user = get_userdata($user_id);
			$display_name = $user ? $user->display_name : $email;

			JVB()->notification()->addNotification(
				$list->user_id,
				'list_share_accepted',
				$user_id,
				sprintf('%s accepted your invitation to the list "%s"', $display_name, $list->name),
				$invitation->list_id,
				'favourites_list',
				[
					'list_id' => $invitation->list_id,
					'list_name' => $list->name,
				]
			);

			return [
				'success' => true,
				'message' => 'List successfully shared with you',
				'list_id' => $invitation->list_id,
				'list_name' => $list->name,
				'permission_type' => $invitation->permission_type
			];

		} catch (Exception $e) {
			$this->logError('acceptListInvitation', [
				'error' => $e->getMessage(),
				'token' => $token,
				'email' => $email
			]);

			return [
				'success' => false,
				'message' => $e->getMessage()
			];
		}
	}

	/**
	 * Get the owner ID for a content item
	 */
	protected function getContentOwner(string $type, int $target_id): int|array|null
	{
		// For posts
		if (str_contains($type, 'post') || in_array($type, array_keys($this->valid_types))) {
			$post = get_post($target_id);
			return $post ? $post->post_author : null;
		}

		// For terms (shops, etc.)
		$owners = get_term_meta($target_id, BASE . 'owner', true);
		if ($owners) {
			$owner_array = array_map('absint', explode(',', $owners));
			return count($owner_array) === 1 ? $owner_array[0] : $owner_array;
		}

		return null;
	}

	/**
	 * Batch format post-type favourites to reduce queries
	 */
	protected function formatPostFavourites(array $items): array
	{
		if (empty($items)) {
			return [];
		}

		$formatted = [];
		$post_ids = array_map(fn($item) => (int)$item->target_id, $items);

		// Get all posts in one query
		$posts = get_posts([
			'post__in' => $post_ids,
			'post_type' => 'any',
			'posts_per_page' => -1,
			'post_status' => 'any',
		]);

		// Create lookup map
		$posts_by_id = [];
		foreach ($posts as $post) {
			$posts_by_id[$post->ID] = $post;
		}

		// Get thumbnails for artists
		$artist_ids = [];
		foreach ($items as $item) {
			if ($item->type === BASE . 'artist') {
				$artist_ids[] = (int)$item->target_id;
			}
		}

		$artist_images = [];
		if (!empty($artist_ids)) {
			global $wpdb;
			$placeholders = implode(',', array_fill(0, count($artist_ids), '%d'));
			$results = $wpdb->get_results($wpdb->prepare(
				"SELECT post_id, meta_value FROM {$wpdb->postmeta}
            WHERE meta_key = %s AND post_id IN ($placeholders)",
				array_merge([BASE . 'image'], $artist_ids)
			));

			foreach ($results as $result) {
				$artist_images[$result->post_id] = $result->meta_value;
			}
		}

		// Get regular thumbnails
		$thumbnail_ids = [];
		foreach ($items as $item) {
			if ($item->type !== BASE . 'artist' && isset($posts_by_id[$item->target_id])) {
				$thumb_id = get_post_thumbnail_id($item->target_id);
				if ($thumb_id) {
					$thumbnail_ids[$item->target_id] = $thumb_id;
				}
			}
		}

		// Format each item
		foreach ($items as $item) {
			$post_id = (int)$item->target_id;

			if (!isset($posts_by_id[$post_id])) {
				continue;
			}

			$post = $posts_by_id[$post_id];

			$formatted_item = [
				'id' => $item->id ?? null,
				'type' => str_replace(BASE, '', $item->type),
				'target_id' => $post_id,
				'date_added' => $item->date_added ?? current_time('mysql'),
				'notes' => $item->notes ?? '',
				'url' => get_permalink($post),
				'title' => $post->post_title,
				'author' => [
					'id' => $post->post_author,
					'name' => get_the_author_meta('display_name', $post->post_author)
				]
			];

			// Add thumbnail
			if ($item->type === BASE . 'artist') {
				$meta_value = $artist_images[$post_id] ?? null;
				$formatted_item['thumbnail'] = $meta_value ? jvbFormatImage($meta_value, 'medium', 'medium') : null;
			} else {
				$thumb_id = $thumbnail_ids[$post_id] ?? null;
				$formatted_item['thumbnail'] = $thumb_id ? jvbFormatImage($thumb_id, 'medium', 'medium') : null;
			}

			$formatted[] = $formatted_item;
		}

		return $formatted;
	}

	/**
	 * Batch format term-type favourites to reduce queries
	 */
	protected function formatTermFavourites(array $items): array
	{
		if (empty($items)) {
			return [];
		}

		$formatted = [];

		// Group by taxonomy
		$terms_by_taxonomy = [];
		foreach ($items as $item) {
			$tax = $item->type;
			if (!isset($terms_by_taxonomy[$tax])) {
				$terms_by_taxonomy[$tax] = [];
			}
			$terms_by_taxonomy[$tax][] = (int)$item->target_id;
		}

		// Get all terms by taxonomy
		$terms_by_id = [];
		foreach ($terms_by_taxonomy as $taxonomy => $term_ids) {
			$terms = get_terms([
				'taxonomy' => $taxonomy,
				'include' => $term_ids,
				'hide_empty' => false,
			]);

			if (!is_wp_error($terms)) {
				foreach ($terms as $term) {
					$terms_by_id[$taxonomy . '_' . $term->term_id] = $term;
				}
			}
		}

		// Get shop images
		$shop_ids = [];
		foreach ($items as $item) {
			if ($item->type === BASE . 'shop') {
				$shop_ids[] = (int)$item->target_id;
			}
		}

		$shop_images = [];
		if (!empty($shop_ids)) {
			global $wpdb;
			$placeholders = implode(',', array_fill(0, count($shop_ids), '%d'));
			$results = $wpdb->get_results($wpdb->prepare(
				"SELECT term_id, meta_value FROM {$wpdb->termmeta}
            WHERE meta_key = %s AND term_id IN ($placeholders)",
				array_merge([BASE . 'image'], $shop_ids)
			));

			foreach ($results as $result) {
				$shop_images[$result->term_id] = $result->meta_value;
			}
		}

		// Format each item
		foreach ($items as $item) {
			$term_id = (int)$item->target_id;
			$key = $item->type . '_' . $term_id;

			if (!isset($terms_by_id[$key])) {
				continue;
			}

			$term = $terms_by_id[$key];

			$formatted_item = [
				'id' => $item->id ?? null,
				'type' => str_replace(BASE, '', $item->type),
				'target_id' => $term_id,
				'date_added' => $item->date_added ?? current_time('mysql'),
				'notes' => $item->notes ?? '',
				'title' => html_entity_decode($term->name),
				'url' => get_term_link($term)
			];

			// Add thumbnail for shops
			if ($item->type === BASE . 'shop') {
				$meta_value = $shop_images[$term_id] ?? null;
				$formatted_item['thumbnail'] = $meta_value ? jvbFormatImage($meta_value, 'medium', 'medium') : null;
			}

			$formatted[] = $formatted_item;
		}

		return $formatted;
	}

	/**
	 * Handle list operations - routes to appropriate method
	 */
	public function handleList(WP_REST_Request $request): WP_REST_Response
	{
		$user_id = absint($request->get_param('user'));
		$operation_id = sanitize_text_field($request->get_param('id'));
		$action = sanitize_text_field($request->get_param('action'));

		if (!$this->userCheck($user_id)) {
			return $this->unauthorized();
		}

		$data = [
			'action' => $action,
			'list_id' => absint($request->get_param('list_id') ?? 0),
			'name' => sanitize_text_field($request->get_param('name') ?? ''),
			'description' => sanitize_textarea_field($request->get_param('description') ?? ''),
			'items' => $request->get_param('items') ?? [],
			'email' => sanitize_email($request->get_param('email') ?? ''),
			'permission_type' => sanitize_text_field($request->get_param('permission_type') ?? 'view'),
		];

		// Map action to operation type
		$operation_type = match ($action) {
			'create' => 'favourite_list_create',
			'update' => 'favourite_list_update',
			'delete' => 'favourite_list_delete',
			'add_items' => 'favourite_list_add_items',
			'remove_items' => 'favourite_list_remove_items',
			'share' => 'favourite_list_share',
			'unshare' => 'favourite_list_unshare',
			default => null
		};

		if (!$operation_type) {
			return $this->error('Invalid action', 'invalid_action', 400);
		}

		JVB()->queue()->queueOperation(
			$operation_type,
			$user_id,
			$data,
			[
				'operation_id' => $operation_id,
				'priority' => 'normal',
			]
		);

		return $this->queued($operation_id);
	}
}