<?php

use PhpParser\BuilderFactory;
use PhpParser\Node\Name;
use PhpParser\PrettyPrinter\Standard;

enum HttpMethod: string
{
    case GET = 'GET';
}

#[Attribute(Attribute::TARGET_METHOD)]
readonly class HTTP
{
    public HttpMethod $httpMethod;

    public function __construct(
        HttpMethod|string $httpMethod,
        public string $path
    )
    {
        if (is_string($httpMethod)) {
            $httpMethod = HttpMethod::from($httpMethod);
        }
        $this->httpMethod = $httpMethod;
    }
}

interface Api
{
    #[HTTP(httpMethod: HttpMethod::GET, path: '/users')]
    public function getUsers();
}

$reflectionClass = new ReflectionClass(Api::class);

$builderFactory = new BuilderFactory();

$class = $builderFactory->class('ApiImpl')
    ->implement('\\' . Api::class);

$reflectionMethod = $reflectionClass->getMethod('getUsers');

$method = $builderFactory
    ->method($reflectionMethod->getName())
    ->makePublic();

$reflectionAttributes = $reflectionMethod->getAttributes();
foreach ($reflectionAttributes as $reflectionAttribute) {
    $name = new Name($reflectionAttribute->getName());
    $attribute = $builderFactory->attribute($name, $reflectionAttribute->getArguments());

    $method->addAttribute($attribute);
}

$class->addStmt($method->getNode());

$proxyNamespaceBuilder = $builderFactory
    ->namespace('Namespace')
    ->addStmt($class);

$standard = new Standard();
echo $standard->prettyPrint([$proxyNamespaceBuilder->getNode()]);

public static function normalizeValue($value) : Expr {
    if ($value instanceof Node\Expr) {
        return $value;
    }

    if (is_null($value)) {
        return new Expr\ConstFetch(
            new Name('null')
        );
    }

    if (is_bool($value)) {
        return new Expr\ConstFetch(
            new Name($value ? 'true' : 'false')
        );
    }

    if (is_int($value)) {
        return new Scalar\LNumber($value);
    }

    if (is_float($value)) {
        return new Scalar\DNumber($value);
    }

    if (is_string($value)) {
        return new Scalar\String_($value);
    }

    if (is_array($value)) {
        $items = [];
        $lastKey = -1;
        foreach ($value as $itemKey => $itemValue) {
            // for consecutive, numeric keys don't generate keys
            if (null !== $lastKey && ++$lastKey === $itemKey) {
                $items[] = new Expr\ArrayItem(
                    self::normalizeValue($itemValue)
                );
            } else {
                $lastKey = null;
                $items[] = new Expr\ArrayItem(
                    self::normalizeValue($itemValue),
                    self::normalizeValue($itemKey)
                );
            }
        }

        return new Expr\Array_($items);
    }

    // !!! HERE !!!
    if (is_object($value)) {
        return new Expr\ClassConstFetch(new Name($value::class), $value->name);
    }

    throw new \LogicException('Invalid value');
}