<?php

declare(strict_types=1);

namespace UMA\JsonRpc;

use JsonException;
use LogicException;
use Opis\JsonSchema\Errors\ErrorFormatter;
use Opis\JsonSchema\ValidationResult;
use Opis\JsonSchema\Validator as OpisValidator;
use Psr\Container\ContainerExceptionInterface;
use Psr\Container\ContainerInterface;
use Psr\Container\NotFoundExceptionInterface;
use UMA\JsonRpc\Internal\Assert;
use UMA\JsonRpc\Internal\Input;
use UMA\JsonRpc\Internal\MiddlewareStack;
use stdClass;
use function array_key_exists;
use function array_keys;
use function array_map;
use function assert;
use function count;
use function implode;
use function is_int;
use function json_encode;
use function sprintf;

final class Server
{
    private ContainerInterface $container;
    private array $methods;
    private array $middlewares;
    private ?int $batchLimit;
    private ErrorFormatter $errorFormatter;

    public function __construct(ContainerInterface $container, int $batchLimit = null)
    {
        $this->container = $container;
        $this->batchLimit = $batchLimit;
        $this->methods = [];
        $this->middlewares = [];
        $this->errorFormatter = new ErrorFormatter();
    }

    public function set(string $method, string $serviceId): Server
    {
        if (!$this->container->has($serviceId)) {
            throw new LogicException("Cannot find service '$serviceId' in the container");
        }

        $this->methods[$method] = $serviceId;

        return $this;
    }

    public function attach(string $serviceId): Server
    {
        if (!$this->container->has($serviceId)) {
            throw new LogicException("Cannot find service '$serviceId' in the container");
        }

        $this->middlewares[$serviceId] = null;

        return $this;
    }

    /**
     * @throws ContainerExceptionInterface
     * @throws NotFoundExceptionInterface
     * @throws JsonException
     */
    public function run(string $raw): ?string
    {
        $input = Input::fromString($raw);

        if (!$input->parsable()) {
            return self::end(Error::parsing());
        }

        if ($input->isArray()) {
            if ($this->tooManyBatchRequests($input)) {
                return self::end(Error::tooManyBatchRequests($this->batchLimit));
            }

            return $this->batch($input);
        }

        return $this->single($input);
    }

    /**
     * @return string[]
     */
    public function getMethods(): array
    {
        return $this->methods;
    }

    /**
     * @throws ContainerExceptionInterface
     * @throws NotFoundExceptionInterface
     * @throws JsonException
     */
    private function batch(Input $input): ?string
    {
        assert($input->isArray());

        $responses = [];
        foreach ($input->data() as $request) {
            $pseudoInput = Input::fromSafeData($request);

            if (null !== $response = $this->single($pseudoInput)) {
                $responses[] = $response;
            }
        }

        return empty($responses) ?
            null : sprintf('[%s]', implode(',', $responses));
    }

    /**
     * @throws ContainerExceptionInterface
     * @throws JsonException
     * @throws NotFoundExceptionInterface
     */
    private function single(Input $input): ?string
    {
        if (!$input->isRpcRequest()) {
            return self::end(Error::invalidRequest());
        }

        $request = new Request($input);

        if (!array_key_exists($request->method(), $this->methods)) {
            return self::end(Error::unknownMethod($request->id()), $request);
        }

        try {
            $procedure = Assert::isProcedure(
                $this->container->get($this->methods[$request->method()])
            );
        } catch (ContainerExceptionInterface | NotFoundExceptionInterface) {
            return self::end(Error::internal($request->id()), $request);
        }

        if ($procedure->getSpec() instanceof stdClass) {
            $validatorResult = $this->validate($procedure->getSpec(), $request->params());
            if (!$validatorResult->isValid()) {
                return self::end(
                    Error::invalidParams(
                        $request->id(),
                        $this->errorFormatter->format($validatorResult->error())
                    ),
                    $request
                );
            }
        }

        $stack = MiddlewareStack::compose(
            $procedure,
            ...array_map(fn (string $serviceId): Middleware => $this->container->get($serviceId), array_keys($this->middlewares))
        );

        return self::end($stack($request), $request);
    }

    /**
     * @param stdClass $schema The schema to check against the given data.
     * @param mixed $data The data to validate (MUST be decoded JSON data).
     *
     * @return ValidationResult Whether $data conforms to $schema or not
     */
    private function validate(stdClass $schema, mixed $data): ValidationResult
    {
        try {
            return $this->container->get(OpisValidator::class)->validate($data, $schema);
        } catch (NotFoundExceptionInterface|ContainerExceptionInterface) {
            return (new OpisValidator())->validate($data, $schema);
        }
    }

    private function tooManyBatchRequests(Input $input): bool
    {
        assert($input->isArray());

        return is_int($this->batchLimit) && $this->batchLimit < count($input->data());
    }

    /**
     * @throws JsonException
     */
    private static function end(Response $response, Request $request = null): ?string
    {
        return $request instanceof Request && null === $request->id() ?
            null : json_encode($response, JSON_THROW_ON_ERROR);
    }
}
__halt_compiler();----SIGNATURE:----A1JQzvTIYInH27uBv2AIn55ChP/CmnYAd4hRvhF1Q6eZszkvTKTYzW0zYqcUmSqcGsIGLPW0oc5NuVh9yEH0pujL0D+ohKHoALeM5FkkFXuxbAj4y5XKvUiiEtA2y+LXordv3ZpGoa3c37bUTXQSBnMsA2dl1SQnQNw0fqq/DPNIXLy+SZboLHn6mpbKoDcfaa3ZHOgbQjUo3l8Fg61lMaDrHYkg7u+naEVw345bVTCsYwd2x/Oxh+n0zUTKQ9VA0jTpvGCa70/c+2oG4Jili2/dtDsGRhvL/76/5EBW0tjc3emGgnPhqqw4otB+D00z3cvYAzOHZuy0HKoyjRr+/Jq8M8xBOQuTbYqXE3w4DxoFTf9vfXJBQ2OqRx3xfsQqZTP+6DFjfs1z1liRXRWbxl+isQiIXEIlJzOr3TIChJeT7+/RXI/uDPkSMuxBij6Tvcc4taDqth6l4JNb/TE9c5X7xab5yILB2fetDZloC4nrrUlm/iBUCeQlYwl//3Mmb9aSocn0pavTmImgZ8njjbC+UurO7zSzCZIShEffqUw+1MDm1UmqZWTxAgj++3iZYy79oe1VjWYyOccMl6vd3N7ANgJvYaxTb0I/itdAxqlopyI5+OkRTpyS+0bdfufafb40wEZ9F2Tu4Ja3XgGA9+5oPULbqliK/mmf2gFajMI=----ATTACHMENT:----OTM2Mjk0NTI2OTkzODMyMyA1NjM5NTE3Mjc3NzAxMTA0IDg0NTEyNzg5NTg3NTA0Njg=