<?php
namespace JVBase\rest\routes;

use JVBase\JVB;
use JVBase\rest\Rest;
use JVBase\managers\CustomTable;
use WP_REST_Request;
use WP_REST_Response;
use WP_Error;

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

/**
 * Response Routes
 *
 * Handles threaded responses/comments for news items
 */
class ResponseRoutes extends Rest
{
	protected int $perPage = 20;
	protected CustomTable $table;
	protected CustomTable $karmaTable;

	public function __construct()
	{
		$this->cacheName = 'responses';
		$this->cacheTtl = 1800; // 30 minutes
		parent::__construct();

		$this->table = CustomTable::for('responses');
		$this->karmaTable = CustomTable::for('karma_response');

		add_filter(BASE.'handle_bulk_operation', [$this, 'processOperation'], 10, 3);
		add_action('deleted_user', [$this, 'handleUserDeletion'], 10, 1);
	}

	public function registerRoutes(): void
	{
		register_rest_route($this->namespace, '/response', [
			[
				'methods'   => 'GET',
				'callback'  => [$this, 'getResponses'],
				'permission_callback' => 'is_user_logged_in'
			],
			[
				'methods'   => 'POST',
				'callback'  => [$this, 'handleResponseActions'],
				'permission_callback' => 'is_user_logged_in'
			]
		]);
	}

	/**
	 * Get responses for an item
	 */
	public function getResponses(WP_REST_Request $request): WP_REST_Response
	{
		$item_id = (int) $request->get_param('item_id');

		if (!$item_id) {
			return $this->error('Missing item ID', 'missing_item_id');
		}

		// Build query args
		$args = $this->buildQueryArgs($request);
		$cacheKey = $this->cache->generateKey(array_merge(['item_id' => $item_id], $args));

		// Check headers for 304 Not Modified
		$headerCheck = $this->checkHeaders($request, $cacheKey);
		if ($headerCheck) {
			return $headerCheck;
		}

		// Check cache
		$cached = $this->cache->get($cacheKey);
		if ($cached) {
			return $this->success($cached);
		}

		// Get responses
		$responses = $this->getItemResponse($item_id, $args);

		if (is_wp_error($responses)) {
			return $this->notFound($responses->get_error_message());
		}

		// Cache and return
		$this->cache->set($cacheKey, $responses);
		return $this->success($responses);
	}

