<?php
namespace JVBase\rest\routes;

use JVBase\JVB;
use JVBase\managers\queue\executors\UploadExecutor;
use JVBase\managers\queue\TypeConfig;
use JVBase\rest\RestRouteManager;
use JVBase\meta\MetaManager;
use JVBase\managers\UploadManager;
use JVBase\utility\Features;
use WP_REST_Request;
use WP_REST_Response;
use WP_Error;
use Exception;

if (!defined('ABSPATH')) {
    exit; // Exit if accessed directly
}
class UploadRoutes extends RestRouteManager
{

    public function __construct()
    {
		$this->action = 'dash-';
        parent::__construct();

		add_action('init', [$this, 'registerUploadExecutors'], 5);
    }

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

		// Image uploads - chunked at 5 files
		$registry->register('image_upload', new TypeConfig(
			executor: $executor,
			chunkKey: 'secured_files',
			chunkSize: 5
		));

		// Video uploads - one at a time (heavy processing)
		$registry->register('video_upload', new TypeConfig(
			executor: $executor,
			chunkKey: 'secured_files',
			chunkSize: 1
		));

		// Document uploads - chunked at 10
		$registry->register('document_upload', new TypeConfig(
			executor: $executor,
			chunkKey: 'secured_files',
			chunkSize: 10
		));

		// Metadata updates
		$registry->register('update_metadata', new TypeConfig(
			executor: $executor
		));

		// Cleanup - chunked at 5
		$registry->register('temporary_cleanup', new TypeConfig(
			executor: $executor,
			chunkKey: 'files',
			chunkSize: 5
		));

		// Attach to content (depends on upload completing)
		$registry->register('attach_upload_to_content', new TypeConfig(
			executor: $executor
		));

