<?php

namespace JVBase\rest\routes;

use JVBase\JVB;
use JVBase\managers\queue\executors\ContentExecutor;
use JVBase\managers\queue\TypeConfig;
use JVBase\rest\RestRouteManager;
use JVBase\managers\Cache;
use JVBase\meta\MetaManager;
use JVBase\utility\Features;
use WP_Post;
use WP_Query;
use WP_Error;
use WP_REST_Request;
use WP_REST_Response;
use Exception;

if (!defined('ABSPATH')) {
	exit; // Exit if accessed directly
}

class ContentRoutes extends RestRouteManager
{
	protected array $fields = [];
	protected array $taxonomies = [];
	protected MetaManager $meta;
	protected string $post_type = '';
	protected string $user_id = '';

	//For Timeline-specific posts
	protected array $timelineSharedFields = [];
	protected array $timelineUniqueFields = [];

	public function __construct()
	{
		$this->cache_name = 'user_content_' . get_current_user_id();
		parent::__construct();
		if (JVB_TESTING) {
			$this->cache->flush();
		}

		$this->action = 'dash-';
		$this->operation_type = 'content_update';
		add_action('init', [$this, 'registerContentExecutors'], 5);
	}

	/**
	 * Register content operation types with the queue's TypeRegistry
	 */
	public function registerContentExecutors(): void
	{
		$registry = JVB()->queue()->registry();
		$executor = new ContentExecutor();

		// Content updates - chunked at 10 posts
		$registry->register('content_update', new TypeConfig(
			executor: $executor,
			chunkKey: 'posts',
			chunkSize: 10
		));

		// Batch creation (from uploads)
		$registry->register('batch_creation', new TypeConfig(
			executor: $executor
		));
	}

	/**
	 * Registers content routes
	 * @return void
	 */
	public function registerRoutes(): void
	{
		// Base content endpoint
		register_rest_route($this->namespace, "/content", [
			[
				'methods' => 'GET',
				'callback' => [$this, 'handleContentRequest'],
				'permission_callback' => [$this, 'checkPermission'],
			],
			[
				'methods' => 'POST',
				'callback' => [$this, 'handleContentUpdate'],
				'permission_callback' => [$this, 'checkPermission']
			]
		]);

		//TODO: consolidate create/batch in with create? I don't think we are ever creating a single item
		register_rest_route($this->namespace, "/create", [
			[
				'methods' => 'POST',
				'callback' => [$this, 'handleContentCreate'],
				'permission_callback' => [$this, 'checkPermission']
			]
		]);
		register_rest_route($this->namespace, "/create/batch", [
			[
				'methods' => 'POST',
				'callback' => [$this, 'handleBatchCreation'],
				'permission_callback' => [$this, 'checkPermission']
			]
		]);
	}

	protected function initTimelineFields(string $content): void
	{
		$content = jvbNoBase($content);
		if (!Features::forContent($content)->has('is_timeline')) {
			return;
		}
		$config = Features::getConfig($content);
		$this->fields = $config['fields'];

		$this->timelineSharedFields = $this->getTimelineSharedFields($content);
		array_unshift($this->timelineSharedFields, 'post_thumbnail');
		array_unshift($this->timelineSharedFields, 'post_title');
		array_unshift($this->timelineSharedFields, 'post_status');

		$this->timelineUniqueFields = $this->getTimelineUniqueFields($content);
	}

	public function getTimelineUniqueFields(string $content): array
	{
		$content = jvbNoBase($content);
		if (!Features::forContent($content)->has('is_timeline')) {
			return [];
		}
		$config = Features::getConfig($content);
		$allFields = $config['fields'];

		return array_keys(array_filter($allFields, function ($field) {
			if (array_key_exists('for_all', $field) && $field['for_all'] === true) {
				return true;
			}
			return false;
		}));
	}

	public function getTimelineSharedFields(string $content): array
	{
		$content = jvbNoBase($content);
		if (!Features::forContent($content)->has('is_timeline')) {
			return [];
		}
		$config = Features::getConfig($content);
		if (!$config || empty($config)) {
			return [];
		}
		$allFields = $config['fields'] ?? [];

		return array_keys(array_filter($allFields, function ($field) {
			if (!array_key_exists('for_all', $field) || $field['for_all'] === false) {
				return true;
			}
			return false;
		}));
	}

