<?php
namespace JVBase\rest\routes;

use Exception;
use JVBase\JVB;
use JVBase\managers\Cache;
use JVBase\rest\RestRouteManager;
use WP_REST_Request;
use WP_REST_Response;
use DateTime;
use DateTimeZone;

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

class QueueRoutes extends RestRouteManager
{
	public function __construct()
	{
		$this->cache_name = 'queue';
		$this->cache_ttl = 300;
		parent::__construct();

		if (JVB_TESTING) {
			$this->cache->flush();
		}
	}

	/**
	 * Registers queue routes
	 * @return void
	 */
	public function registerRoutes():void
	{
		register_rest_route($this->namespace, '/queue', [
			[
				'methods'   => 'GET',
				'callback'  => [$this, 'getQueue'],
				'permission_callback'   => [$this, 'checkPermission'],
				'args'  => [
					'status'    => [
						'type'  => 'string',
						'enum'  => ['all', 'queued', 'pending', 'processing', 'completed', 'failed', 'failed_permanent'],
						'default' => 'all'
					],
					'ids'    => [
						'required'  => false,
						'type'  => 'string',
						'description' => 'Comma-separated list of operation IDs'
					],
					'limit' => [
						'type' => 'integer',
						'default' => 50,
						'minimum' => 1,
						'maximum' => 100
					]
				]
			],
			[
				'methods'   => 'POST',
				'callback'  => [$this, 'handleAction'],
				'permission_callback'   => [$this, 'checkPermission'],
				'args' => [
					'ids'    => [
						'required'  => true,
						'type'  => 'array',
						'items' => [
							'type' => 'string'
						],
						'description' => 'Array of operation IDs (single or multiple)'
					],
					'action'    => [
						'required'  => true,
						'type'  => 'string',
						'enum'  => ['dismiss', 'retry', 'cancel'],
						'description' => 'Action to perform on the operations'
					]
				]
			]
		]);
	}

	/**
	 * Get queue operations with optional filtering
	 *
	 * @param WP_REST_Request $request
	 * @return WP_REST_Response
	 */
	public function getQueue(WP_REST_Request $request): WP_REST_Response
	{
		$user_id = $request->get_param('user');
		$status = sanitize_text_field($request->get_param('status'));
		$ids = $request->get_param('ids');
		$limit = intval($request->get_param('limit'));
		// Use base class user-specific header checking
		$key = $this->cache->generateKey(['user'=> $user_id, 'status'=> $status, 'ids'=> $ids, 'limit'=> $limit]);
		$cache_check = $this->checkHeaders($request, $key);
		if ($cache_check) {
			return $cache_check;
		}

		// Build filters for getUserOperations
		$filters = [
			'not_dismissed' => true,
			'limit' => $limit ?: 50,
		];

		if ($status && $status !== 'all') {
			$filters['state'] = $status;
		}

		if (!empty($ids)) {
			$filters['ids'] = array_map('trim', explode(',', $ids));
		}

		// Get operations via Queue
		$operations = JVB()->queue()->getUserOperations($user_id, $filters);

		// Format operations for API response
		$formatted = array_map([$this, 'formatOperationFromObject'], $operations);

		$response = new WP_REST_Response([
			'items' => $formatted,
			'total' => count($formatted),
			'timestamp' => date('c'),
			'has_more' => count($formatted) === ($limit ?: 50),
			'queue_stats' => $this->getQueueStats($user_id),
			'server_time' => date('c')
		]);

		return $this->addCacheHeaders($response);
	}


	/**
	 * Get queue statistics for user
	 */
	protected function getQueueStats(int $user_id): array
	{
		$stats = JVB()->queue()->getUserStats($user_id);

		// Add frontend-only statuses that don't exist in backend
		return array_merge([
			'queued' => 0,
			'localProcessing' => 0,
			'uploading' => 0,
		], $stats);
	}

	/**
	 * Map backend state/outcome to frontend status
	 * Backend uses: state (pending, scheduled, processing, completed) + outcome (pending, success, partial, failed, failed_permanent)
	 * Frontend expects: queued, pending, processing, completed, failed, failed_permanent
	 */
	protected function mapStateToStatus(string $state, ?string $outcome): string
	{
		// If completed, check outcome for failure states
		if ($state === 'completed') {
			return match($outcome) {
				'failed' => 'failed',
				'failed_permanent' => 'failed_permanent',
				'partial' => 'completed', // or could be 'partial' if JS supports it
				default => 'completed'
			};
		}

		// Map other states directly
		return match($state) {
			'scheduled' => 'pending',
			default => $state
		};
	}

	/**
	 * Format Operation object for API response
	 */
	protected function formatOperationFromObject(\JVBase\managers\queue\Operation $op): array
	{
		$formatted = [
			'id' => $op->id,
			'type' => $op->type,
			'status' => $this->mapStateToStatus($op->state, $op->outcome),
			'progress_count' => $op->processedItems,
			'count' => $op->totalItems,
			'retries' => $op->retries,
			'data' => $op->requestData,
			'result' => $op->result ?? [],
		];

		$formatted['created_at'] = $this->formatTimestamp($op->scheduledAt);
		$formatted['updated_at'] = $this->formatTimestamp($op->completedAt ?? $op->startedAt ?? $op->scheduledAt);

		if ($op->state === 'completed' && $op->completedAt) {
			$formatted['completed_at'] = $this->formatTimestamp($op->completedAt);
		}

		if ($op->errorMessage) {
			$formatted['error_message'] = $op->errorMessage;
		}

		if ($formatted['count'] > 0) {
			$formatted['progress_percentage'] = round(
				($formatted['progress_count'] / $formatted['count']) * 100
			);
		}

		$formatted['title'] = $this->getOperationTitle($op->type, $op->requestData);
		$formatted['user_dismissed'] = $op->userDismissed;

		return $formatted;
	}

