<?php
namespace JVBase\rest\routes;

use JVBase\rest\Rest;
use JVBase\managers\CustomTable;
use JVBase\rest\Route;
use WP_REST_Request;
use WP_REST_Response;

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

/**
 * Invitations Route Manager
 *
 * Handles user invitations:
 * - Global invitations (user to user, based on JVB_MEMBERSHIP['can_invite'])
 * - Term invitations (to ownable content taxonomies with 'invitable' flag)
 */
class Invitations extends Rest
{
	protected array $inviteConfig;
	protected CustomTable $table;

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

		// Get invitation configuration
		$this->inviteConfig = JVB()->invitations()->getInviteConfig();
		$this->table = CustomTable::for('invitations');

		// Cache connections
		$this->cache
			->connect('user')
			->connect('taxonomy');
	}

	public function registerRoutes(): void
	{
		Route::for('invitations')
			->get([$this, 'getInvitations'])
			->args([
				'user' => 'int|required',
				'to_term' => 'int',
				'taxonomy' => 'string',
				'status' => 'string|enum:all,pending,accepted,rejected,expired,revoked|default:all',
				'page' => 'int|default:1|min:1'
			])
			->auth('user')
			->rateLimit(20)

			->post([$this, 'createInvitationRequest'])
			->args([
				'user' => 'int|required',
				'action' => 'string|enum:create,revoke,refresh|default:create',
				'invites' => 'array',
				'invitation_id' => 'int'
			])
			->auth('verified')
			->rateLimit(10, 300);
	}

	/**
	 * Get invitations for a user or term
	 */
	public function getInvitations(WP_REST_Request $request): WP_REST_Response
	{
		$userID = $request->get_param('user');
		$termID = $request->get_param('to_term');
		$taxonomy = $request->get_param('taxonomy');

		// Validate user
		if (get_current_user_id() !== $userID) {
			return $this->unauthorized('Invalid user');
		}

		$args = [
			'user' => $userID,
			'to_term' => $termID,
			'taxonomy' => $taxonomy ? jvbNoBase($taxonomy) : null,
			'status' => $request->get_param('status'),
			'page' => $request->get_param('page')
		];

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

		// Get appropriate invitations
		$result = ($args['to_term'] && $args['taxonomy'])
			? $this->getTermInvitations($args)
			: $this->getUserInvitations($args);

		// Cache result
		$this->cache->set($key, $result);

		return $this->success($result);
	}

	/**
	 * Get invitations for a specific term
	 */
	protected function getTermInvitations(array $args): array
	{
		// Check permission
		if (!JVB()->roles()->isManager($args['user'], $args['to_term'])) {
			return $this->forbidden('You cannot view invitations for this ' . $args['taxonomy'])->get_data();
		}

		$perPage = 20;
		$offset = ($args['page'] - 1) * $perPage;

		// Build query
		$where = ['to_' . $args['taxonomy'] => $args['to_term']];
		if ($args['status'] !== 'all') {
			$where['status'] = $args['status'];
		}

		// Fluent CustomTable usage
		$total = $this->table
			->where($where)
			->countResults();

		$invitations = $this->table
			->where($where)
			->orderBy('created_at')
			->limit($perPage, $offset)
			->getResults();

		return [
			'invitations' => array_map([$this, 'formatInvitation'], $invitations),
			'total' => $total,
			'pages' => ceil($total / $perPage),
			'page' => $args['page'],
			'per_page' => $perPage
		];
	}

	/**
	 * Get invitations sent by a user
	 */
	protected function getUserInvitations(array $args): array
	{
		$perPage = 20;
		$offset = ($args['page'] - 1) * $perPage;

		// Use raw query for JSON search
		$query = "SELECT * FROM {$this->table->getFullTableName()}
                  WHERE JSON_SEARCH(inviters, 'one', %s, NULL, '$[*].user_id') IS NOT NULL";
		$params = [$args['user']];

		if ($args['status'] !== 'all') {
			$query .= " AND status = %s";
			$params[] = $args['status'];
		}

		$query .= " ORDER BY created_at DESC LIMIT %d OFFSET %d";
		$params = array_merge($params, [$perPage, $offset]);

		$invitations = $this->table->queryResults($query, $params);

		// Get count
		$countQuery = str_replace('SELECT *', 'SELECT COUNT(*)',
			substr($query, 0, strrpos($query, 'ORDER BY')));
		$countParams = array_slice($params, 0, -2);
		$total = (int) $this->table->queryVar($countQuery, $countParams);

		return [
			'invitations' => array_map([$this, 'formatInvitation'], $invitations),
			'total' => $total,
			'pages' => ceil($total / $perPage),
			'page' => $args['page'],
			'per_page' => $perPage
		];
	}

	/**
	 * Create invitation request - queues invitations for processing
	 */
	public function createInvitationRequest(WP_REST_Request $request): WP_REST_Response
	{
		$userID = $request->get_param('user');
		$action = $request->get_param('action');

		// Validate user
		if (get_current_user_id() !== $userID) {
			return $this->unauthorized('Invalid user');
		}

		// Handle actions
		return match($action) {
			'revoke' => $this->revokeInvite($userID, $request->get_params()),
			'refresh' => $this->resendInvite($userID, $request->get_params()),
			default => $this->queueInvitations($userID, $request->get_param('invites'))
		};
	}

	protected function queueInvitations(int $userID, array $invites): WP_REST_Response
	{
		if (empty($invites)) {
			return $this->error('No invitations provided');
		}

		// Validate invitations
		$validated = $this->validateInvitations($userID, $invites);

		if (empty($validated)) {
			return $this->error('No valid invitations to send');
		}

		// Queue using fluent interface
		$op = JVB()->queue()->add(
			'invitation_create',
			$userID,
			['invitations' => $validated],
			[
				'priority' => 'high',
				'chunk_key' => 'invitations',
				'chunk_size' => 20
			]
		);
		return $this->queued($op['operation_id']);
	}

	/**
	 * Validate and sanitize invitation data
	 */
	protected function validateInvitations(int $userID, array $invites): array
	{
		return JVB()->invitations()->validateInvitations($userID, $invites);
	}


	/**
	 * Revoke an invitation
	 */
	protected function revokeInvite(int $userID, array $data): WP_REST_Response
	{
		$invitationID = (int) ($data['invitation_id'] ?? 0);

		if (!$invitationID) {
			return $this->error('Invitation ID required');
		}

		$op = JVB()->queue()->add(
			'invitation_revoke',
			$userID,
			['invitation_id' => $invitationID],
			['priority' => 'high']
		);

		return $this->queued($op['operation_id']);
	}

	/**
	 * Resend an invitation
	 */
	protected function resendInvite(int $userID, array $data): WP_REST_Response
	{
		$invitationID = (int) ($data['invitation_id'] ?? 0);

		if (!$invitationID) {
			return $this->error('Invitation ID required');
		}

		$op = JVB()->queue()->add(
			'invitation_resend',
			$userID,
			['invitation_id' => $invitationID],
			['priority' => 'high']
		);

		if (is_wp_error($op)) {
			return $this->error($op->get_error_message());
		}
		return $this->queued($op['operation_id']);
	}


	/**
	 * Format invitation for API response
	 */
	protected function formatInvitation(object $invitation): array
	{
		$inviters = json_decode($invitation->inviters ?? '[]', true) ?: [];

		$formatted = [
			'id' => (int) $invitation->id,
			'name' => $invitation->name,
			'email' => $invitation->email,
			'invited_role' => $invitation->invited_role,
			'status' => $invitation->status,
			'expires_at' => $invitation->expires_at,
			'accepted_at' => $invitation->accepted_at ?? null,
			'created_at' => $invitation->created_at,
			'inviters' => array_map(fn($inviter) => [
				'id' => (int) $inviter['user_id'],
				'name' => jvbGetUsername($inviter['user_id']),
				'invited_at' => $inviter['invited_at']
			], $inviters)
		];

		// Add term information if present
		foreach (JVB()->roles()->getInvitableTaxonomies() as $taxonomy) {
			$column = 'to_' . $taxonomy;
			if (isset($invitation->$column) && $invitation->$column) {
				$termID = (int) $invitation->$column;
				$term = get_term($termID, BASE . $taxonomy);

				if ($term && !is_wp_error($term)) {
					$formatted['term'] = [
						'id' => $termID,
						'name' => $term->name,
						'taxonomy' => $taxonomy
					];
					break; // Only show first term
				}
			}
		}

		return $formatted;
	}

}