	/**
	 * Handle content update/creation
	 * @param WP_REST_Request $request
	 *
	 * @return WP_REST_Response
	 */
	public function handleContentUpdate(WP_REST_Request $request): WP_REST_Response
	{
		$data = $request->get_params();
		$user_id = $data['user'];

		if (!$this->userCheck($user_id)) {
			return new WP_REST_Response([
				'success' => true,
				'message' => 'You for real?'
			]);
		}

		if (!array_key_exists('posts', $data) || !is_array($data['posts'])) {
			return new WP_REST_Response([
				'success' => true,
				'message' => 'No posts found'
			]);
		}

		$count = count($data['posts']);
		$operationId = $data['id'];
		unset($data['user']);
		unset($data['id']);

		$queue = JVB()->queue();
		$queue->queueOperation(
			'content_update',
			$user_id,
			$data,
			[
				'count' => $count,
				'chunk_key' => 'posts',
				'chunk_size' => 10,
				'operation_id' => $operationId
			]
		);
		return new WP_REST_Response([
			'success' => true,
			'message' => 'Queued for processing',
			'operation' => $operationId
		]);
	}

	/**
	 * Handle content creation
	 * @param WP_REST_Request $request
	 *
	 * @return WP_REST_Response
	 */
	public function handleContentCreate(WP_REST_Request $request): WP_REST_Response
	{
		$data = $request->get_json_params();
		$user_id = $data['user'];

		if (!isset($data['posts']) || !is_array($data['posts'])) {
			return new WP_REST_Response([
				'success' => false,
				'message' => 'Invalid request format'
			]);
		}

		$count = count($data['posts']);
		$operationId = $data['id'];
		unset($data['user']);
		unset($data['id']);
		JVB()->queue()->queueOperation(
			'batch_creation',
			$user_id,
			$data,
			[
				'count' => $count,
				'operation_id' => $operationId,
			]
		);

		return new WP_REST_Response([
			'success' => true,
			'message' => 'Queued for processing',
			'operation' => $operationId
		]);
	}


	/**
	 * Handle request
	 * @param WP_REST_Request $request
	 *
	 * @return WP_REST_Response
	 */
	public function handleContentRequest(WP_REST_Request $request): WP_REST_Response
	{
		$params = $request->get_params();
		$user_id = $params['user'];

		if (!$this->userCheck($user_id)) {
			return new WP_REST_Response([
				'success' => false,
				'message' => 'User does not match up. Are you a bot?',
			]);
		}

		$post_status = $params['status'];
		if ($post_status === 'all') {
			$post_status = ['publish', 'draft'];
		} else {
			$post_status = explode(',', $post_status);
		}
		$post_type = str_replace('-', '_', jvbCheckBase($params['content']));


		// Build query args
		$args = [
			'post_type' => $post_type,
			'posts_per_page' => $params['per_page'] ?? 30,
			'paged' => $params['page'],
			'orderby' => 'date',
			'order' => 'DESC',
			'author' => $user_id,
			'post_status' => $post_status
		];
		//Only top level posts for timeline types
		if (Features::forContent($post_type)->has('is_timeline')) {
			$args['post_parent'] = 0;
		}

		//Calendar filters
		if (Features::forContent($post_type)->has('is_calendar')) {
			$args = $this->applyCalendarFilters($args, $params);
		}
		$taxonomies = array_filter($params, function ($param) {
			return str_starts_with($param, 'tax_');
		}, ARRAY_FILTER_USE_KEY);
		if (!empty($taxonomies)) {
			$params['taxonomies'] = [];
			foreach ($taxonomies as $taxonomy => $terms) {
				$taxonomy = str_replace('tax_', '', $taxonomy);
				$params['taxonomies'][$taxonomy] = $terms;
			}
		}
		if (array_key_exists('taxonomies', $params)) {
			$args = $this->applyTaxonomyFilters($args, $params);
		}
		if (array_key_exists('date-filter', $params) || array_key_exists('dateFrom', $params)) {
			$args = $this->applyDateFilters($args, $params);
		}
		if (array_key_exists('orderby', $params) || array_key_exists('order', $params)) {
			$args = $this->applyOrderFilters($args, $params);
		}

		if (array_key_exists('search', $params)) {
			$args['s'] = sanitize_text_field($params['search']);
		}


		$key = $this->cache->generateKey($args);
		// 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 = new WP_REST_Response($cache);
			return $this->addCacheHeaders($response);
		}

		$this->post_type = jvbCheckBase($params['content'] ?? $params['type']);
		// Only expand search to taxonomies if we're actually going to query
		if (array_key_exists('s', $args)) {
			$args = $this->applySearchFilters($args, $params);
		}

		// Run query
		$query = new WP_Query($args);


		$this->fields = jvbGetFields(str_replace('-', '_', $this->post_type));
		$this->taxonomies = $this->getTaxonomies($this->post_type);
		$posts = array_map([$this, 'prepareItem'], $query->posts);

		$data = [
			'items' => $posts,
			'total' => $query->found_posts,
			'total_pages' => $query->max_num_pages
		];


		$this->cache->set($key, $data);