	/**
	 * Get human-readable operation title
	 */
	protected function getOperationTitle(string $type, array $data): string
	{
		$titles = [
			'attach_upload_to_content' => 'Attaching Upload',
			'content_update' => 'Updating Content',
			'user_settings' => 'Updating Settings',
			'bulk_operation' => 'Bulk Operation',
			'image_processing' => 'Processing Images',
			'notification_send' => 'Sending Notification',
			'cache_clear' => 'Clearing Cache',
			'data_export' => 'Exporting Data',
			'data_import' => 'Importing Data'
		];

		$base_title = $titles[$type] ?? ucwords(str_replace('_', ' ', $type));

		if ($type === 'attach_upload_to_content' && $data['mode'] === 'selection') {
			$base_title .= '; Waiting on your Groupings to proceed...';
		}
		// Add context if available
		if (!empty($data['content'])) {
			$content_type = ucfirst($data['content']);
			$base_title = str_replace('Content', $content_type, $base_title);
		}

		return $base_title;
	}

	/**
	 * Update operation status (dismiss or retry)
	 *
	 * @param WP_REST_Request $request
	 * @return WP_REST_Response
	 */
	public function handleAction(WP_REST_Request $request): WP_REST_Response
	{
		$data = $request->get_json_params();
		$ids = $data['ids'] ?? [];
		$action = $data['action'] ?? '';
		$user_id = (int)$data['user'];

		// Validate input
		if (empty($ids) || !is_array($ids)) {
			return new WP_REST_Response([
				'success' => false,
				'message' => 'Missing or invalid operation IDs'
			], 400);
		}

		if (!in_array($action, ['dismiss', 'retry', 'cancel'])) {
			return new WP_REST_Response([
				'success' => false,
				'message' => 'Invalid action. Must be: dismiss, retry, or cancel'
			], 400);
		}

		// Get operations via Queue - verifies ownership
		$operations = JVB()->queue()->getUserOperations($user_id, [
			'ids' => $ids,
			'limit' => count($ids),
		]);

		if (empty($operations)) {
			return new WP_REST_Response([
				'success' => false,
				'message' => 'No valid operations found'
			], 404);
		}

		$result = $this->processQueueAction($action, $operations, $user_id);

		if ($result['success']) {
			Cache::touch($user_id);
		}

		return new WP_REST_Response($result);
	}

	protected function processQueueAction(string $action, array $operations, int $user_id): array
	{
		$queue = JVB()->queue();
		$processed_count = 0;
		$errors = [];
		$valid_ids = [];

		foreach ($operations as $op) {
			try {
				$result = match($action) {
					'dismiss' => $queue->dismiss($op->id),
					'retry'   => $queue->retry($op->id, $user_id),
					'cancel'  => $queue->cancel($op->id, $user_id),
					default   => false,
				};

				if ($result) {
					$processed_count++;
					$valid_ids[] = $op->id;
				} else {
					// Only add errors for meaningful failures
					if ($action === 'retry' && ($op->state !== 'completed' || !in_array($op->outcome, ['failed', 'failed_permanent']))) {
						$errors[] = "Operation {$op->id} cannot be retried (state: {$op->state}, outcome: {$op->outcome})";
					}
					// Silently skip cancel failures (can't cancel processing/completed)
				}
			} catch (Exception $e) {
				$errors[] = "Error processing operation {$op->id}: " . $e->getMessage();
			}
		}

		$message = $this->getActionMessage($action, $processed_count);
		if (!empty($errors)) {
			$message .= ". Errors: " . implode(', ', $errors);
		}

		return [
			'success' => $processed_count > 0,
			'action' => $action,
			'processed_count' => $processed_count,
			'total_requested' => count($operations),
			'processed_ids' => $valid_ids,
			'errors' => $errors,
			'message' => $message
		];
	}

	/**
	 * Get user-friendly message for action results
	 */
	protected function getActionMessage(string $action, int $count): string
	{
		if ($count === 0) {
			return "No operations were {$action}ed";
		}

		$past_tense = [
			'dismiss' => 'dismissed',
			'retry' => 'retried',
			'cancel' => 'cancelled'
		];

		return "{$count} operation" . ($count === 1 ? '' : 's') . " {$past_tense[$action]}";
	}

	public function getOperationErrors(WP_REST_Request $request): WP_REST_Response
	{
		$user_id = get_current_user_id();

		$operations = JVB()->queue()->getUserOperations($user_id, [
			'state' => 'completed',
			'outcome' => ['failed', 'failed_permanent', 'partial'],
			'has_errors' => true,
			'order_by' => 'updated_at DESC',
			'limit' => 20,
		]);

		$formatted = array_map(function($op) {
			return [
				'id' => $op->id,
				'type' => $op->type,
				'error_message' => $op->errorMessage,
				'failed_items' => $op->failedItems ?? [],
				'retries' => $op->retries,
				'created_at' => $op->scheduledAt,
				'updated_at' => $op->completedAt,
				'error_details' => $this->parseErrorMessage($op->errorMessage ?? ''),
			];
		}, $operations);

		return new WP_REST_Response([
			'errors' => $formatted,
			'total' => count($formatted)
		]);
	}
	protected function parseErrorMessage(string $error_message): array
	{
		if (str_contains($error_message, ' | ')) {
			$parts = explode(' | ', $error_message);
			return [
				'original_error' => $parts[0] ?? '',
				'cleanup_reason' => $parts[1] ?? ''
			];
		}

		return [
			'original_error' => $error_message,
			'cleanup_reason' => null
		];
	}
}