		// Process upload groups into posts
		$registry->register('process_upload_groups', new TypeConfig(
			executor: $executor
		));
	}

    /**
     * Registers upload routes
     * @return void
     */
    public function registerRoutes():void
    {
		// Main upload endpoint
		register_rest_route($this->namespace, '/uploads', [
			'methods' => 'POST',
			'callback' => [$this, 'handleUpload'],
			'permission_callback' => [$this, 'checkPermission']
		]);

		register_rest_route($this->namespace, '/uploads/groups', [
			'methods' => 'POST',
			'callback' => [$this, 'handleGroupingRequest'],
			'permission_callback' => [$this, 'checkPermission'],
			'args' => [
				'id' => [
					'required' => true,
					'type' => 'string',
					'description' => 'Original upload operation ID'
				],
				'content' => [
					'required' => true,
					'type' => 'string'
				],
				'user' => [
					'required' => true,
					'type' => 'integer'
				],
			]
		]);

		register_rest_route($this->namespace, '/uploads/meta', [
			'methods' => 'POST',
			'callback' => [$this, 'handleMetadataUpdate'],
			'permission_callback' => [$this, 'checkPermission'],
			'args' => [
				'user' => [
					'type' => 'integer',
					'required' => true
				],
				'items' => [
					'type' => 'array',
					'required' => true,
					'description' => 'Direct attachment IDs (for updates after completion)',
				],
			]
		]);
    }

	/**
	 * Build the main $context for UploadManager from the $request params
	 * @param WP_REST_Request $request
	 * @return array
	 */
    protected function buildUploadArgs(WP_REST_Request $request):array
    {
        $data = $request->get_params();
		$args = [];
		foreach ($data as $key => $value) {
			switch ($key) {
				// Post Type/Taxonomy
				case 'content':
					$key = str_replace('-', '_', $key);
					if ($value === 'options' || array_key_exists($value, JVB_CONTENT) || Features::forTaxonomy($key)->has('is_content')) {
						$args['content'] = $value;
					}
					break;
				case 'destination':
					if (in_array($value, ['meta', 'post', 'post_group'])) {
						$args['destination'] = sanitize_text_field($value);
						if (in_array($value, ['post', 'post_group']) && empty($data['content'])) {
							throw new Exception("Content type required for destination: {$value}");
						}
					}
					break;
				// User ID
				case 'user':
					if ($this->userCheck($value)) {
						$args['user'] = (int) $value;
						if (!array_key_exists('post_id', $data) && !array_key_exists('term_id', $data)) {
							$args['post_id'] = (int)get_user_meta((int) $value, BASE.'link', true);
						}
					}
					break;
				// Operation ID
				case 'id':
					if (is_string($value)) {
						$value = sanitize_text_field($value);
						$args['id'] =  $value;
						$args['upload'] = $value.'_upload';
					}
					break;
				// Post ID
				case 'post_id':
					if (is_numeric($value)) {
						$args['post_id'] = absint($value);
					}
					break;
				// Term ID
				case 'term_id':
					if (is_numeric($value)) {
						$args['term_id'] = absint($value);
					}
					break;
				// Field Name, as defined for MetaManager.php
				case 'field_name':
					if (is_string($value)) {
						$args['field_name'] = sanitize_text_field($value);
					}
					break;
				// Upload Mode
				case 'mode':
					if (in_array($value, ['direct', 'selection'])) {
						$args['mode'] = sanitize_text_field($value);
					}
					break;
				case 'upload_ids':
					if (is_string($value)) {
						// Parse JSON array
						$decoded = json_decode($value, true);
						if (is_array($decoded)) {
							$args['upload_ids'] = $decoded;
						}
					} elseif (is_array($value)) {
						// Already an array (shouldn't happen with FormData JSON, but handle it)
						$args['upload_ids'] = $value;
					}
					break;
				case 'metadata':
					if (!empty($value)) {
						$metadata = is_string($value) ? json_decode($value, true) : $value;
						if (is_array($metadata)) {
							foreach ($metadata as $k => $v) {
								if (in_array($k, ['title', 'caption', 'alt', 'depends_on'])) {
									$args['metadata'][$k] = sanitize_text_field($v);
								}
							}
						}
					}
					break;
				case 'posts':
					if (is_string($value)) {
						$decoded = json_decode($value, true);
						if (is_array($decoded)) {
							$args['posts'] = $decoded;
						}
					}
					break;

				case 'group_titles':
					if (is_string($value)) {
						$decoded = json_decode($value, true);
						if (is_array($decoded)) {
							$args['group_titles'] = array_map('sanitize_text_field', $decoded);
						}
					}
					break;
				// Other field info
				case 'field_key':
				case 'field_type':
				case 'subtype':
				case 'item_id':
				case 'context':
					if (is_string($value)) {
						$args[$key] = sanitize_text_field($value);
					}
					break;
			}
		}
        return $args;
    }

    /**
     * Handle upload request with immediate feedback
     */
    /**
     * @param WP_REST_Request $request
     *
     * @return WP_REST_Response
     */
	public function handleUpload(WP_REST_Request $request): WP_REST_Response
	{
		try {
			$files = $request->get_file_params();
			$args = $this->buildUploadArgs($request);

			if (!$args['content'] || !$args['user']) {

				$this->logError('Missing required data');
				return new WP_REST_Response([
					'success'	=> false,
					'message'	=> 'Missing required data'
				]);
			}

			// Step 1: Secure all uploaded files
			$secured_files = $this->secureFiles($files, $args);

			if (empty($secured_files)) {
				$this->logError('No valid files to upload');
				return new WP_REST_Response([
					'success'	=> false,
					'message'	=> 'No valid files to upload'
				]);
			}

			// Step 2: Queue for processing via OperationQueue
			$operation_id = $this->queueProcessing($secured_files, $args);

			return new WP_REST_Response([
				'success' => true,
				'operation_id' => $operation_id,
				'file_count' => count($secured_files),
				'message' => 'Files secured and queued for processing'
			], 200);

		} catch (Exception $e) {
			// Error handling...
			JVB()->error()->log(
				'[UploadRoutes]:handleUploadRequest',
				$e->getMessage(),
				[
					'request_data' => $request->get_params(),
					'files_info' => $this->getFilesInfo($_FILES),
					'trace' => $e->getTraceAsString()
				]
			);

			return $this->sendResponse(
				false,
				['error_code' => 'upload_failed'],
				'Upload processing failed: ' . $e->getMessage()
			);
		}
	}

	/**
	 * Secure uploaded files to temporary storage
	 */
	protected function secureFiles(array $files, array $args): array
	{
		$uploader = new UploadManager();
		$secured_files = [];
		$errors = [];

		$context = $args;
		unset($context['upload_ids']);

		$file_array = $files['files'] ?? $files;
		if (!is_array($file_array['tmp_name'])) {
			$file_array = [
				'name' => [$file_array['name']],
				'type' => [$file_array['type']],
				'tmp_name' => [$file_array['tmp_name']],
				'error' => [$file_array['error']],
				'size' => [$file_array['size']]
			];
		}
		$tmp_names = $file_array['tmp_name'] ?? [];


		foreach ($tmp_names as $index => $tmp_name) {
			$file_data = [
				'name' => $file_array['name'][$index],
				'type' => $file_array['type'][$index],
				'tmp_name' => $tmp_name,
				'error' => $file_array['error'][$index],
				'size' => $file_array['size'][$index]
			];

			if ($file_data['error'] !== UPLOAD_ERR_OK) {
				$errors[$index] = $this->getUploadErrorMessage($file_data['error']);
				continue;
			}

			try {
				$secured = $uploader->secureUploadedFile($file_data, $context);

				if (empty($secured)) {
					throw new Exception('Failed to secure file');
				}

				// Embed upload_id directly in the secured file data
				$secured['upload_id'] = $args['upload_ids'][$index] ?? 'upload_' . $index;

				$secured_files[] = $secured;
			} catch (Exception $e) {
				$errors[$index] = $e->getMessage();
			}
		}

		return [
			'files' => $secured_files,
			'errors' => $errors
		];
	}

	protected function getUploadErrorMessage(int $error_code): string
	{
		return match($error_code) {
			UPLOAD_ERR_INI_SIZE => 'File exceeds maximum upload size',
			UPLOAD_ERR_FORM_SIZE => 'File exceeds form maximum size',
			UPLOAD_ERR_PARTIAL => 'File was only partially uploaded',
			UPLOAD_ERR_NO_FILE => 'No file was uploaded',
			UPLOAD_ERR_NO_TMP_DIR => 'Missing temporary folder',
			UPLOAD_ERR_CANT_WRITE => 'Failed to write file to disk',
			UPLOAD_ERR_EXTENSION => 'Upload stopped by extension',
			default => 'Unknown upload error'
		};
	}


	/**
	 * Queue files for processing
	 */
	protected function queueProcessing(array $secured_data, array $args): string
	{
		$operation_type = $this->determineOperationType($secured_data['files'][0] ?? []);

		$chunkSize = 5;
		if ($operation_type === 'video') {
			$chunkSize = 1;
		} elseif ($operation_type === 'document') {
			$chunkSize = 10;
		}

		JVB()->queue()->queueOperation(
			$operation_type,
			$args['user'],
			array_merge(
				['secured_files' => $secured_data['files']],
				$args
			),
			[
				'operation_id'  => $args['upload'],
				'chunk_key'     => 'secured_files',
				'chunk_size'    => $chunkSize
			]
		);

		if ($args['mode'] !== 'selection') {
			JVB()->queue()->queueOperation(
				'attach_upload_to_content',
				$args['user'],
				$args,
				[
					'priority'      => 'high',
					'operation_id'  => $args['id'],
					'depends_on'    => $args['upload']
				]
			);
		}

		JVB()->queue()->queueOperation(
			'temporary_cleanup',
			$args['user'],
			[
				'files'     => $secured_data['files'],
				'context'   => $args,
			],
			[
				'priority'      => 'low',
				'chunk_size'    => 5,
				'chunk_key'     => 'files',
				'depends_on'    => $args['upload']
			]
		);

		return $args['id'];
	}

	/**
	 * Determine operation type from file data
	 */
	protected function determineOperationType(array $file): string
	{
		$file_type = $file['file_type'] ?? 'image';

		return match($file_type) {
			'video' => 'video_upload',
			'document' => 'document_upload',
			default => 'image_upload'
		};
	}

	/**
	 * Step 3: Process operation from queue
	 * Called by OperationQueue
	 * @param WP_Error|array $result
	 * @param object $operation
	 * @param array $data
	 *
	 * @return array|WP_Error
	 */
	public function processOperation(array $result, object $operation, array $data): array
	{
		// Only handle our operation types
		$handled_types = [
			'image_upload',
			'video_upload',
			'document_upload',
			'update_metadata',
			'temporary_cleanup',
			'attach_upload_to_content',
			'process_upload_groups'
		];

		if (!in_array($operation->type, $handled_types)) {
			return $result; // Not our operation, pass through
		}

		try {
			// Route to appropriate handler
			$handler_result = match($operation->type) {
				'image_upload' => $this->processImageUpload($operation, $data),
				'video_upload' => $this->processVideoUpload($operation, $data),
				'document_upload' => $this->processDocumentUpload($operation, $data),
				'update_metadata' => $this->processUploadMeta($result, $operation, $data),
				'temporary_cleanup' => $this->processTemporaryCleanup($result, $operation, $data),
				'attach_upload_to_content' => $this->processAttachToContent($operation, $data),
				'process_upload_groups'	=> $this->processUploadGroups($result, $operation, $data),
				default => new WP_Error('unknown_type', 'Unknown operation type')
			};

			// Handle WP_Error
			if (is_wp_error($handler_result)) {
				return [
					'success' => false,
					'result' => $handler_result->get_error_message()
				];
			}

			return $handler_result;

		} catch (Exception $e) {
			JVB()->error()->log(
				'[UploadRoutes]:processOperation',
				$e->getMessage(),
				[
					'operation_id' => $operation->id,
					'operation_type' => $operation->type
				]
			);

			return [
				'success' => false,
				'result' => $e->getMessage()
			];
		}
	}
	/**
	 * Standardize processing result
	 */
	protected function standardizeResult(array $result): array
	{
		return [
			'attachment_id' => $result['attachment_id'],
			'url' => $result['url'],
			'file' => $result['file'],
			'upload_id' => $result['upload_id'] ?? null
		];
	}

	protected function processAttachToContent(object $operation, array $data): array
	{
		try {
			// Get the results from the upload operation
			$upload_results = JVB()->queue()->getOperationValue($data['upload'], 'result', true);

			if (empty($upload_results)) {
				throw new Exception('No upload results found for operation: ' . $data['upload']);
			}

			// Now attach to the specified content
			if (!empty($data['field_name'])) {
				$this->updateFieldValue($data, $upload_results);
			}

			return [
				'success' => true,
				'result' => 'Attachments linked to content'
			];

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

	/**
	 * Cleanup temporary files after processing
	 */
	protected function cleanupTempFiles(array $secured_files, int $user_id): void
	{
		$uploader = new UploadManager();

		foreach ($secured_files as $secured) {
			if (!empty($secured['temp_path']) && file_exists($secured['temp_path'])) {
				@unlink($secured['temp_path']);
			}
		}

		// Clean up empty directories
		$uploader->cleanupEmptyTempDirs($user_id);
	}

	/**
	 * Update field value with new attachment IDs
	 */
	protected function updateFieldValue(array $data, array $results): void
	{
		if ((!array_key_exists('post_id', $data) && !array_key_exists('term_id', $data) && !array_key_exists('user', $data))  && !array_key_exists('field_name', $data)) {
			return;
		}

		$attachment_ids = array_column($results, 'attachment_id');
		if (array_key_exists('post_id', $data)) {
			$meta = new MetaManager($data['post_id'], 'post');
		} elseif (array_key_exists('term_id', $data)) {
			$meta = new MetaManager($data['term_id'], 'term');
		} else {
			$link = (int)get_user_meta($data['user'], BASE.'link');
			$meta = new MetaManager($link, 'post');
		}

		// Get existing value
		$existing = $meta->getValue($data['field_name']);
		$existing_ids = !empty($existing) ? explode(',', $existing) : [];

		// Merge with new IDs
		$all_ids = array_unique(array_merge($existing_ids, $attachment_ids));

		// Update with comma-separated string
		$meta->updateValue($data['field_name'], implode(',', $all_ids));
	}

	/**
	 * Generic file upload processor - works for images, videos, documents
	 */
	protected function processFileUpload(object $operation, array $data, string $file_type): WP_Error|array
	{
		try {
			$uploader = new UploadManager();
			$processed_results = [];
			$config = $this->getFieldConfig($data);

			$args = $data;
			unset($args['secured_files']);

			foreach ($data['secured_files'] as $secured_file) {
				$result = $uploader->processUpload(
					$secured_file['temp_path'],
					array_merge(
						$config,
						[
							'file_type' => $file_type,
							'user_id' => $operation->user_id,
							'post_id' => (int)($data['post_id'] ?? 0),
							'term_id' => (int)($data['term_id'] ?? 0),
							'original_name' => $secured_file['original_name'],
							'mime_type' => $secured_file['mime_type'],
							'content' => $data['content'] ?? '',
						]
					)
				);

				if (!is_wp_error($result)) {
					$standardized = $this->standardizeResult($result);

					// Use embedded upload_id from the secured file itself
					$standardized['upload_id'] = $secured_file['upload_id'] ?? null;

					if ($standardized['upload_id']) {
						$processed_results[$standardized['upload_id']] = $standardized;
					} else {
						$processed_results[] = $standardized;
					}

					// Apply frontend metadata if provided
					if (!empty($secured_file['metadata'])) {
						$this->applyMeta($standardized['attachment_id'], $secured_file['metadata']);
					}
				}
			}

			$this->handleUploadDestination($data, $processed_results);

			// Cleanup temporary files
			$this->cleanupTempFiles($data['secured_files'], $operation->user_id);

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

		} catch (Exception $e) {
			JVB()->error()->log(
				'[UploadRoutes]:processFileUpload',
				$e->getMessage(),
				[
					'operation_id' => $operation->id,
					'file_type' => $file_type,
					'user_id' => $operation->user_id
				]
			);
			return [
				'success'   => false,
				'result'    => $e->getMessage()
			];
		}
	}

	/**
	 * Process image uploads
	 */
	protected function processImageUpload(object $operation, array $data): WP_Error|array
	{
		return $this->processFileUpload($operation, $data, 'image');
	}

	/**
	 * Process video uploads
	 */
	protected function processVideoUpload(object $operation, array $data): WP_Error|array
	{
		return $this->processFileUpload($operation, $data, 'video');
	}

	/**
	 * Process document uploads
	 */
	protected function processDocumentUpload(object $operation, array $data): WP_Error|array
	{
		return $this->processFileUpload($operation, $data, 'document');
	}

	/**
	 * Process temporary cleanup operation
	 * Called by OperationQueue for 'temporary_cleanup' operations
	 *
	 * @param array $result
	 * @param object $operation
	 * @param array $data
	 * @return array
	 */
	protected function processTemporaryCleanup(array $result, object $operation, array $data): array
	{
		try {
			// Cleanup temporary files if they exist
			if (!empty($data['secured_files'])) {
				$this->cleanupTempFiles($data['secured_files'], $operation->user_id);
			}

			// If specific temp paths provided
			if (!empty($data['temp_paths']) && is_array($data['temp_paths'])) {
				foreach ($data['temp_paths'] as $temp_path) {
					if (file_exists($temp_path)) {
						@unlink($temp_path);
					}
				}
			}

			// Cleanup empty temp directories for this user
			if (!empty($operation->user_id)) {
				$uploader = new UploadManager();
				$uploader->cleanupEmptyTempDirs($operation->user_id);
			}

			return [
				'success' => true,
				'result' => 'Temporary files cleaned up successfully'
			];

		} catch (Exception $e) {
			JVB()->error()->log(
				'[UploadRoutes]:processTemporaryCleanup',
				$e->getMessage(),
				[
					'operation_id' => $operation->id,
					'user_id' => $operation->user_id
				]
			);

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

	/**
	 * Handle metadata update requests
	 */
	public function handleMetadataUpdate(WP_REST_Request $request): WP_REST_Response
	{
		try {
			$data = $request->get_params();

			error_log('Received data for meta change: '.print_r($data, true));


			$items = $data['items']??false;
			if (!$items) {
				return $this->sendResponse(
					true,
					[
					],
					'No items to update'
				);
			}
			$pending = [];
			$attachments = array_filter($items, function ($item) {
				return array_key_exists('attachmentId', $item);
			});
			if (count($attachments) !== count($items)) {
				$pending = array_filter($items, function ($item) {
					return array_key_exists('uploadId',$item);
				});
			}


			if (!empty($attachments)) {
				// Phase 2B: Direct attachment update (images already processed)
				return $this->updateMeta($attachments, $data['user']);
			}
			elseif (!empty($pending)) {
				// Phase 2A: Queue metadata update with dependency on upload operation
				return $this->queueMetaUpdate($pending, $data['user']);
			}

			return $this->sendResponse(
				false,
				['error_code' => 'missing_identifiers'],
				'Must provide either attachment_ids or operation_id'
			);

		} catch (Exception $e) {
			JVB()->error()->log(
				'[UploadRoutes]:handleMetadataUpdate',
				$e->getMessage(),
				[
					'request_data' => $request->get_params(),
					'trace' => $e->getTraceAsString()
				]
			);

			return $this->sendResponse(
				false,
				['error_code' => 'metadata_update_failed'],
				'Metadata update failed: ' . $e->getMessage()
			);
		}
	}
	/**
	 * Update metadata directly on completed attachments
	 */
	protected function updateMeta(array $data, int $user): WP_REST_Response
	{
		$updated_count = 0;
		$errors = [];
		$ids = [];
		foreach ($data as $info) {
			try {
				$attachment_id = $info['attachmentId'];
				$ids[] = $attachment_id;
				unset($info['attachmentId']);
				// Verify attachment exists and user has permission
				if (!$this->verifyAttachmentAccess($attachment_id, $user)) {
					$errors[] = "No permission to edit attachment {$attachment_id}";
					continue;
				}

				$this->applyMeta($attachment_id, $info);
				$updated_count++;

			} catch (Exception $e) {
				$errors[] = "Failed to update attachment {$attachment_id}: " . $e->getMessage();
			}
		}

		return $this->sendResponse(
			$updated_count > 0,
			[
				'updated_count' => $updated_count,
				'errors' => $errors,
				'attachment_ids' => $ids
			],
			$updated_count > 0 ?
				"Updated metadata for {$updated_count} attachment(s)" :
				'No attachments were updated'
		);
	}
	/**
	 * Queue metadata update with dependency on upload operation
	 */
	protected function queueMetaUpdate(array $data, int $user): WP_REST_Response
	{
		$queue = JVB()->queue();
		$depends_on = [];
		$errors = [];
		$original = count($data);
		foreach ($data as $uploadID => $info) {
			if (!array_key_exists('depends_on', $info)) {
				unset($data[$uploadID]);
				$errors[$uploadID] = $info;
				continue;
			}
			if (!in_array($info['depends_on'], $depends_on)) {
				$depends_on[] = $info['depends_on'];
			}
		}
		$operationID = $queue->queueOperation(
			'update_metadata',
			$user,
			$data,
			[
				'depends_on' => $depends_on,
				'priority' => 'medium',
			]
		);

		return $this->sendResponse(
			true,
			[
				'operation_id' => $operationID,
				'message'		=> "Successfully queued ".count($data)." of {$original} meta updates"
			],
			'Metadata update queued - will apply after upload completes'
		);
	}

	/**
	 * Process metadata update operation (called by queue processor)
	 */
	public function processUploadMeta(WP_Error|array $result, object $operation, array $data): WP_Error|array
	{
		try {
			if (!is_array($operation->depends_on)) {
				$operation->depends_on = [$operation->depends_on];
			}
			$updated_count = 0;
			$errors = [];
			foreach ($operation->depends_on as $dependency) {
				$operationData = JVB()->queue()->getOperation($dependency);
				if (!$operationData || $operationData->status !== 'completed') {
					throw new Exception('Original upload operation not found or not completed');
				}

				$uploadResults = json_decode($operationData->result, true);
				if (!$uploadResults || !$uploadResults['success']) {
					throw new Exception('Original upload operation failed');
				}
				$attachmentsToUpdate = array_filter($data, function ($item) use ($dependency) {
					return $item['depends_on'] === $dependency;
				});

				$uploadIDToAttachment = $this->buildUploadToAttachmentMapping(
					array_keys($attachmentsToUpdate),
					$uploadResults['data']
				);

				if (empty($uploadIDToAttachment)) {
					throw new Exception('No valid upload ID to attachment ID mappings found');
				}

				foreach ($uploadIDToAttachment as $uploadId => $attachmentId) {
					try {
						$this->applyMeta($attachmentId, $attachmentsToUpdate[$uploadId]);
						$updated_count++;
					} catch (Exception $e) {
						$errors[] = "Upload {$uploadId} (Attachment {$attachmentId}): " . $e->getMessage();
					}
				}
			}

			return [
				'success' => $updated_count > 0,
				'result'	=> [
					'updated_count' => $updated_count,
					'mappings' => $uploadIDToAttachment,
					'errors' => $errors,
					'message' => "Applied metadata to {$updated_count} attachment(s)"
				]
			];

		} catch (Exception $e) {
			JVB()->error()->log(
				'[UploadRoutes]:processUploadMeta',
				$e->getMessage(),
				[
					'operation_id' => $operation->id,
					'original_operation_id' => $data['original_operation_id'] ?? 'unknown'
				]
			);

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

	protected function applyMeta(int $attachment_id, array $metadata): void
	{
		// Update alt text
		if (!empty($metadata['image-alt-text'])) {
			update_post_meta($attachment_id, '_wp_attachment_image_alt', sanitize_text_field($metadata['image-alt-text']));
		}
		$postUpdates = [];
		// Update title
		if (!empty($metadata['image-title'])) {
			$postUpdates['post_title'] = $metadata['image-title'];
		}

		// Update caption
		if (!empty($metadata['image-caption'])) {
			$postUpdates['post_excerpt'] = sanitize_textarea_field($metadata['image-caption']);
		}

		if (!empty($postUpdates)) {
			$postUpdates['ID'] = $attachment_id;
			wp_update_post($postUpdates);
		}
	}

	/**
	 * Build mapping from frontend upload IDs to WordPress attachment IDs
	 */
	protected function buildUploadToAttachmentMapping(array $upload_ids, array $results): array
	{
		$mapping = [];

		foreach ($results as $result) {
			if (!isset($result['upload_id']) || !isset($result['attachment_id'])) {
				continue;
			}

			$upload_id = $result['upload_id'];
			$attachment_id = $result['attachment_id'];

			// Validate that this upload_id was requested
			if (in_array($upload_id, $upload_ids)) {
				$mapping[$upload_id] = $attachment_id;
			}
		}

		return $mapping;
	}

	/**
	 * Verify user has access to attachment
	 */
	protected function verifyAttachmentAccess(int $attachment_id, int $user_id): bool
	{
		$attachment = get_post($attachment_id);

		if (!$attachment || $attachment->post_type !== 'attachment') {
			return false;
		}

		// Check if user owns the attachment or has admin privileges
		return ($attachment->post_author == $user_id) || current_user_can('manage_options');
	}

	/**
	 * Get field configuration for upload processing
	 */
	protected function getFieldConfig(array $data): array
	{
		static $config_cache = [];

		$cache_key = md5(json_encode([
			$args['content'] ?? '',
			$args['field_name'] ?? ''
		]));

		if (isset($config_cache[$cache_key])) {
			return $config_cache[$cache_key];
		}

		$config = [
			'allowed_types' => null,
			'max_size' => null,
			'convert' => 'webp',
			'quality' => 80,
			'create_thumbnails' => true,
		];

		// Get field definition from registry if available
		if (!empty($args['content']) && !empty($args['field_name'])) {
			$content_type = $args['content'];
			$field_name = $args['field_name'];

			if (array_key_exists($content_type, JVB_CONTENT)) {
				$content_fields = JVB_CONTENT[$content_type]['fields'] ?? [];
				if (array_key_exists($field_name, $content_fields)) {
					$field_def = $content_fields[$field_name];

					// Extract relevant config from field definition
					$config = array_merge($config, [
						'allowed_types' => $field_def['accepted_types'] ?? null,
						'max_size' => $field_def['max_size'] ?? null,
						'convert' => $field_def['convert'] ?? 'webp',
						'quality' => $field_def['quality'] ?? 80,
						'create_thumbnails' => $field_def['create_thumbnails'] ?? true,
					]);
				}
			}
		}

		$config_cache[$cache_key] = $config;
		return $config;
	}


	/**
	 * Get files info for error logging
	 */
	protected function getFilesInfo(array $files): array
	{
		return [
			'files_count' => is_array($files['name']) ? count($files['name']) : 1,
			'total_size' => is_array($files['size']) ? array_sum($files['size']) : $files['size'],
			'file_types' => is_array($files['type']) ? array_unique($files['type']) : [$files['type']]
		];
	}

	protected function sendResponse(bool $success, array $data = [], string $message = '', string $operation_id = ''): WP_REST_Response
	{
		$response = [
			'success' => $success,
			'message' => $message,
			'data' => $data,
			'timestamp' => current_time('mysql')
		];

		if ($operation_id) {
			$response['operation_id'] = $operation_id;
		}

		return new WP_REST_Response($response);
	}


	public function handleGroupingRequest(WP_REST_Request $request): WP_REST_Response
	{
		try {
			$files = $request->get_file_params();
			$args = $this->buildUploadArgs($request);

			error_log('handleGroupingRequest Files: '.print_r($files, true));
			error_log('handleGroupingRequest args: '.print_r($args, true));

			if (!$args['content'] || !$args['user'] || !$args['posts']) {
				$this->logError('Missing required data');
				return new WP_REST_Response([
					'success'   => false,
					'message'   => 'Missing required data'
				]);
			}

			// Secure files to temporary storage
			$secured_files = $this->secureFiles($files, $args);

			if (empty($secured_files['files'])) {
				return $this->sendResponse(
					false,
					['error_code' => 'no_files'],
					'No valid files to upload'
				);
			}

			// Queue file upload operation
			$operation_type = $this->determineOperationType($secured_files['files'][0] ?? []);
			$chunkSize = 5;
			if ($operation_type === 'video') {
				$chunkSize = 1;
			} elseif ($operation_type === 'document') {
				$chunkSize = 10;
			}

			JVB()->queue()->queueOperation(
				$operation_type,
				$args['user'],
				array_merge(
					['secured_files' => $secured_files['files']],
					$args
				),
				[
					'operation_id' => $args['upload'],
					'chunk_key' => 'secured_files',
					'chunk_size' => $chunkSize
				]
			);

			JVB()->queue()->queueOperation(
				'process_upload_groups',
				$args['user'],
				$args,
				[
					'operation_id' => $args['id'],
					'depends_on' => [$args['upload']],
					'priority' => 'high'
				]
			);

			return $this->sendResponse(
				true,
				[
					'operation_id' => $args['id'],
					'upload_operation_id' => $args['upload'],
					'post_count' => count($args['posts']),
					'file_count' => count($secured_files['files'])
				],
				'Files uploaded and posts queued for creation'
			);

		} catch (Exception $e) {
			JVB()->error()->log(
				'[UploadRoutes]:handleGroupingRequest',
				$e->getMessage(),
				[
					'request_data' => $request->get_params(),
					'trace' => $e->getTraceAsString()
				]
			);

			return $this->sendResponse(
				false,
				['error_code' => 'grouping_failed'],
				'Grouping operation failed: ' . $e->getMessage()
			);
		}
	}

	protected function processUploadGroups(WP_Error|array $result, object $operation, array $data): WP_Error|array
	{
		try {
			$queue = JVB()->queue();
			$all_uploaded_images = [];

			// Get the upload operation ID from dependencies
			$dependencies = json_decode($operation->dependencies, true);

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

			// Collect uploads from all dependency operations
			$uploads = [];
			foreach ($dependencies as $dependency) {
				// Use getOperationValue like ContentRoutes does
				$res = $queue->getOperationValue($dependency, 'result');

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

				// Results are stored at root level, keyed by upload_id
				// Filter to only include actual upload results (arrays with attachment_id)
				foreach ($res as $key => $value) {
					if (is_array($value) && isset($value['attachment_id'])) {
						$uploads[$key] = $value;
					}
				}
			}

			if (empty($uploads)) {
				return [
					'success'   => false,
					'result'    => 'No uploads to process'
				];
			}

			// Build map of upload_id => attachment_id
			foreach ($uploads as $upload_id => $img) {
				$all_uploaded_images[$upload_id] = [
					'upload_id' => $upload_id,
					'attachment_id' => (int)$img['attachment_id']
				];
			}

			$content = jvbCheckBase($data['content']);
			if (Features::forContent($data['content'])->has('is_timeline')) {
				return $this->processTimelineUploads($data, $uploads, $all_uploaded_images, $operation);
			}

			$user = (int)$data['user'];
			$created_posts = [];
			$used_upload_ids = [];

			// Create posts from groups
			foreach ($data['posts'] as $index => $post) {
				$post_title = !empty($post['fields']['post_title'])
					? sanitize_text_field($post['fields']['post_title'])
					: 'New ' . JVB_CONTENT[$data['content']]['singular'] . ' ' . ($index + 1);

				$post_excerpt = !empty($post['fields']['post_excerpt'])
					? sanitize_textarea_field($post['fields']['post_excerpt'])
					: '';

				$args = [
					'post_type' => $content,
					'post_author' => $user,
					'post_status' => 'draft',
					'post_title' => $post_title,
					'post_excerpt' => $post_excerpt,
				];

				$new_post_id = wp_insert_post($args);

				if ($new_post_id && !is_wp_error($new_post_id)) {
					$created_posts[] = $new_post_id;

					// Get featured image upload_id - string, not int!
					$featured_upload_id = $post['fields']['featured'] ?? null;
					$featured_attachment_id = null;
					$gallery_attachment_ids = [];

					// Process all images for this post
					foreach ($post['images'] as $img) {
						$upload_id = $img['upload_id'];
						$used_upload_ids[] = $upload_id;

						if (isset($all_uploaded_images[$upload_id])) {
							$attachment_id = $all_uploaded_images[$upload_id]['attachment_id'];

							if ($upload_id === $featured_upload_id) {
								$featured_attachment_id = $attachment_id;
							} else {
								$gallery_attachment_ids[] = $attachment_id;
							}
						}
					}

					// Set featured image
					if ($featured_attachment_id) {
						set_post_thumbnail($new_post_id, $featured_attachment_id);
					} elseif (!empty($gallery_attachment_ids)) {
						set_post_thumbnail($new_post_id, $gallery_attachment_ids[0]);
						array_shift($gallery_attachment_ids);
					}

					// Set gallery images
					if (!empty($gallery_attachment_ids)) {
						$meta = new MetaManager($new_post_id, 'post');
						$fields = jvbGetFields($content, 'post');

						foreach ($fields as $name => $config) {
							if ($config['type'] === 'gallery') {
								$meta->updateValue($name, implode(',', $gallery_attachment_ids));
								break;
							}
						}
					}
				}
			}

			return [
				'success' => true,
				'result' => [
					'created_posts' => $created_posts,
					'total_posts' => count($created_posts),
					'used_images' => count($used_upload_ids),
					'message' => "Created " . count($created_posts) . " post(s) from uploads"
				]
			];

		} catch (Exception $e) {
			JVB()->error()->log(
				'[UploadRoutes]:processUploadGroups',
				$e->getMessage(),
				[
					'operation_id' => $operation->id,
					'user_id' => $operation->user_id
				]
			);

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

	protected function processTimelineUploads(array $data, array $uploads, array $uploadMap, object $operation):array
	{
		try {
			$user = (int)$data['user'];
			$created_posts = [];
			$used_upload_ids = [];

			$content = jvbCheckBase($data['content']);

			$config = Features::getConfig($content);

			$defaultTitle = 'New '.$config['singular']. ' ';
			foreach ($data['posts'] as $index=> $post) {
				$title = !empty($post['fields']['post_title'])
					? sanitize_text_field($post['fields']['post_title'])
					: $defaultTitle.($index + 1);
				$excerpt = !empty($post['fields']['post_excerpt'])
					? sanitize_textarea_field($post['fields']['post_excerpt'])
					: '';

				$args =[
					'post_type'		=> $content,
					'post_author'	=> $user,
					'post_status'	=> 'draft',
					'post_title'	=> $title,
					'post_excerpt'	=> $excerpt
				];
				$parent = wp_insert_post($args);

				if ($parent && !is_wp_error($parent)) {
					//Get the attachment IDs first
					$childPosts = [];
					$featured = $post['fields']['featured']??null;
					$featuredID = null;
					foreach ($post['images'] as $key => $img) {
						$upload_id = $img['upload_id'];
						$used_upload_ids[] = $upload_id;

						if (isset($uploadMap[$upload_id])) {
							$attachment_id = (int)$uploadMap[$upload_id]['attachment_id'];
							if ($upload_id === $featured) {
								$featuredID = $attachment_id;
							} else {
								$childPosts[] = $attachment_id;
							}
						}
					}
					// Set the featured image for the parent
					if ($featuredID) {
						set_post_thumbnail($parent, $featuredID);
					} elseif (!empty($childPosts)) {
						//use first image if no set featured
						set_post_thumbnail($parent, (int)$childPosts[0]);
						array_shift($childPosts);
					}

					//Create Child Posts
					if (!empty($childPosts)) {
						$args['post_parent'] = $parent;
						$created_posts[$parent] = [];
						foreach ($childPosts as $i => $imgID) {
							$treatment = $i + 1;
							$childTitle = $title.' - Treatment '.$treatment;
							$childDesc = '';
							$args['post_title'] = $childTitle;
							$args['post_excerpt'] = $childDesc;
							$child = wp_insert_post($args);
							if ($child && !is_wp_error($child)) {
								$created_posts[$parent][] = $child;
								set_post_thumbnail($child, $imgID);
							}
						}
					}
				}
			}
			return [
				'success'	=> true,
				'result'	=> [
					'created_posts'	=> $created_posts,
					'used_images'	=> $used_upload_ids
				]
			];
		} catch (Exception $e) {
			JVB()->error()->log(
				'[UploadRoutes]:processTimelineUploads',
				$e->getMessage(),
				[
					'operation_id' => $operation->id,
					'user_id' => $operation->user_id
				]
			);

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

	protected function cleanupUnusedImages(array $unused_images): array
	{
		$cleaned_count = 0;
		$errors = [];

		foreach ($unused_images as $upload_id => $image_data) {
			try {
				$attachment_id = $image_data['attachment_id'];

				// Verify this attachment exists and wasn't already deleted
				if (get_post($attachment_id)) {
					// Delete the attachment and its files
					$deleted = wp_delete_attachment($attachment_id, true);

					if ($deleted) {
						$cleaned_count++;
					} else {
						$errors[] = "Failed to delete attachment {$attachment_id} for upload {$upload_id}";
					}
				} else {
					// Attachment already doesn't exist, count as cleaned
					$cleaned_count++;
				}

			} catch (Exception $e) {
				$errors[] = "Error cleaning up upload {$upload_id}: " . $e->getMessage();
			}
		}

		return [
			'cleaned_count' => $cleaned_count,
			'errors' => $errors
		];
	}

	function getAttachmentID(array $image, array $storedResults): int|false
	{
		foreach ($storedResults as $operationID => $uploads) {
			foreach ($uploads as $upload) {
				// FIX: Handle both case variations
				$stored_upload_id = $upload['upload_id'];
				$search_upload_id = $image['upload_id'];

				if ($stored_upload_id === $search_upload_id) {
					return (int)$upload['attachment_id'];
				}
			}
		}
		return false;
	}

	function extractFeaturedItem(array &$items, string $meta_key = 'featured'): array
	{
		// Handle empty array
		if (empty($items)) {
			return [
				'featured' => null,
				'remaining' => []
			];
		}

		$featured_index = null;

		// First pass: look for featured item
		foreach ($items as $index => $item) {
			if (isset($item['meta'][$meta_key])) {
				$featured_index = $index;
				break;
			}
		}

		// If no featured item found, use first item (index 0)
		if ($featured_index === null) {
			$featured_index = 0;
		}

		// Extract the featured/first item
		$featured = $items[$featured_index];

		// Remove the item from the original array
		unset($items[$featured_index]);

		// Re-index the array to maintain sequential indices
		$remaining = array_values($items);

		return [
			'featured' => $featured,
			'remaining' => $remaining
		];
	}

	protected function mapUploadIdsToAttachments(array $uploadIds, array $uploadedImages): array
	{
		$mappedImages = [];

		foreach ($uploadIds as $uploadId) {
			$imageData = $this->findImageByUploadId($uploadId, $uploadedImages);
			if ($imageData) {
				$mappedImages[] = $imageData;
			}
		}

		return $mappedImages;
	}

	protected function findImageByUploadId(string $uploadId, array $uploadedImages): ?array
	{
		// Handle both flat array and grouped results
		foreach ($uploadedImages as $image) {
			if (is_array($image)) {
				// If it's a grouped result, check each image in the group
				if (isset($image[0]) && is_array($image[0])) {
					foreach ($image as $groupImage) {
						if (isset($groupImage['upload_id']) && $groupImage['upload_id'] === $uploadId) {
							return $groupImage;
						}
					}
				} else {
					// Single image result
					if (isset($image['upload_id']) && $image['upload_id'] === $uploadId) {
						return $image;
					}
				}
			}
		}

		return null;
	}

	protected function determineFeaturedImage(array $group, array $groupImages): ?int
	{
		// Check if user has starred a specific image
		if (!empty($group['featured_upload_id'])) {
			foreach ($groupImages as $image) {
				if (isset($image['upload_id']) && $image['upload_id'] === $group['featured_upload_id']) {
					return $image['attachment_id'];
				}
			}
		}

		// Default to first image
		return !empty($groupImages) ? $groupImages[0]['attachment_id'] : null;
	}

	protected function sanitizeGroupMetadata(array $metadata): array
	{
		$sanitized = [];

		foreach ($metadata as $key => $value) {
			$sanitizedKey = sanitize_key($key);

			if (is_string($value)) {
				$sanitized[$sanitizedKey] = sanitize_text_field($value);
			} elseif (is_array($value)) {
				$sanitized[$sanitizedKey] = array_map('sanitize_text_field', $value);
			} else {
				$sanitized[$sanitizedKey] = $value;
			}
		}

		return $sanitized;
	}

	protected function generatePostTitle(string $content, int $userId): string
	{
		$username = get_user_meta($userId, 'first_name', true) ?: get_user_meta($userId, 'display_name', true);
		$link = get_user_meta($userId, BASE.'link', true);
		$city = function_exists('jvbArtistCity') ? jvbArtistCity($link) : '';

		$title = ucfirst($content);
		if ($username) {
			$title .= ' by ' . $username;
		}
		if ($city) {
			$title .= ' from ' . $city;
		}

		return $title;
	}


	/**
	 * Determine how to save uploaded files based on configuration
	 */
	protected function handleUploadDestination(array $data, array $results): void
	{
		// Determine destination from config
		$destination = $data['destination'] ?? 'meta';

		switch ($destination) {
			case 'meta':
				// Save to post/term/user meta
				$this->saveToMeta($data, $results);
				break;

			case 'post':
				// Create individual posts for each file
				$this->createIndividualPosts($data, $results);
				break;

			case 'post_group':
				// Create posts with grouped files
				$this->createGroupedPosts($data, $results);
				break;

			default:
				// No destination specified - files processed but not attached
				break;
		}
	}

	/**
	 * Infer destination from existing data (backward compatibility)
	 */
	protected function inferDestination(array $data): string
	{
		// If field_name exists → saving to meta
		if (!empty($data['field_name'])) {
			return 'meta';
		}

		// If post_type exists without field_name → creating posts
		if (!empty($data['content'])) {
			return 'post';
		}

		// No destination
		return 'none';
	}

	/**
	 * Save attachment IDs to meta field
	 */
	protected function saveToMeta(array $data, array $results): void
	{
		if (empty($data['field_name'])) {
			return;
		}

		$attachment_ids = array_column($results, 'attachment_id');

		// Determine meta type
		if (!empty($data['post_id'])) {
			$meta = new MetaManager($data['post_id'], 'post');
		} elseif (!empty($data['term_id'])) {
			$meta = new MetaManager($data['term_id'], 'term');
		} elseif (!empty($data['user'])) {
			$link = (int)get_user_meta($data['user'], BASE.'link', true);
			$meta = new MetaManager($link, 'post');
		} else {
			return;
		}

		// Get existing value
		$existing = $meta->getValue($data['field_name']);
		$existing_ids = !empty($existing) ? explode(',', $existing) : [];

		// Merge with new IDs
		$all_ids = array_unique(array_merge($existing_ids, $attachment_ids));

		// Update with comma-separated string
		$meta->updateValue($data['field_name'], implode(',', $all_ids));
	}

	/**
	 * Create individual posts from uploads
	 */
	protected function createIndividualPosts(array $data, array $results): array
	{
		if (empty($data['content'])) {
			return [];
		}

		$created_posts = [];

		foreach ($results as $result) {
			$attachment_id = $result['attachment_id'];
			$attachment = get_post($attachment_id);

			// Create post
			$post_data = [
				'post_type' => jvbCheckBase($data['content']),
				'post_title' => $attachment->post_title,
				'post_status' => 'draft',
				'post_author' => $data['user'] ?? get_current_user_id(),
			];

			$post_id = wp_insert_post($post_data);

			if (!is_wp_error($post_id)) {
				// Set as featured image or attach to gallery
				$this->attachFileToPost($post_id, $attachment_id, $data);

				$created_posts[] = [
					'post_id' => $post_id,
					'attachment_id' => $attachment_id,
				];
			}
		}

		return $created_posts;
	}

	/**
	 * Create posts with grouped uploads
	 */
	protected function createGroupedPosts(array $data, array $results): array
	{
		if (empty($data['content'])) {
			return [];
		}

		$id_map = [];
		foreach ($results as $result) {
			if (isset($result['upload_id'], $result['attachment_id'])) {
				$id_map[$result['upload_id']] = $result['attachment_id'];
			}
		}

		// Groups come from frontend as metadata
		$groups = $data['groups'] ?? [array_column($results, 'attachment_id')];
		$created_posts = [];

		foreach ($groups as $group_index => $group_upload_ids) {
			$group_attachment_ids = array_filter(
				array_map(fn($uid) => $id_map[$uid] ?? null, $group_upload_ids)
			);

			if (empty($group_attachment_ids)) continue;
			// Create post for this group
			$first_attachment = get_post($group_attachment_ids[0]);

			$post_data = [
				'post_type' => jvbCheckBase($data['content']),
				'post_title' => $data['group_titles'][$group_index] ?? $first_attachment->post_title,
				'post_status' => $data['post_status'] ?? 'draft',
				'post_author' => $data['user'] ?? get_current_user_id(),
			];

			$post_id = wp_insert_post($post_data);

			if (!is_wp_error($post_id)) {
				// Attach all files in group
				foreach ($group_attachment_ids as $index => $attachment_id) {
					if ($index === 0) {
						// First is featured
						set_post_thumbnail($post_id, $attachment_id);
					} else {
						// Others go to gallery
						$meta = new MetaManager($post_id, 'post');
						$existing = $meta->getValue('gallery');
						$existing_ids = !empty($existing) ? explode(',', $existing) : [];
						$existing_ids[] = $attachment_id;
						$meta->updateValue('gallery', implode(',', $existing_ids));
					}
				}

				$created_posts[] = [
					'post_id' => $post_id,
					'attachment_ids' => $group_attachment_ids,
				];
			}
		}

		return $created_posts;
	}

	/**
	 * Attach file to post based on file type
	 */
	protected function attachFileToPost(int $post_id, int $attachment_id, array $data): void
	{
		$attachment = get_post($attachment_id);
		$mime_type = $attachment->post_mime_type;

		// Determine file type
		if (str_starts_with($mime_type, 'image/')) {
			// Set as featured image
			set_post_thumbnail($post_id, $attachment_id);
		} elseif (str_starts_with($mime_type, 'video/')) {
			// Save to video field
			$meta = new MetaManager($post_id, 'post');
			$meta->updateValue('video', $attachment_id);
		} else {
			// Documents - save to documents field
			$meta = new MetaManager($post_id, 'post');
			$existing = $meta->getValue('documents');
			$existing_ids = !empty($existing) ? explode(',', $existing) : [];
			$existing_ids[] = $attachment_id;
			$meta->updateValue('documents', implode(',', $existing_ids));
		}
	}
}