		$response = new WP_REST_Response($data);
		return $this->addCacheHeaders($response);
	}

	protected function applySearchFilters(array $args, array $params): array
	{
		$search_term = sanitize_text_field($params['search']);

		// Search term is already in $args['s'] from earlier

		// Get all taxonomies registered to this post type
		$taxonomies = get_object_taxonomies($this->post_type, 'names');

		if (empty($taxonomies)) {
			return $args;
		}

		// Cache the taxonomy term lookup per search term + post type
		$term_cache_key = 'search_terms_' . md5($search_term . $this->post_type);
		$matching_term_ids = $this->cache->get($term_cache_key);

		if ($matching_term_ids === false) {
			$matching_term_ids = [];

			foreach ($taxonomies as $taxonomy) {
				$terms = get_terms([
					'taxonomy' => $taxonomy,
					'search' => $search_term,
					'hide_empty' => false,
					'fields' => 'ids'
				]);

				if (!is_wp_error($terms) && !empty($terms)) {
					$matching_term_ids = array_merge($matching_term_ids, $terms);
				}
			}

			// Cache term IDs for 1 hour
			$this->cache->set($term_cache_key, $matching_term_ids, 3600);
		}

		if (empty($matching_term_ids)) {
			return $args;
		}

		// Build tax_query for matching terms
		$term_queries = [];

		foreach ($taxonomies as $taxonomy) {
			$taxonomy_term_ids = array_filter($matching_term_ids, function ($term_id) use ($taxonomy) {
				$term = get_term($term_id);
				return !is_wp_error($term) && $term->taxonomy === $taxonomy;
			});

			if (!empty($taxonomy_term_ids)) {
				$term_queries[] = [
					'taxonomy' => $taxonomy,
					'field' => 'term_id',
					'terms' => array_values($taxonomy_term_ids),
					'operator' => 'IN'
				];
			}
		}

		if (!empty($term_queries)) {
			if (isset($args['tax_query'])) {
				$args['tax_query'] = [
					'relation' => 'OR',
					$args['tax_query'],
					[
						'relation' => 'OR',
						...$term_queries
					]
				];
			} else {
				$args['tax_query'] = [
					'relation' => 'OR',
					...$term_queries
				];
			}
		}

		return $args;
	}

	/**
	 * Gets allowed taxonomies for a particular content
	 * @param string $content
	 *
	 * @return array
	 */
	protected function getTaxonomies(string $content): array
	{
		$taxonomy_for = jvbGlobalTaxonomyFor();
		$out = [];
		foreach ($taxonomy_for as $tax => $postTypes) {
			if (in_array($content, $postTypes)) {
				$out[BASE . $tax] = [
					'label' => JVB_CONTENT[$content]['plural'],
					'icon' => $tax,
				];
			}
		}
		return $out;
	}

	/**
	 * Processes operation from queue
	 * @param object $operation
	 * @param array $data
	 *
	 * @return array
	 */
	protected function processBatches(object $operation, array $data): array
	{
		$this->user_id = $operation->user_id;
		$posts = $data['posts'];

		if (empty($posts)) {
			return [
				'success' => false,
				'message' => 'No posts to update'
			];
		}

		$results = [];

		foreach ($posts as $ID => $post_data) {
			if (Features::forContent($post_data['content'])->has('is_timeline') && array_key_exists('timeline', $post_data)) {
				// Handle timeline posts - ensure we have a valid integer ID
				$parent_id = (int)$ID;

				// Skip if ID is invalid (0, 'null', etc would become 0)
				if ($parent_id === 0) {
					error_log('Invalid timeline parent ID: ' . $ID);
					$results[$ID] = [
						'success' => false,
						'message' => 'Invalid parent post ID for timeline'
					];
					continue;
				}

				$results[$ID] = $this->processTimelinePost($parent_id, $post_data);
				continue;
			}
			if (str_starts_with($ID, 'new')) {

				error_log('New post detected. Creating... with: ' . print_r([
						'post_author' => $this->user_id,
						'post_type' => jvbCheckBase($post_data['content']),
						'post_title' => $post_data['post_title'] ?? '',
						'post_status' => $post_data['status'] ?? 'draft',
					], true));
				error_log('Recieved Data: ' . print_r($post_data, true));
				$ID = wp_insert_post([
					'post_author' => $this->user_id,
					'post_type' => jvbCheckBase($post_data['content']),
					'post_title' => $post_data['post_title'] ?? '',
					'post_status' => $post_data['status'] ?? 'draft',
				]);
				if (!$ID || is_wp_error($ID)) {
					$results[$ID] = [
						'success' => false,
						'message' => 'Couldn\'t Create Post'
					];
					continue;
				}
				$fields = jvbGetFields($post_data['content']);
				$allowedFields = array_filter($post_data, function ($key) use ($fields) {
					return array_key_exists($key, $fields);
				}, ARRAY_FILTER_USE_KEY);

				$meta = new MetaManager($ID, 'post');
				$success = $meta->setAll($allowedFields);
				$results[$ID] = [
					'success' => $success
				];
			} else {
				if (!$this->verifyOwnership($ID)) {
					$results[$ID] = [
						'success' => false,
						'message' => 'No permission to modify this post'
					];
					continue;
				}
				error_log('Saving post data: ' . print_r($post_data, true));

				if (array_key_exists('post_status', $post_data)) {
					switch ($post_data['post_status']) {
						case 'publish':
							unset($post_data['post_status']);
							if (user_can($this->user_id, 'manage_options') || user_can($this->user_id, 'skip_moderation')) {
								$result = wp_update_post(['ID' => $ID, 'post_status' => 'publish']);
							}
							break;
						case 'draft':
							$result = wp_update_post([
								'ID' => $ID,
								'post_status' => 'draft'
							]);
							break;
						case 'trash':
							$result = wp_trash_post($ID);
							break;
						case 'delete':
							$result = wp_delete_post($ID, true);
							return ['success' => (bool)$result];
					}
				}
				error_log('Updating data: ' . print_r($post_data, true));
				$fields = jvbGetFields($post_data['content']);
				$allowedFields = array_filter($post_data, function ($key) use ($fields) {
					return array_key_exists($key, $fields);
				}, ARRAY_FILTER_USE_KEY);

				error_log('Allowed Fields: ' . print_r($allowedFields, true));
				$meta = new MetaManager($ID, 'post');
				$success = $meta->setAll($allowedFields);
				$results[$ID] = [
					'success' => $success
				];

			}
		}

		if (jvbSiteHasNotifications()) {
			$this->notifications = JVB()->notification();
			$this->notifications->addNotification(
				$this->user_id,
				'content_update_complete',
				null,
				'Content updates completed!'
			);
		}


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

	/**
	 * Extracts the postdata for timeline post child posts from the pseudo-repeater element
	 * @param int $parent_id
	 * @param array $post_data
	 * @return array|true[]
	 */
	protected function processTimelinePost(int $parent_id, array $post_data): array
	{
		if (!$this->verifyOwnership($parent_id)) {
			return ['success' => false, 'message' => 'No permission'];
		}

		error_log('[Processing Timeline Post...');

		$ignore = ['content', 'user'];
		$this->fields = jvbGetFields($post_data['content']);
		$this->initTimelineFields($post_data['content']);

		// Get parent post details
		$parent_post = get_post($parent_id);
		$parent_title = $parent_post->post_title;
		$parent_is_published = ($parent_post->post_status === 'publish');

		// Extract shared data from top level (excluding post_thumbnail which is unique per post)
		$sharedData = array_filter($post_data, function ($key) use ($ignore) {
			return in_array($key, $this->timelineSharedFields)
				&& !in_array($key, $ignore)
				&& $key !== 'post_thumbnail';
		}, ARRAY_FILTER_USE_KEY);

		// If no shared post_title at top level, extract from first timeline entry
		if (!isset($sharedData['post_title']) && isset($post_data['timeline'][0]['post_title'])) {
			$sharedData['post_title'] = $post_data['timeline'][0]['post_title'];
		}
		$clearParent = false;
		if (array_key_exists('timeline', $post_data) && is_array($post_data['timeline'])) {
			// Remove post_title and post_thumbnail from shared taxonomies
			$sharedTaxonomies = array_filter($sharedData, function ($key) {
				return $key !== 'post_title' && $key !== 'post_thumbnail';
			}, ARRAY_FILTER_USE_KEY);

			// Ensure the parent post exists and is still first in the array
			$index = array_search((string)$parent_id, array_column($post_data['timeline'], 'id'));

			if ($index === false) {
				return [
					'success' => false,
					'message' => 'Missing parent id. This should not have happened'
				];
			}

			if ($index !== 0) {
				$new_parent_id = $post_data['timeline'][0]['id'];

				if (is_numeric($new_parent_id) && (int)$new_parent_id > 0) {
					$new_parent_id = (int)$new_parent_id;
					wp_update_post([
						'ID' => $new_parent_id,
						'post_parent' => 0
					]);

					wp_update_post([
						'ID' => $parent_id,
						'post_parent' => $new_parent_id
					]);

					$existing_children = get_children([
						'post_parent' => $parent_id,
						'fields' => 'ids'
					]);

					foreach ($existing_children as $child_id) {
						if ($child_id !== $new_parent_id) {
							wp_update_post([
								'ID' => $child_id,
								'post_parent' => $new_parent_id
							]);
						}
					}

					// Update parent references
					$parent_id = $new_parent_id;
					$parent_post = get_post($parent_id);
					$parent_title = $parent_post->post_title;
					$parent_is_published = ($parent_post->post_status === 'publish');
				} else {
					$item = $post_data['timeline'][$index];
					unset($post_data['timeline'][$index]);
					array_unshift($post_data['timeline'], $item);
				}
			}

			$errors = [];
			$success = [];
			$existing_children = get_children([
				'post_parent' => $parent_id,
				'orderby' => 'menu_order',
				'post_status' => ['publish', 'draft'],
				'fields' => 'ids'
			]);

			$prevDate = null;
			$latest_date = null;
			$earliest_date = null;
			foreach ($post_data['timeline'] as $order => $timeline) {
				// Get unique fields for this specific timeline entry
				$allowedFields = array_filter($timeline, function ($key) use ($ignore) {
					return in_array($key, $this->timelineUniqueFields) && !in_array($key, $ignore);
				}, ARRAY_FILTER_USE_KEY);

				// Determine the post title
				$is_parent = ((int)$timeline['id'] === $parent_id);
				$provided_title = $timeline['post_title'] ?? '';
				$auto_generated_pattern = '/^.+Treatment #?\d+$/'; // Matches "Title - Treatment #1" or "Title - Treatment 1"

				if ($is_parent) {
					// Parent keeps its own title or uses shared title
					$allowedFields['post_title'] = $provided_title ?: ($sharedData['post_title'] ?? $parent_title);
				} else {
					// For child posts, auto-generate if:
					// 1. No title provided, OR
					// 2. Title matches auto-generated pattern (meaning it wasn't customized)
					if (empty($provided_title) || preg_match($auto_generated_pattern, $provided_title)) {
						$allowedFields['post_title'] = 'Treatment ' . $order;
					} else {
						// Keep custom title
						$allowedFields['post_title'] = $provided_title;
					}
				}

				// Merge with shared taxonomies AFTER setting unique fields
				$allowedFields = array_merge($sharedTaxonomies, $allowedFields);

				// Handle post creation if needed
				if (!array_key_exists('id', $timeline) || !is_numeric($timeline['id'])) {
					$newChild = wp_insert_post([
						'post_author' => $this->user_id,
						'post_type' => jvbCheckBase($post_data['content']),
						'post_title' => $allowedFields['post_title'],
						'post_parent' => $parent_id,
						'menu_order' => $order,
						'post_status' => $parent_is_published ? 'publish' : 'draft'
					]);
					if (!$newChild || is_wp_error($newChild)) {
						$errors[] = [
							'message' => 'Could not create child post',
							'data' => $timeline
						];
						continue;
					}
					$timeline['id'] = $newChild;
				}

				if (in_array((int)$timeline['id'], $existing_children)) {
					unset($existing_children[array_search((int)$timeline['id'], $existing_children)]);
				}

				// Update post status and menu order
				$post_updates = ['ID' => $timeline['id']];

				if (!$is_parent) {
					$post_updates['menu_order'] = $order;

					// Auto-publish child if parent is published
					if ($parent_is_published) {
						$current_post = get_post($timeline['id']);
						if ($current_post && $current_post->post_status !== 'publish') {
							$post_updates['post_status'] = 'publish';
						}
					}
				}

				if (count($post_updates) > 1) {
					$result = wp_update_post($post_updates);
					error_log('Updated post ' . $timeline['id'] . ' with: ' . print_r($post_updates, true) . ' Result: ' . $result);
					$clearParent = true;
				}

				// Update metadata
				$meta = new MetaManager($timeline['id'], 'post');
				$oldValues = $meta->getAll(array_keys($allowedFields));

//				// Set number taxonomy to menu_order (always update for reordering)
//				if (!$is_parent) {
//					$number_value = $order;
//					$term = get_term_by('name', (string)$number_value, BASE . 'number');
//					if (!$term) {
//						$result = wp_insert_term((string)$number_value, BASE . 'number');
//						if ($result && !is_wp_error($result)) {
//							$term = $result['term_id'];
//						}
//					} else {
//						$term = $term->term_id;
//					}
//					$allowedFields['number'] = $term;
//				}

				// Auto-timeline logic
				if ($prevDate) {
					$newDate = array_key_exists('date', $oldValues) ? $oldValues['date'] : ((array_key_exists('date', $allowedFields)) ? $allowedFields['date'] : null);
					if ($newDate) {
						$date1 = new \DateTime($prevDate);
						$date2 = new \DateTime($newDate);
						$weeks = floor($date1->diff($date2)->days / 7);
						if ($weeks > 0) {
							$termToCheck = $weeks . ' Weeks';
							$term = get_term_by('name', $termToCheck, BASE . 'timeline');
							if (!$term) {
								$result = wp_insert_term($termToCheck, BASE . 'timeline');
								if ($result && !is_wp_error($result)) {
									$term = $result['term_id'];
								}
							} else {
								$term = $term->term_id;
							}
							$allowedFields['timeline'] = $term;
						}
					}
				}
				$prevDate = array_key_exists('date', $oldValues) ? $oldValues['date'] : ((array_key_exists('date', $allowedFields)) ? $allowedFields['date'] : $prevDate);

				$updateValues = array_filter($allowedFields, function ($value, $key) use ($oldValues) {
					return (!array_key_exists($key, $oldValues) || $value !== $oldValues[$key]);
				}, ARRAY_FILTER_USE_BOTH);


				$meta->setAll($updateValues);
				$timeline['id'] = (int)$timeline['id'];

				$success[] = $timeline['id'];
			}
		}

		// Delete any remaining children that no longer exist
		if (!empty($existing_children)) {
			foreach ($existing_children as $ID) {
				wp_delete_post($ID);
			}
		}

		if ($clearParent) {
			$this->cache->flush();
			Cache::onPostChange($parent_id, $parent_post);
		}


		return ['success' => true, 'data' => [
			'success' => $success,
			'errors' => $errors
		]];
	}

	/**
	 * Handle batch content creation from uploads
	 * @param WP_REST_Request $request
	 *
	 * @return WP_REST_Response
	 */
	public function handleBatchCreation(WP_REST_Request $request): WP_REST_Response
	{
		//Operation has two parts
		//First, queue image processing
		//Then queue post creation from the stored IDs, depending on mode
		//if direct, each image becomes a new post
		//if selection, each group becomes its own post,
		// and ungrouped items each become their own post
		if (!isset($_FILES['files'])) {
			return new WP_REST_Response([
				'success' => false,
				'message' => 'No files uploaded...',
			]);
		}

		$data = $request->get_params();


		$user_id = $data['user'];
		if (!$this->userCheck($user_id)) {
			return new WP_REST_Response([
				'success' => 'false',
				'message' => 'Invalid user match... are you a bot?'
			]);
		}
		$operation_id = $data['id'];
		$response = new WP_REST_Response([
			'success' => true,
			'message' => 'Successfully sent to server. Added to queue.',
			'operation_id' => $operation_id,
			'status' => 'pending'
		]);
		$this->queue = JVB()->queue();
		JVB()->routes('uploads')->handleUploadRequest($request, false);
		$this->queue->queueOperation(
			'batch_creation',
			$user_id,
			[
				'content' => $request->get_param('content'),
				'mode' => $request->get_param('mode') ?: 'direct',
				'files_data' => $request->get_param('files_data')
			],
			[
				'operation_id' => $operation_id,
				'priority' => 'high',
				'notification' => true,
				'depends_on' => $operation_id . '_upload'
			]
		);

		return $response;
	}

	/**
	 * Generates a post title, based on content type
	 * @param string $content the post type
	 *
	 * @return string
	 */
	protected function generatePostTitle(string $content): string
	{
		$username = get_user_meta($this->user_id, 'first_name', true);
		$link = get_user_meta($this->user_id, BASE . 'link', true);
		$city = jvbArtistCity($link);
		return ucfirst($content) . ' by ' . $city . ' artist ' . $username;
	}

	/**
	 * @param WP_Post $post the post object
	 *
	 * @return array
	 */
	protected function prepareItem(WP_Post $post, bool $skip = false, bool $fields = true): array
	{
		if (!$skip && Features::forContent($post->post_type)->has('is_timeline')) {
			$this->initTimelineFields($post->post_type);
			return $this->formatTimeline($post);
		}
		$this->meta = new MetaManager($post->ID, 'post');
		$data = [
			'id' => $post->ID,
			'title' => $post->post_title,
			'status' => $post->post_status,
			'date' => $post->post_date,
			'modified' => $post->post_modified,
			'thumbnail' => get_the_post_thumbnail_url($post->ID),
			'alt' => get_post_meta(get_post_thumbnail_id(), '_wp_attachment_image_alt', true),
			'icon' => $this->post_type,
			'taxonomies' => [],
			'fields' => ($fields) ? $this->meta->getAll() : [],
			'images' => [],
		];

		// Add taxonomy terms
		foreach ($this->taxonomies as $taxonomy => $options) {
			$tax = str_replace(BASE, '', $taxonomy);
			$terms = wp_get_object_terms(
				$post->ID,
				$taxonomy,
				['fields' => 'id=>name']
			);
			$data['taxonomies'][$tax] = [
				'terms' => (is_wp_error($terms)) ? [] : $terms,
				'name' => $options['label'],
				'icon' => $tax
			];
		}

		$images = $this->extractImages();


		if (!empty($images)) {
			$data['images'] = $images;
		}

		return $data;
	}

	protected function extractImages(array $fields = []): array
	{
		//Extract images
		$images = [];
		$get = [];
		$fields = (empty($fields)) ? $this->fields : $fields;
		foreach ($fields as $field => $config) {
			if ($config['type'] === 'gallery' || $config['type'] === 'image' || $field === 'post_thumbnail') {
				$get[] = $field;
			}
		}

		if (!empty($get)) {
			$allImages = $this->meta->getAll($get);
			foreach ($allImages as $k => $imgs) {
				$temp = explode(',', $imgs);
				foreach ($temp as $img) {
					if (is_numeric($img) && !array_key_exists($img, $images)) {
						$images[$img] = jvbImageData((int)$img);
					}
				}
			}
		}
		return $images;
	}

	public function formatTimeline(WP_Post $post): array
	{
		$item = $this->prepareItem($post, true, false);
		//Step 1: Get the fields that apply to all posts
		$mainMeta = new MetaManager($post->ID, 'post');
		$item['fields'] = $mainMeta->getAll($this->timelineSharedFields);

		//Step 2: Get the fields for each individual posts
		$children = get_children(['post_parent' => $post->ID, 'orderby' => 'date', 'order' => 'ASC', 'post_status' => ['publish', 'draft'], 'fields' => 'ids']);
		array_unshift($children, $post->ID);

		$subFields = [];
		$images = [];
		foreach ($children as $child) {
			$meta = new MetaManager($child, 'post');
			$f = $meta->getAll($this->timelineUniqueFields);
			$f = ['id' => $child] + $f;
			$subFields[] = $f;

			$images[$f['post_thumbnail']] = jvbImageData((int)$f['post_thumbnail']);
		}
		$item['fields']['timeline'] = $subFields;
		$item['images'] = $item['images'] + $images;
		$item['number'] = $mainMeta->getValue('number');

		return $item;
	}

	/**
	 * Builds the taxonomy query
	 * @param array $taxonomies
	 *
	 * @return array|string[]
	 */
	protected function buildTaxQuery(array $taxonomies): array
	{
		$tax_query = [];
		error_log('Taxonomies in query: ' . print_r($taxonomies, true));

		foreach ($taxonomies as $taxonomy => $terms) {
			if (!empty($terms)) {
				$tax_query[] = [
					'taxonomy' => jvbCheckBase($taxonomy),
					'field' => 'term_id',
					'terms' => array_map('absint', (array)$terms)
				];
			}
		}


		return count($tax_query) > 1
			? array_merge(['relation' => 'AND'], $tax_query)
			: $tax_query;
	}

	/**
	 * Builds the date query
	 * @param array $date_params
	 *
	 * @return array
	 */
	protected function buildDateQuery(array $date_params): array
	{
		$query = [];

		if (!empty($date_params['after'])) {
			$query['after'] = sanitize_text_field($date_params['after']);
		}

		if (!empty($date_params['before'])) {
			$query['before'] = sanitize_text_field($date_params['before']);
		}

		if (isset($date_params['inclusive'])) {
			$query['inclusive'] = (bool)$date_params['inclusive'];
		}

		return empty($query) ? [] : [$query];
	}

	/**
	 * @param int $post_id
	 *
	 * @return bool
	 */
	protected function verifyOwnership(int $post_id): bool
	{
		$post = get_post($post_id);
		return $post && $post->post_author == $this->user_id;
	}

	/**
	 * Processes operation from Operation Queue
	 * @param WP_Error|array $result
	 * @param object $operation
	 * @param array $data
	 *
	 * @return array|WP_Error
	 */
	public function processOperation(WP_Error|array $result, object $operation, array $data): array|WP_Error
	{
		if ($operation->type === 'batch_creation') {
			$JVB = JVB();
			$queue = $JVB->queue();

			$images = $queue->getOperationValue($operation->id . '_upload', 'result') ?? false;

			$this->user_id = $operation->user_id;
			$this->post_type = BASE . $data['content'];
			try {
				$results = [];
				if ($images) {
					if ($data['mode'] == 'selection') {
						$total = count($images);
						foreach ($images as $group => $files) {
							$settings = json_decode($data['files_data'][$group]);

							switch ($settings->type) {
								case 'group':
									$featuredIndex = $settings->metadata->featuredFile ?? 0;
									$title = $settings->metadata->title ?? $this->generatePostTitle($data['content']);
									$new = wp_insert_post([
										'post_type' => BASE . $data['content'],
										'post_title' => $title,
										'post_status' => 'draft',
										'post_author' => $operation->user_id
									]);
									if ($new && !is_wp_error($new)) {
										set_post_thumbnail($new, $files[$featuredIndex]['attachment_id']);
										unset($files[$featuredIndex]);
										if (!empty($files)) {
											$meta = new MetaManager($new, 'post');
											$IDs = array_column($files, 'attachment_id');
											$meta->updateValue('gallery', implode(',', $IDs));
										}
										$results[] = $new;
//                                        $queue->updateOperationProgress($operation->id, $group + 1, $total);
									}
									break;
								default:
									foreach ($files as $img) {
										$new = wp_insert_post([
											'post_type' => BASE . $data['content'],
											'post_title' => $this->generatePostTitle($data['content']),
											'post_status' => 'draft',
											'post_author' => $operation->user_id
										]);

										if ($new && !is_wp_error($new)) {
											set_post_thumbnail($new, $img['attachment_id']);
											$results[] = $new;
//                                            $queue->updateOperationProgress($operation->id, $group + 1, $total);
										}
									}
									break;
							}
						}
					} else {
						$total = count($images);
						foreach ($images as $key => $img) {
							$new = wp_insert_post([
								'post_type' => BASE . $data['content'],
								'post_title' => $this->generatePostTitle($data['content']),
								'post_status' => 'draft',
								'post_author' => $operation->user_id
							]);
							if ($new && !is_wp_error($new)) {
								set_post_thumbnail($new, $img['attachment_id']);
							}
							$results[] = $new;
//                            $queue->updateOperationProgress($operation->id, $key + 1, $total);
						}
					}
				}

				return [
					'success' => true,
					'result' => $results
				];
			} catch (Exception $e) {
				$JVB->error()->log(
					'[ContentRoutes]:processOperation',
					$e->getMessage()
				);
			}

			return $results;
		} elseif ($operation->type == 'content_update') {
			$result = $this->processBatches($operation, $data);
		}

		return $result;
	}
	// Add to ContentRoutes.php

	/**
	 * One-time migration: Set latest_date meta for all timeline posts
	 * Call this once via WP-CLI or a temporary admin page
	 *
	 * Usage: add_action('admin_init', function() {
	 *     if (current_user_can('manage_options')) {
	 *         JVB()->routes('content')->migrateTimelineLatestDates();
	 *     }
	 * });
	 */
	public function migrateTimelineLatestDates(): array
	{
		global $wpdb;

		$results = [
			'processed' => 0,
			'updated' => 0,
			'skipped' => 0,
			'errors' => []
		];

		// Get all timeline post types
		$timeline_types = [];
		foreach (JVB_CONTENT as $type => $config) {
			if (Features::forContent($type)->has('is_timeline')) {
				$timeline_types[] = BASE . $type;
			}
		}

		if (empty($timeline_types)) {
			return $results;
		}

		// Get all parent timeline posts
		$args = [
			'post_type' => $timeline_types,
			'post_status' => ['publish', 'draft'],
			'post_parent' => 0,
			'posts_per_page' => -1,
			'fields' => 'ids'
		];

		$parent_ids = get_posts($args);

		foreach ($parent_ids as $parent_id) {
			$results['processed']++;

			try {
				// Get all children including the parent
				$children = get_children([
					'post_parent' => $parent_id,
					'post_status' => ['publish', 'draft'],
					'orderby' => 'menu_order',
					'order' => 'ASC',
					'fields' => 'ids'
				]);

				// Add parent to the list
				array_unshift($children, $parent_id);

				// Find latest date among all posts
				$latest_timestamp = 0;

				foreach ($children as $post_id) {
					$date = get_post_meta($post_id, BASE . 'date', true);

					if ($date) {
						$timestamp = strtotime($date);
						if ($timestamp > $latest_timestamp) {
							$latest_timestamp = $timestamp;
						}
					}
				}

				// Update parent with latest date
				if ($latest_timestamp > 0) {
					update_post_meta($parent_id, BASE . 'latest_date', $latest_timestamp);
					$results['updated']++;
					error_log("Updated post {$parent_id} with latest_date: {$latest_timestamp}");
				} else {
					// Fallback to parent post's post_date
					$parent_post = get_post($parent_id);
					$fallback_timestamp = strtotime($parent_post->post_date);

					if ($fallback_timestamp > 0) {
						update_post_meta($parent_id, BASE . 'latest_date', $fallback_timestamp);
						$results['updated']++;
						error_log("Updated post {$parent_id} with fallback latest_date: {$fallback_timestamp} (from post_date)");
					} else {
						$results['skipped']++;
						error_log("No dates found for post {$parent_id}");
					}
				}

			} catch (Exception $e) {
				$results['errors'][] = [
					'post_id' => $parent_id,
					'error' => $e->getMessage()
				];
			}
		}

		error_log('Timeline migration complete: ' . print_r($results, true));
		return $results;
	}
}


//add_action('init', function() {
////	delete_option('jvb_timeline_migrated');
//	if (get_option('jvb_timeline_migrated')) {
//		return;
//	}
//	JVB()->routes('content')->migrateTimelineLatestDates();
//	update_option('jvb_timeline_migrated', true);
//});