mail/lib/Controllers/CompositionController.php

<?php

declare(strict_types=1);

namespace KTXM\Mail\Controllers;

use InvalidArgumentException;
use KTXC\Http\Response\JsonResponse;
use KTXC\Http\Response\Response;
use KTXC\Context\IdentityContextInterface;
use KTXC\Context\TenantContextInterface;
use KTXF\Controller\ControllerAbstract;
use KTXF\Routing\Attributes\AuthenticatedRoute;
use KTXM\Mail\CompositionManager;
use Psr\Log\LoggerInterface;
use Throwable;

final class CompositionController extends ControllerAbstract {

    public function __construct(
        private readonly TenantContextInterface $tenantContext,
        private readonly IdentityContextInterface $identityContext,
        private readonly CompositionManager $compositionManager,
        private readonly LoggerInterface $logger,
    ) {}

    #[AuthenticatedRoute('/compose/v1', name: 'mail.compose.v1', methods: ['POST'])]
    public function index(
        int $version,
        string $transaction,
        string|null $operation = null,
        array|null $data = null,
    ): Response {
        $tenantId = $this->tenantContext->identifier();
        $userId = $this->identityContext->identifier();

        try {
            if ($operation === null) {
                throw new InvalidArgumentException('Operation must be provided');
            }

            $result = match ($operation) {
                'stage' => $this->stage($tenantId, $userId, $data),
                'patch' => $this->patch($tenantId, $userId, $data),
                'discard' => $this->discard($tenantId, $userId, $data),
                'send' => $this->send($tenantId, $userId, $data),
                'attachment.add' => $this->attachmentAdd($tenantId, $userId, $data),
                'attachment.remove' => $this->attachmentRemove($tenantId, $userId, $data),
                default => throw new InvalidArgumentException('Invalid operation: ' . $operation),
            };

            return new JsonResponse([
                'version' => $version,
                'transaction' => $transaction,
                'operation' => $operation,
                'status' => 'success',
                'data' => $result,
            ], JsonResponse::HTTP_OK);
        } catch (Throwable $throwable) {
            $this->logger->error('Mail draft request failed', ['exception' => $throwable]);

            return new JsonResponse([
                'version' => $version,
                'transaction' => $transaction,
                'operation' => $operation,
                'status' => 'error',
                'data' => [
                    'code' => $throwable->getCode(),
                    'message' => $throwable->getMessage(),
                ],
            ], JsonResponse::HTTP_INTERNAL_SERVER_ERROR);
        }
    }

    private function stage(string $tenantId, string $userId, array $data): array {
        if (!isset($data['identifier']) || !is_string($data['identifier']) || $data['identifier'] === '') {
            throw new InvalidArgumentException('Invalid parameter: identifier must be a non-empty string');
        }
        if (!isset($data['action']) || !is_string($data['action'])) {
            throw new InvalidArgumentException('Invalid parameter: action must be a string');
        }
        if (!in_array($data['action'], ['fresh', 'reply', 'forward'], true)) {
            throw new InvalidArgumentException('Invalid parameter: action must be one of fresh, reply, forward');
        }
        if (!isset($data['sender']) || !is_array($data['sender'])) {
            throw new InvalidArgumentException('Invalid parameter: sender must be an array');
        }
        if (!isset($data['message']) || !is_array($data['message'])) {
            throw new InvalidArgumentException('Invalid parameter: message must be an array');
        }
        if (($data['action'] === 'reply' || $data['action'] === 'forward') && (!isset($data['source']) || !is_string($data['source']) || $data['source'] === '')) {
            throw new InvalidArgumentException('Invalid parameter: source must be a non-empty string for reply or forward action');
        }

        return $this->compositionManager->stage($tenantId, $userId, $data['identifier'], $data['action'], $data['sender'], $data['message'], $data['source'] ?? null);
    }

    private function patch(string $tenantId, string $userId, array $data): array {
        if (!isset($data['identifier']) || !is_string($data['identifier']) || $data['identifier'] === '') {
            throw new InvalidArgumentException('Invalid parameter: identifier must be a non-empty string');
        }
        if (!isset($data['sender']) || !is_array($data['sender'])) {
            throw new InvalidArgumentException('Invalid parameter: sender must be an array');
        }
        if (!isset($data['message']) || !is_array($data['message'])) {
            throw new InvalidArgumentException('Invalid parameter: message must be an array');
        }

        return $this->compositionManager->patch($tenantId, $userId, $data['identifier'], $data);
    }
    private function discard(string $tenantId, string $userId, array $data): array {
        if (!isset($data['identifier']) || !is_string($data['identifier']) || $data['identifier'] === '') {
            throw new InvalidArgumentException('Invalid parameter: identifier must be a non-empty string');
        }

        return $this->compositionManager->discard($tenantId, $userId, $data['identifier']);
    }

    private function send(string $tenantId, string $userId, array $data): array {
        if (!isset($data['identifier']) || !is_string($data['identifier']) || $data['identifier'] === '') {
            throw new InvalidArgumentException('Invalid parameter: identifier must be a non-empty string');
        }
        if (!isset($data['sender']) || !is_array($data['sender'])) {
            throw new InvalidArgumentException('Invalid parameter: sender must be an array');
        }
        if (!isset($data['message']) || !is_array($data['message'])) {
            throw new InvalidArgumentException('Invalid parameter: message must be an array');
        }
        if (!isset($data['attachments']) || !is_array($data['attachments'])) {
            throw new InvalidArgumentException('Invalid parameter: attachments must be an array');
        }

        return $this->compositionManager->send($tenantId, $userId, $data['identifier'], $data['sender'], $data['message'], $data['attachments']);
    }

    private function attachmentAdd(string $tenantId, string $userId, array $data): array {
        if (!isset($data['composition']) || !is_string($data['composition']) || $data['composition'] === '') {
            throw new InvalidArgumentException('Invalid parameter: composition must be a non-empty string');
        }
        if (!isset($data['attachments']) || !is_array($data['attachments'])) {
            throw new InvalidArgumentException('Invalid parameter: attachments must be an array');
        }

        return $this->compositionManager->attachmentAdd($tenantId, $userId, $data['composition'], ...$data['attachments']);
    }

    private function attachmentRemove(string $tenantId, string $userId, array $data): array {
        if (!isset($data['composition']) || !is_string($data['composition']) || $data['composition'] === '') {
            throw new InvalidArgumentException('Invalid parameter: composition must be a non-empty string');
        }
        if (!isset($data['identifier']) || !is_string($data['identifier']) || $data['identifier'] === '') {
            throw new InvalidArgumentException('Invalid parameter: identifier must be a non-empty string');
        }

        return $this->compositionManager->attachmentRemove($tenantId, $userId, $data['composition'], $data['identifier']);
    }
}