<?php

declare(strict_types=1);

namespace Tests\Unit\Repository;

use Http\Promise\FulfilledPromise;
use Http\Promise\RejectedPromise;
use Microsoft\Kiota\Abstractions\ApiException;
use Mockery;
use Uwil\ArcadiaApiPhpClient\Error\ApiError;
use Uwil\ArcadiaApiPhpClient\Error\ServerError;
use Uwil\ArcadiaApiPhpClient\Lib\ApiDto\Dto\IncoCompo;
use Uwil\ArcadiaApiPhpClient\Lib\ApiValueObject\IncoCompoId;
use Uwil\ArcadiaApiPhpClient\Lib\ApiValueObject\IncoId;
use Uwil\ArcadiaApiPhpClient\Mapper\IncoCompoMapper;
use Uwil\ArcadiaApiPhpClient\Repository\IncoCompoApiRepository;
use Uwil\ArcadiaKiotaOpenApiClient\ApiClient;
use Uwil\ArcadiaKiotaOpenApiClient\IncoSheets\IncoSheetsRequestBuilder;
use Uwil\ArcadiaKiotaOpenApiClient\IncoSheets\Item\Composition\CompositionRequestBuilder;
use Uwil\ArcadiaKiotaOpenApiClient\IncoSheets\Item\WithIncoItemRequestBuilder;
use Uwil\ArcadiaKiotaOpenApiClient\Models\IncoCompo as KiotaIncoCompo;
use Uwil\ArcadiaKiotaOpenApiClient\Models\IncoCompoItemResponse;

/** @return array{
 *  \Uwil\ArcadiaKiotaOpenApiClient\IncoSheets\IncoSheetsRequestBuilder&\Mockery\MockInterface,
 *  \Uwil\ArcadiaKiotaOpenApiClient\ApiClient&\Mockery\MockInterface,
 *  \Uwil\ArcadiaApiPhpClient\Mapper\IncoCompoMapper&\Mockery\MockInterface
 * } */
function incoCompoMocks(): array
{
    $incoSheetsBuilder = Mockery::mock(IncoSheetsRequestBuilder::class);
    $apiClient         = Mockery::mock(ApiClient::class);
    $mapper            = Mockery::mock(IncoCompoMapper::class);

    return [
        $incoSheetsBuilder,
        $apiClient,
        $mapper,
    ];
}

function dummyIncoCompo(): IncoCompo
{
    return (new IncoCompoMapper())->toDto(new KiotaIncoCompo());
}

