namespace App;

class ConfigProvider
{
    /**
     * Get configuration
     *
     * @return array
     */
    public function __invoke(): array
    {
        return [
            'dependencies'     => [
                'factories' => [
                    TestPageHandler::class => TestPageHandlerFactory::class,
                ],
            ],
            MetadataMap::class => [
                [
                    '__class__'      => RouteBasedResourceMetadata::class,
                    'resource_class' => TestEntity::class,
                    'route'          => 'test',
                    'extractor'      => Reflection::class,
                ],
                [
                    '__class__'           => RouteBasedCollectionMetadata::class,
                    'collection_class'    => TestCollection::class,
                    'collection_relation' => 'test',
                    'route'               => 'tests',
                ],
            ],
            'routes'           => [
                'tests' => [
                    'path'            => '/test',
                    'middleware'      => TestPageHandler::class,
                    'allowed_methods' => ['GET'],
                ],
                'test'  => [
                    'path'            => '/test/:id',
                    'middleware'      => TestPageHandler::class,
                    'allowed_methods' => ['GET'],
                ],
            ],
        ];
    }
}

namespace App;

class TestEntity
{

    /**
     * @var int
     */
    protected $id;

    /**
     * @var string
     */
    protected $name;

    /**
     * @var string|null
     */
    protected $description;

    /**
     * Get id
     *
     * @return int
     */
    public function getId(): int
    {
        return $this->id;
    }

    /**
     * Set id
     *
     * @param int $id
     *
     * @return void
     */
    public function setId(int $id): void
    {
        $this->id = $id;
    }

    /**
     * Get name
     *
     * @return string
     */
    public function getName(): string
    {
        return $this->name;
    }

    /**
     * Set name
     *
     * @param string $name
     *
     * @return void
     */
    public function setName(string $name): void
    {
        $this->name = $name;
    }

    /**
     * Get description
     *
     * @return null|string
     */
    public function getDescription(): ?string
    {
        return $this->description;
    }

    /**
     * Set description
     *
     * @param null|string $description
     *
     * @return void
     */
    public function setDescription(?string $description): void
    {
        $this->description = $description;
    }
}

namespace App;

use Zend\Paginator\Paginator;

class TestCollection extends Paginator
{

}

namespace App;

use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\RequestHandlerInterface;
use Zend\Expressive\Hal\HalResponseFactory;
use Zend\Expressive\Hal\ResourceGenerator;
use Zend\Paginator\Adapter\ArrayAdapter;

class TestPageHandler implements RequestHandlerInterface
{

    /**
     * @var ResourceGenerator
     */
    protected $resourceGenerator;

    /**
     * @var HalResponseFactory
     */
    protected $responseFactory;

    /**
     * @var TestEntity[]
     */
    protected $testEntities;

    /**
     * Constructor
     *
     * @param ResourceGenerator  $resourceGenerator
     * @param HalResponseFactory $responseFactory
     */
    public function __construct(ResourceGenerator $resourceGenerator, HalResponseFactory $responseFactory)
    {
        $this->resourceGenerator = $resourceGenerator;
        $this->responseFactory   = $responseFactory;
    }

    /**
     * @inheritdoc
     */
    public function handle(ServerRequestInterface $request): ResponseInterface
    {
        $this->generateTestEntities();
        $id = $request->getAttribute('id', false);
        if ($id) {
            $resource = $this->getTestEntity($id);
        } else {
            $resource = $this->getAllTestEntities();
        }

        return $this->responseFactory->createResponse($request,
            $this->resourceGenerator->fromObject($resource, $request));
    }

    /**
     * Get test entity
     *
     * @param $id
     *
     * @return TestEntity
     */
    public function getTestEntity(int $id): TestEntity
    {
        return $this->testEntities[$id];
    }

    /**
     * Get all test entities
     *
     * @return TestCollection
     */
    public function getAllTestEntities(): TestCollection
    {
        return new TestCollection(new ArrayAdapter($this->testEntities));
    }

    /**
     * Generate test entities
     *
     * @return void
     */
    public function generateTestEntities(): void
    {
        $this->testEntities = [];
        foreach (range(1, 10) as $id) {
            $entity = new TestEntity;
            $entity->setId($id);
            $entity->setName('test' . $id);
            $this->testEntities[$id] = $entity;
        }
    }
}

namespace App;

use Interop\Container\ContainerInterface;
use Zend\Expressive\Hal\HalResponseFactory;
use Zend\Expressive\Hal\ResourceGenerator;
use Zend\ServiceManager\Factory\FactoryInterface;

class TestPageHandlerFactory implements FactoryInterface
{

    /**
     * @inheritdoc
     */
    public function __invoke(ContainerInterface $container, $requestedName, array $options = null): TestPageHandler
    {
        return new $requestedName(
            $container->get(ResourceGenerator::class),
            $container->get(HalResponseFactory::class)
        );
    }
}

