<?php

namespace PhpJsonRpc;

use PhpJsonRpc\Client\IdGenerator;
use PhpJsonRpc\Client\IdGeneratorInterface;
use PhpJsonRpc\Core\Result\Error;
use PhpJsonRpc\Error\InvalidResponseException;
use PhpJsonRpc\Client\HttpTransport;
use PhpJsonRpc\Client\AbstractTransport;
use PhpJsonRpc\Client\RequestBuilder;
use PhpJsonRpc\Client\ResponseParser;
use PhpJsonRpc\Core\Invoke\AbstractInvoke;
use PhpJsonRpc\Core\Invoke\Notification;
use PhpJsonRpc\Core\Invoke\Invoke;
use PhpJsonRpc\Core\InvokeSpec;
use PhpJsonRpc\Core\Result\Result;
use PhpJsonRpc\Core\ResultSpec;
use PhpJsonRpc\Error\JsonRpcException;

/**
 * Implementation of JSON-RPC2 client specification
 *
 * @link http://www.jsonrpc.org/specification
 */
class Client
{
    /**
     * Client will return null if server error happened
     */
    const ERRMODE_SILENT    = 0;

    /**
     * Client will throw exception if server error happened
     */
    const ERRMODE_EXCEPTION = 2;

    /**
     * @var AbstractInvoke[]
     */
    private $units = [];

    /**
     * @var bool
     */
    private $isSingleRequest = true;

    /**
     * @var RequestBuilder
     */
    private $requestBuilder;

    /**
     * @var AbstractTransport
     */
    private $transport;

    /**
     * @var ResponseParser
     */
    private $responseParser;

    /**
     * @var IdGeneratorInterface
     */
    private $generatorId;

    /**
     * @var int
     */
    private $serverErrorMode;

    /**
     * Client constructor.
     *
     * @param string $url
     * @param int    $serverErrorMode
     */
    public function __construct(string $url, int $serverErrorMode = self::ERRMODE_SILENT)
    {
        $this->requestBuilder  = new RequestBuilder();
        $this->transport       = new HttpTransport($url);
        $this->responseParser  = new ResponseParser();
        $this->generatorId     = new IdGenerator();
        $this->serverErrorMode = $serverErrorMode;
    }

    /**
     * @return RequestBuilder
     */
    public function getRequestBuilder(): RequestBuilder
    {
        return $this->requestBuilder;
    }

    /**
     * @return AbstractTransport
     */
    public function getTransport(): AbstractTransport
    {
        return $this->transport;
    }

    /**
     * Set transport engine
     *
     * @param AbstractTransport $transport
     */
    public function setTransport(AbstractTransport $transport)
    {
        $this->transport = $transport;
    }

    /**
     * @return ResponseParser
     */
    public function getResponseParser()
    {
        return $this->responseParser;
    }

    /**
     * @param ResponseParser $responseParser
     */
    public function setResponseParser($responseParser)
    {
        $this->responseParser = $responseParser;
    }

    /**
     * @return IdGeneratorInterface
     */
    public function getGeneratorId(): IdGeneratorInterface
    {
        return $this->generatorId;
    }

    /**
     * @param IdGeneratorInterface $idGenerator
     */
    public function setIdGenerator(IdGeneratorInterface $idGenerator)
    {
        $this->generatorId = $idGenerator;
    }

    /**
     * Make request
     *
     * @param string $method
     * @param array  $parameters
     *
     * @return $this|mixed
     * @throws JsonRpcException
     */
    public function call(string $method, array $parameters)
    {
        if ($this->isSingleRequest) {
            $this->units = [];
        }

        $this->units[] = new Invoke($this->generatorId->get(), $method, $parameters);

        if ($this->isSingleRequest) {
            $resultSpecifier = $this->execute(new InvokeSpec($this->units, true));

            if (!$resultSpecifier->isSingleResult()) {
                throw new InvalidResponseException();
            }

            list($result) = $resultSpecifier->getResults();

            if ($result instanceof Result) {
                /** @var Result $result */
                return $result->getResult();
            } elseif ($result instanceof Error) {
                /** @var Error $result */
                if ($this->serverErrorMode === self::ERRMODE_EXCEPTION) {
                    throw $result->getBaseException();
                }
            }

            return null;
        }

        return $this;
    }

