<?php

declare(strict_types=1);

namespace Tests\Unit\Auth;

use GuzzleHttp\Promise\PromiseInterface;
use GuzzleHttp\Psr7\Request;
use Psr\Http\Message\RequestInterface;
use Uwil\ArcadiaApiPhpClient\Auth\ApiMandatoryHeadersMiddleware;
use Uwil\ArcadiaApiPhpClient\Auth\ClientIdentifier;
use Uwil\ArcadiaApiPhpClient\Auth\ClientSecret;
use Uwil\ArcadiaApiPhpClient\Auth\RequestSignature;
use Uwil\ArcadiaApiPhpClient\Auth\RequestSignatureCalculator;

describe('ApiMandatoryHeadersMiddleware Test', function () {
    it('can instanciate a valid ApiMandatoryHeadersMiddleware', function () {
        // GIVEN
        $response    = $this->createMock(PromiseInterface::class);
        $nextHandler = function (RequestInterface $_, array $__ = []) use ($response): PromiseInterface {
            return $response;
        };
        $apiKey              = new ClientIdentifier('valid-client-identifier');
        $withSecret          = new ClientSecret('valid-client-secret');
        $signatureCalculator = $this->createMock(RequestSignatureCalculator::class);

        // WHEN
        $middleware = new ApiMandatoryHeadersMiddleware(
            $nextHandler,
            $apiKey,
            $withSecret,
            $signatureCalculator
        );

        // THEN
        expect($middleware)->toBeInstanceOf(ApiMandatoryHeadersMiddleware::class);
    });

    it('can be invoked and return a request', function () {
        // GIVEN
        $response   = $this->createMock(PromiseInterface::class);
        $request    = new Request('GET', 'http://example.com');

        $nextHandler = function (RequestInterface $_, array $__ = []) use ($response): PromiseInterface {
            return $response;
        };

        $apiKey              = new ClientIdentifier('valid-client-identifier');
        $withSecret          = new ClientSecret('valid-client-secret');
        $signatureCalculator = mock(RequestSignatureCalculator::class);
        $signatureCalculator->shouldReceive('sign')
            ->andReturn(new RequestSignature(
                value: 'calculated-signature',
                bodyHash: 'body-hash',
            ));
        $middleware          = new ApiMandatoryHeadersMiddleware(
            $nextHandler,
            $apiKey,
            $withSecret,
            $signatureCalculator
        );

        // WHEN
        $result = $middleware($request, []);

        // THEN
        expect($result)->toBe($response);
    });
});

describe('ApiMandatoryHeadersMiddleware validation rules', function () {
    it('sign a request with api v1 required headers', function () {
        // GIVEN
        $response   = $this->createMock(PromiseInterface::class);
        $request    = new Request('GET', 'http://example.com');

        $nextHandler = function (RequestInterface $_, array $__ = []) use ($response, &$request): PromiseInterface {
            // NOTE: In order to check added headers.
            $request = $_;

            return $response;
        };

        $apiKey              = new ClientIdentifier('valid-client-identifier');
        $withSecret          = new ClientSecret('valid-client-secret');
        $signatureCalculator = mock(RequestSignatureCalculator::class);
        $signatureCalculator->shouldReceive('sign')
            ->andReturn(new RequestSignature(
                value: 'calculated-signature',
                bodyHash: 'body-hash',
            ));
        $middleware          = new ApiMandatoryHeadersMiddleware(
            $nextHandler,
            $apiKey,
            $withSecret,
            $signatureCalculator
        );

        // WHEN
        $middleware($request, []);
        // * Replaced the original request with the one containing added headers.
        $nextHandler($request, []);

        // THEN
        expect($request->getHeaderLine('X-Client-Identifier'))->toBe('valid-client-identifier');
        expect($request->getHeaderLine('X-Signature'))->toBe('calculated-signature');
        expect($request->getHeaderLine('X-Body-Hash'))->toBe('body-hash');
        expect($request->getHeaderLine('X-Timestamp'))->not->toBeEmpty();
        expect($request->getHeaderLine('X-Nonce'))->not->toBeEmpty();
    });
});