	/**
	 * Handle response actions (create/update/delete)
	 */
	public function handleResponseActions(WP_REST_Request $request): WP_REST_Response
	{
		$data = $request->get_params();
		$user_id = (int) ($data['user'] ?? 0);

		if (!$this->userCheck($user_id)) {
			return $this->unauthorized('User verification failed');
		}

		$operation_id = $data['id'] ?? uniqid('response_');
		$action = sanitize_text_field($data['action'] ?? '');

		if (!in_array($action, ['create', 'delete', 'update'])) {
			return $this->error('Invalid action', 'invalid_action');
		}

		// Validate required fields for create
		if ($action === 'create') {
			if (!isset($data['item_id'], $data['response'], $data['content'])) {
				return $this->error('Missing required fields', 'missing_fields');
			}
		}

		// Prepare data for queue
		$queue_data = match($action) {
			'create' => [
				'item_id' => (int) $data['item_id'],
				'parent_id' => isset($data['parent_id']) ? (int) $data['parent_id'] : null,
				'response' => wp_kses_post($data['response']),
				'content' => sanitize_text_field($data['content'])
			],
			'update' => [
				'response_id' => (int) $data['response_id'],
				'response' => isset($data['response']) ? wp_kses_post($data['response']) : null,
				'status' => isset($data['status']) && in_array($data['status'], ['published', 'hidden', 'flagged'])
					? $data['status']
					: null
			],
			'delete' => [
				'response_id' => (int) $data['response_id']
			]
		};

		// Queue the operation
		JVB()->queue()->queueOperation(
			$action . '_response',
			$user_id,
			$queue_data,
			[
				'operation_id' => 'u' . $user_id . '_' . $operation_id,
				'priority' => 'high'
			]
		);

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

	/**
	 * Get responses with karma calculations
	 */
	protected function getItemResponse(int $item_id, array $args = []): array|WP_Error
	{
		$defaults = [
			'page' => 1,
			'per_page' => $this->perPage,
			'orderby' => 'created_at',
			'order' => 'DESC',
			'parent_id' => null
		];

		$args = wp_parse_args($args, $defaults);

		// Verify post exists
		$post = get_post($item_id);
		if (!$post) {
			return new WP_Error('not_found', 'Item not found');
		}

		// Build query with karma calculations
		$query = "
            SELECT r.*,
                COALESCE((SELECT COUNT(*) FROM {$this->table->getFullTableName()} WHERE parent_id = r.id), 0) as reply_count,
                COALESCE((SELECT COUNT(*) FROM {$this->karmaTable->getFullTableName()} WHERE item_id = r.id AND vote = 'up'), 0) as upvotes,
                COALESCE((SELECT COUNT(*) FROM {$this->karmaTable->getFullTableName()} WHERE item_id = r.id AND vote = 'down'), 0) as downvotes
            FROM {$this->table->getFullTableName()} r
            WHERE r.item_id = %d
        ";

		$query_args = [$item_id];

		// Filter by parent_id
		if (isset($args['parent_id'])) {
			$query .= " AND r.parent_id " . ($args['parent_id'] === null ? "IS NULL" : "= %d");
			if ($args['parent_id'] !== null) {
				$query_args[] = $args['parent_id'];
			}
		}

		// Get total count for pagination
		$count_query = str_replace(
			['SELECT r.*,', 'COALESCE((SELECT COUNT(*) FROM', 'as reply_count,', 'as upvotes,', 'as downvotes'],
			['SELECT COUNT(*)', '', '', '', ''],
			$query
		);
		$count_query = preg_replace('/COALESCE\([^)]+\)[^,]*,?/', '', $count_query);
		$total_items = (int) $this->table->queryVar($count_query, $query_args);

		// Add ordering
		$order_column = in_array($args['orderby'], ['created_at', 'updated_at'])
			? "r.{$args['orderby']}"
			: $args['orderby'];

		$query .= " ORDER BY {$order_column} {$args['order']}";

		// Add pagination
		$query .= " LIMIT %d OFFSET %d";
		$query_args[] = $args['per_page'];
		$query_args[] = ($args['page'] - 1) * $args['per_page'];

		// Get responses
		$responses = $this->table->queryResults($query, $query_args);

		// Format responses
		$items = array_map([$this, 'formatItem'], $responses);

		return [
			'items' => $items,
			'has_more' => $args['page'] < ceil($total_items / $args['per_page']),
			'total_items' => $total_items,
			'total_pages' => (int) ceil($total_items / $args['per_page'])
		];
	}

	/**
	 * Process queue operations
	 */
	public function processOperation(WP_Error|array $result, object $operation, array $data): WP_Error|array
	{
		if (!in_array($operation->type, ['create_response', 'update_response', 'delete_response'])) {
			return $result;
		}

		return match($operation->type) {
			'create_response' => $this->createResponse($operation, $data),
			'update_response' => $this->updateResponse($data),
			'delete_response' => $this->deleteResponse($data),
			default => $result
		};
	}

	/**
	 * Create a new response
	 */
	protected function createResponse(object $operation, array $data): array
	{
		$response_id = $this->table->insert([
			'item_id' => $data['item_id'],
			'content' => $data['content'],
			'user_id' => $operation->user_id,
			'parent_id' => $data['parent_id'],
			'response' => $data['response'],
			'status' => 'published'
		]);

		if (!$response_id) {
			$this->logError('Failed to insert response', [
				'data' => $data,
				'error' => $this->table->getLastError()
			]);

			return ['success' => false, 'result' => 'Failed to create response'];
		}

		// Send notifications
		$this->sendNotifications($data['item_id'], $data['parent_id'], $response_id, $operation->user_id);

		// Clear cache
		$this->cache->flush();

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

	/**
	 * Update a response
	 */
	protected function updateResponse(array $data): array
	{
		$update_data = [];

		if (isset($data['response'])) {
			$update_data['response'] = $data['response'];
			$update_data['updated_at'] = current_time('mysql');
		}

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

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

		$updated = $this->table->update(
			$update_data,
			['id' => $data['response_id']]
		);

		if ($updated === false) {
			$this->logError('Failed to update response', [
				'data' => $data,
				'error' => $this->table->getLastError()
			]);

			return ['success' => false, 'result' => 'Failed to update response'];
		}

		$this->cache->flush();
		return ['success' => true, 'result' => $updated];
	}

	/**
	 * Delete a response (or mark as deleted if it has replies)
	 */
	protected function deleteResponse(array $data): array
	{
		$response = $this->table->get(['id' => $data['response_id']]);

		if (!$response) {
			return ['success' => false, 'result' => 'Response not found'];
		}

		// Check if it has replies
		$has_replies = $this->table->where(['parent_id' => $data['response_id']])->countResults() > 0;

		if ($has_replies) {
			// Don't delete, just mark as deleted
			$updated = $this->table->update(
				[
					'response' => '[ deleted ]',
					'status' => 'deleted',
					'updated_at' => current_time('mysql')
				],
				['id' => $data['response_id']]
			);

			$this->cache->flush();
			return ['success' => true, 'result' => $updated];
		}

		// No replies, safe to delete
		$deleted = $this->table->delete(['id' => $data['response_id']]);

		if ($deleted === false) {
			$this->logError('Failed to delete response', [
				'data' => $data,
				'error' => $this->table->getLastError()
			]);

			return ['success' => false, 'result' => 'Failed to delete response'];
		}

		$this->cache->flush();
		return ['success' => true, 'result' => $deleted];
	}

	/**
	 * Send notifications for new responses
	 */
	protected function sendNotifications(int $item_id, ?int $parent_id, int $response_id, int $user_id): void
	{
		// Notify post author
		$post = get_post($item_id);
		if ($post && $post->post_author != $user_id) {
			JVB()->notification()->addNotification(
				$post->post_author,
				'new_response',
				[
					'message' => 'Someone responded to your post',
					'item_id' => $item_id,
					'response_id' => $response_id
				]
			);
		}

		// Notify parent response author if this is a reply
		if ($parent_id) {
			$parent = $this->table->get(['id' => $parent_id]);

			if ($parent && $parent->user_id != $user_id) {
				JVB()->notification()->addNotification(
					$parent->user_id,
					'response_reply',
					[
						'message' => 'Someone replied to your response',
						'item_id' => $item_id,
						'response_id' => $response_id
					]
				);
			}
		}
	}

	/**
	 * Build query arguments from request
	 */
	protected function buildQueryArgs(WP_REST_Request $request): array
	{
		$page = max(1, (int) ($request->get_param('page') ?? 1));
		$per_page = min(100, max(1, (int) ($request->get_param('per_page') ?? $this->perPage)));

		$args = [
			'page' => $page,
			'per_page' => $per_page,
			'orderby' => 'created_at',
			'order' => 'DESC'
		];

		// Parent filter (null = top-level only)
		if ($request->has_param('parent_id')) {
			$parent_id = $request->get_param('parent_id');
			$args['parent_id'] = $parent_id === '0' ? null : (int) $parent_id;
		}

		// Ordering
		if ($request->has_param('orderby')) {
			$orderby = $request->get_param('orderby');
			$valid = ['created_at', 'updated_at', 'upvotes', 'downvotes'];

			if (in_array($orderby, $valid)) {
				$args['orderby'] = $orderby;
			}
		}

		if ($request->has_param('order')) {
			$order = strtoupper($request->get_param('order'));
			if (in_array($order, ['ASC', 'DESC'])) {
				$args['order'] = $order;
			}
		}

		return $args;
	}

	/**
	 * Get child responses recursively
	 */
	protected function getChildren(int $item_id, int $parent_id): array
	{
		return $this->getItemResponse($item_id, ['parent_id' => $parent_id]);
	}

	/**
	 * Format response for API output
	 */
	protected function formatItem(object $response): array
	{
		$formatted = [
			'id' => (int) $response->id,
			'item_id' => (int) $response->item_id,
			'parent_id' => $response->parent_id ? (int) $response->parent_id : null,
			'response' => $response->response,
			'status' => $response->status,
			'created_at' => $response->created_at,
			'updated_at' => $response->updated_at,
			'children' => $this->getChildren($response->item_id, $response->id),
			'upvotes' => (int) ($response->upvotes ?? 0),
			'downvotes' => (int) ($response->downvotes ?? 0),
			'karma' => (int) ($response->upvotes ?? 0) - (int) ($response->downvotes ?? 0),
			'reply_count' => (int) ($response->reply_count ?? 0)
		];

		// Handle deleted users
		if ($response->is_user_deleted) {
			$formatted['user'] = [
				'id' => null,
				'name' => '[deleted user]',
				'is_deleted' => true
			];
		} else {
			// Add artist info
			$artist = jvbContentFromUser($response->user_id);
			if (!empty($artist)) {
				$formatted['artist'] = [
					'name' => $artist['name'],
					'url' => $artist['url'],
					'shop' => $artist['shop'] ?? null
				];
			}
		}

		return $formatted;
	}

	/**
	 * Handle user deletion by anonymizing responses
	 */
	public function handleUserDeletion(int $user_id): void
	{
		$updated = $this->table->update(
			[
				'is_user_deleted' => 1,
				'updated_at' => current_time('mysql')
			],
			['user_id' => $user_id]
		);

		$this->logError(
			'Anonymized responses for deleted user',
			['user_id' => $user_id, 'count' => $updated],
			'info'
		);

		$this->cache->flush();
	}
}