$metadataMap  = $this->resourceGenerator->getMetadataMap();
$metadata     = $metadataMap->get(Item::class);
$routesParams = array_merge($metadata->getRouteParams(), ['categoryId' => $categoryId]);
$metadata->setRouteParams($routesParams);

$app->get('/api/test/{id}',App\Handler\TestHandler::class,'api.test.get');

/* Code */
 $linkGenerator=$this->resourceGenerator
        ->getLinkGenerator();
$linkGenerator->templatedFromRoute(
                    'test',
                    $request,
                    'api.test.get'
                );
/* Code */

{
    "id": 1,
    "name": "Test",
    "_links": {
        "test": {
            "href": "http://localhost/expressive-test/public/api/test/{id}",
            "templated": true
        }
    }
}

Zend\Expressive\Router\Exception\RuntimeException raised in file D:\Sites\expressive-test\vendor\zendframework\zend-expressive-fastroute\src\FastRouteRouter.php line 299:
Message: Route `api.test.get` expects at least parameter values for [id], but received []

$array = [
    ['foo' => 'bar'],
];
$resource->embed('foobar', $resourceGenerator->fromArray($array));

new Link('a', 'b', false, ['c' => null]);

// PipelineAndRoutesDelegator.php
$app->route(
    '/book[/:id]',
    [
        BookAction::class
    ],
    [
        'GET', 'POST', 'PUT', 'DELETE', 'PATCH'
    ],
    'book'
);

// ConfigProvider.php
MetadataMap::class => [
    [
        '__class__' => RouteBasedResourceMetadata::class,
        'resource_class' => Book::class,
        'route' => 'book',
        'extractor' => ClassMethods::class,
    ],
    [
        '__class__' => RouteBasedCollectionMetadata::class,
        'collection_class' => BookCollection::class,
        'collection_relation' => 'book',
        'route' => 'book',
    ],
],

'route_params' => [
    'id' => 0,
]

MetadataMap::class => [
    [
        '__class__' => RouteBasedResourceMetadata::class,
        'resource_class' => Post::class,
        'route' => 'blog.post',
        'extractor' => ClassMethods::class,
    ],
    new RouteBasedResourceMetadata(
        Post::class,
        'blog.post',
        ClassMethods::class
    ),
];

namespace App;

class User
{
   /**
    * @var string
    */
   protected $id;

   /**
    * @var string
    */
   protected $name;

   /**
    * @var string
    */
   protected $email;

   /**
    * @var Avatar
    */
   protected $avatar;

   public function getName(): ?string
   {
       return $this->name;
   }

   public function setName(?string $name): User
   {
       $this->name = $name;
       return $this;
   }

   public function getEmail(): ?string
   {
       return $this->email;
   }

   public function setEmail(?string $email): User
   {
       $this->email = $email;
       return $this;
   }

   public function getAvatar(): ?Avatar
   {
       return $this->avatar;
   }

   public function setAvatar(?Avatar $avatar): User
   {
       $this->avatar = $avatar;
       return $this;
   }
}

namespace App;

class Avatar
{
   /**
    * @var string|null
    */
   protected $id;

   /**
    * @var string|null
    */
   protected $url;

   public function getId(): ?string
   {
       return $this->id;
   }

   public function setId(?string $id): User
   {
       $this->id = $id;
       return $this;
   }

   public function getUrl(): ?string
   {
       return $this->url;
   }

   public function setUrl(?string $url): User
   {
       $this->url = $url;
       return $this;
   }
}

MetadataMap::class => [
    [
        '__class__' => RouteBasedResourceMetadata::class,
        'resource_class' => App\User::class,
        'route' => 'api.user',
        'extractor' => ClassMethodsHydrator::class,
    ],
    [
        '__class__' => RouteBasedResourceMetadata::class,
        'resource_class' => App\Avatar::class,
        'route' => 'api.avatar',
        'extractor' => ClassMethodsHydrator::class,
    ],
],

$renderer = new JsonRenderer();
$avatar = new Avatar();
$avatar->setId('1234');
$avatar->setUrl('https://superfastcdn.com/myavatar.png');
$user = new User();
$user->setId('5678');
$user->setName('John Doe');
$user->setEmail('[email protected]');
$user->setAvatar($avatar);

$resource = $resourceGenerator->fromObject($user, $request);
echo $renderer->render($resource);

$user->setAvatar(null);

$resource = $resourceGenerator->fromObject($user, $request);
echo $renderer->render($resource);

$halResource1 = new HalResource([
    'id' => '1',
    'roles' => [10, 11],
]);
$halResource2 = new HalResource([
    'id' => '1',
    'roles' => [],
]);
print_r($halResource1->toArray());
print_r($halResource2->toArray());

if (! is_array($value) || empty($value)) {
    return false;
}