describe('IncoCompoApiRepository', function () {
    describe('findFor', function () {
        it('returns IncoCompo when composition is found', function () {
            // GIVEN
            $id            = new IncoId('12345');
            $kiotaCompo    = new KiotaIncoCompo();
            $itemResponse  = new IncoCompoItemResponse();
            $itemResponse->setComposition($kiotaCompo);
            $expectedCompo = dummyIncoCompo();

            $promise = new FulfilledPromise($itemResponse);

            [
                $incoSheetsBuilder,
                $apiClient,
                $mapper,
            ] = incoCompoMocks();

            $compositionBuilder = Mockery::mock(CompositionRequestBuilder::class);
            $compositionBuilder->shouldReceive('get')->once()->andReturn($promise);

            $itemBuilder = Mockery::mock(WithIncoItemRequestBuilder::class);
            $itemBuilder->shouldReceive('composition')->once()->andReturn($compositionBuilder);

            $incoSheetsBuilder->shouldReceive('byIncoId')
                ->once()
                ->with('12345')
                ->andReturn($itemBuilder);
            $apiClient->shouldReceive('incoSheets')->once()->andReturn($incoSheetsBuilder);
            $mapper->shouldReceive('toDto')
                ->once()
                ->with($kiotaCompo)
                ->andReturn($expectedCompo);

            $repository = new IncoCompoApiRepository($apiClient, $mapper);

            // WHEN
            $result = $repository->findFor($id);

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

        it('returns null when composition is not found (404)', function () {
            // GIVEN
            $id = new IncoId('12345');

            $exception = new ApiException('Not Found');
            $exception->setResponseStatusCode(404);

            $promise = new RejectedPromise($exception);

            [
                $incoSheetsBuilder,
                $apiClient,
                $mapper,
            ] = incoCompoMocks();

            $compositionBuilder = Mockery::mock(CompositionRequestBuilder::class);
            $compositionBuilder->shouldReceive('get')->once()->andReturn($promise);

            $itemBuilder = Mockery::mock(WithIncoItemRequestBuilder::class);
            $itemBuilder->shouldReceive('composition')->once()->andReturn($compositionBuilder);

            $incoSheetsBuilder->shouldReceive('byIncoId')
                ->once()
                ->with('12345')
                ->andReturn($itemBuilder);
            $apiClient->shouldReceive('incoSheets')->once()->andReturn($incoSheetsBuilder);
            $mapper->shouldNotReceive('toDto');

            $repository = new IncoCompoApiRepository($apiClient, $mapper);

            // WHEN
            $result = $repository->findFor($id);

            // THEN
            expect($result)->toBeNull();
        });

        it('returns ApiError when request fails', function () {
            // GIVEN
            $id = new IncoId('12345');

            $exception = new ApiException('Internal Server Error');
            $exception->setResponseStatusCode(500);

            $promise = new RejectedPromise($exception);

            [
                $incoSheetsBuilder,
                $apiClient,
                $mapper,
            ] = incoCompoMocks();

            $compositionBuilder = Mockery::mock(CompositionRequestBuilder::class);
            $compositionBuilder->shouldReceive('get')->once()->andReturn($promise);

            $itemBuilder = Mockery::mock(WithIncoItemRequestBuilder::class);
            $itemBuilder->shouldReceive('composition')->once()->andReturn($compositionBuilder);

            $incoSheetsBuilder->shouldReceive('byIncoId')
                ->once()
                ->with('12345')
                ->andReturn($itemBuilder);
            $apiClient->shouldReceive('incoSheets')->once()->andReturn($incoSheetsBuilder);
            $mapper->shouldNotReceive('toDto');

            $repository = new IncoCompoApiRepository($apiClient, $mapper);

            // WHEN
            $result = $repository->findFor($id);

            // THEN
            expect($result)->toBeInstanceOf(ApiError::class);
            expect($result)->toBeInstanceOf(ServerError::class);
            expect($result->message())->toBe('Internal Server Error');
            expect($result->statusCode())->toBe(500);
        });
    });

    describe('find', function () {
        it('returns IncoCompo when composition is found', function () {
            // GIVEN
            $id            = new IncoCompoId('12345');
            $kiotaCompo    = new KiotaIncoCompo();
            $itemResponse  = new IncoCompoItemResponse();
            $itemResponse->setComposition($kiotaCompo);
            $expectedCompo = dummyIncoCompo();

            $promise = new FulfilledPromise($itemResponse);

            [
                $incoSheetsBuilder,
                $apiClient,
                $mapper,
            ] = incoCompoMocks();

            $compositionBuilder = Mockery::mock(CompositionRequestBuilder::class);
            $compositionBuilder->shouldReceive('get')->once()->andReturn($promise);

            $itemBuilder = Mockery::mock(WithIncoItemRequestBuilder::class);
            $itemBuilder->shouldReceive('composition')->once()->andReturn($compositionBuilder);

            $incoSheetsBuilder->shouldReceive('byIncoId')
                ->once()
                ->with('12345')
                ->andReturn($itemBuilder);
            $apiClient->shouldReceive('incoSheets')->once()->andReturn($incoSheetsBuilder);
            $mapper->shouldReceive('toDto')
                ->once()
                ->with($kiotaCompo)
                ->andReturn($expectedCompo);

            $repository = new IncoCompoApiRepository($apiClient, $mapper);

            // WHEN
            $result = $repository->find($id);

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

        it('returns null when composition is not found (404)', function () {
            // GIVEN
            $id = new IncoCompoId('12345');

            $exception = new ApiException('Not Found');
            $exception->setResponseStatusCode(404);

            $promise = new RejectedPromise($exception);

            [
                $incoSheetsBuilder,
                $apiClient,
                $mapper,
            ] = incoCompoMocks();

            $compositionBuilder = Mockery::mock(CompositionRequestBuilder::class);
            $compositionBuilder->shouldReceive('get')->once()->andReturn($promise);

            $itemBuilder = Mockery::mock(WithIncoItemRequestBuilder::class);
            $itemBuilder->shouldReceive('composition')->once()->andReturn($compositionBuilder);

            $incoSheetsBuilder->shouldReceive('byIncoId')
                ->once()
                ->with('12345')
                ->andReturn($itemBuilder);
            $apiClient->shouldReceive('incoSheets')->once()->andReturn($incoSheetsBuilder);
            $mapper->shouldNotReceive('toDto');

            $repository = new IncoCompoApiRepository($apiClient, $mapper);

            // WHEN
            $result = $repository->find($id);

            // THEN
            expect($result)->toBeNull();
        });

        it('returns ApiError when request fails', function () {
            // GIVEN
            $id = new IncoCompoId('12345');

            $exception = new ApiException('Internal Server Error');
            $exception->setResponseStatusCode(500);

            $promise = new RejectedPromise($exception);

            [
                $incoSheetsBuilder,
                $apiClient,
                $mapper,
            ] = incoCompoMocks();

            $compositionBuilder = Mockery::mock(CompositionRequestBuilder::class);
            $compositionBuilder->shouldReceive('get')->once()->andReturn($promise);

            $itemBuilder = Mockery::mock(WithIncoItemRequestBuilder::class);
            $itemBuilder->shouldReceive('composition')->once()->andReturn($compositionBuilder);

            $incoSheetsBuilder->shouldReceive('byIncoId')
                ->once()
                ->with('12345')
                ->andReturn($itemBuilder);
            $apiClient->shouldReceive('incoSheets')->once()->andReturn($incoSheetsBuilder);
            $mapper->shouldNotReceive('toDto');

            $repository = new IncoCompoApiRepository($apiClient, $mapper);

            // WHEN
            $result = $repository->find($id);

            // THEN
            expect($result)->toBeInstanceOf(ApiError::class);
            expect($result)->toBeInstanceOf(ServerError::class);
            expect($result->message())->toBe('Internal Server Error');
            expect($result->statusCode())->toBe(500);
        });
    });
});