    /**
     * Make notification request
     *
     * @param string $method
     * @param array  $parameters
     *
     * @return $this|null
     */
    public function notification(string $method, array $parameters)
    {
        if ($this->isSingleRequest) {
            $this->units = [];
        }

        $this->units[] = new Notification($method, $parameters);

        if ($this->isSingleRequest) {
            $this->execute(new InvokeSpec($this->units, true));
            return null;
        }

        return $this;
    }

    /**
     * Start batch request
     *
     * @return $this
     */
    public function batch()
    {
        $this->isSingleRequest = false;
        $this->units = [];
        return $this;
    }

    /**
     * Execute batch request
     *
     * @return array
     */
    public function batchExecute()
    {
        $results = $this->execute(new InvokeSpec($this->units, false))->getResults();

        // Make right order in sequence of results. It's required operation, because JSON-RPC2
        // specification define: "The Response objects being returned from a batch call MAY be returned
        // in any order within the Array. The Client SHOULD match contexts between the set of Request objects and the
        // resulting set of Response objects based on the id member within each Object."

        $callMap = [];
        foreach ($this->units as $index => $unit) {
            /** @var Invoke $unit */
            $callMap[$unit->getRawId()] = $index;
        }

        if (count($results) !== count($this->units)) {
            throw new InvalidResponseException();
        }

        $resultSequence = [];
        foreach ($results as $result) {
            if ($result instanceof Result) {
                /** @var Result $result */
                $resultSequence[ $callMap[$result->getId()] ] = $result->getResult();
            } elseif ($result instanceof Error) {
                /** @var Error $result */
                $resultSequence[ $callMap[$result->getId()] ] = $this->serverErrorMode === self::ERRMODE_EXCEPTION ? $result->getBaseException() : null;
            }
        }
        ksort($resultSequence);
        $this->units = [];

        return $resultSequence;
    }

    /**
     * @param InvokeSpec $call
     *
     * @return ResultSpec
     */
    private function execute(InvokeSpec $call): ResultSpec
    {
        $request  = $this->requestBuilder->build($call);
        $response = $this->transport->request($request);

        return $this->responseParser->parse($response);
    }
}
__halt_compiler();----SIGNATURE:----QnwzerRQ3zpB2uJLkAVQF3gpUoIyShkHRvhvq2nqhHIpSZMZJnnUPvZ+QGTalDGO5bh6E1h8EontyvoXQ0XhO0dsakWvXYd24FnwqABJBsatjOFPki95L0y6fv70gkBQZvKnlM7U+7+gRxX4qU2Le/LXsILMk4zlCuGes7JlAngF+ooilciGpN9affT/NavBtFshtuJ0/U0qpuVvhG/wvlObrR3mWuV+RG8fP50pQ8TjXAk5FaIXnCx7wVaP2z3mb3t/n+Vkz4/DJX56DWIqSZhAi/x5bu8IG2fy3UBfWGsZA2RsnnltmbCNqjs4KK1iUz6eDs2v9l+2E6SKpbaqqU9P2kzs7kUJmUiVGQBookIObjRJNHxl8jj5DzNlFwGaBAfNIML8DqMEpO09ZMX6SaZ9w9wxm4mFKaXvlNxDmZ6/566fcCsDtoCgq+wyHNw5FZoq+7jxVYAHB2BdPxYtbFBf7f17SG1k6OXnzi3HiO1F+cqPw3Pm7EKJswZB5hBf9NHTVKEPO7wuSjvGS7B11n5uxwoOblhTtauW0YJFzbPBoB98RRmrpHnA5mgIV8wjj62fiR7M4REQg/Lzk/QJLv+h5gPmeteYEK95crET9IcRpozJvd2CfdRkggaC0ZEylJ9OmUEf/CSWl9DN9yPLRh7mLm47Mk7SL6dAWGa30xc=----ATTACHMENT:----MjY2MDk2MDg1MDM3OTQxMCAxOTY3MDAwMTYxNjE2ODM5IDIwNTQ5MDQwODY3NzM0MjQ=