kiri-router/src/Handler.php

<?php
declare(strict_types=1);

namespace Kiri\Router;

use Closure;
use Kiri;
use Kiri\Router\Format\ArrayFormat;
use Kiri\Router\Format\IFormat;
use Kiri\Router\Format\MixedFormat;
use Kiri\Router\Format\NoBody;
use Kiri\Router\Format\OtherFormat;
use Kiri\Router\Format\ResponseFormat;
use Kiri\Router\Format\VoidFormat;
use Psr\Container\ContainerExceptionInterface;
use Psr\Container\ContainerInterface;
use Psr\Container\NotFoundExceptionInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\RequestHandlerInterface;
use ReflectionFunction;
use ReflectionMethod;

class Handler implements RequestHandlerInterface
{

    /**
     * @var IFormat
     */
    protected mixed $format;


    /**
     * @var array
     */
    protected array $methods = [];


    /**
     * @var ContainerInterface
     */
    protected ContainerInterface $container;


    /**
     * @var array
     */
    protected array $parameters;


    /**
     * @param array|Closure $handler
     * @param ReflectionMethod|ReflectionFunction $parameter
     */
    public function __construct(public array|Closure $handler, ReflectionMethod|ReflectionFunction $parameter)
    {
        if ($parameter->getReturnType() != null) {
            $this->format = Kiri::getDi()->get($this->returnType($parameter));
        } else {
            $this->format = Kiri::getDi()->get(MixedFormat::class);
        }
        $this->parameters = Kiri::getDi()->getMethodParams($parameter);
    }


    /**
     * @param ReflectionMethod $reflectionType
     * @return string
     */
    protected function returnType(ReflectionMethod $reflectionType): string
    {
        return match ($reflectionType->getReturnType()->getName()) {
            'array'                 => ArrayFormat::class,
            'mixed', 'object'       => MixedFormat::class,
            'int', 'string', 'bool' => OtherFormat::class,
            'void'                  => VoidFormat::class,
            default                 => ResponseFormat::class
        };
    }


    /**
     * @param string $method
     * @return void
     * @throws
     */
    public function setRequestMethod(string $method): void
    {
        if ($method == 'HEAD') {
            $this->format = Kiri::getDi()->get(NoBody::class);
        }
    }


    /**
     * @return bool
     */
    public function isClosure(): bool
    {
        return $this->handler instanceof Closure;
    }


    /**
     * @param string $interface
     * @return bool
     */
    public function implement(string $interface): bool
    {
        if (!$this->handler instanceof Closure) {
            return $this->handler[0] instanceof $interface;
        }
        return false;
    }


    /**
     * @return string|null
     */
    public function getClass(): ?string
    {
        if ($this->handler instanceof Closure) {
            return null;
        }
        return $this->handler[0];
    }


    /**
     * @return string|null
     */
    public function getMethod(): ?string
    {
        if ($this->handler instanceof Closure) {
            return null;
        }
        return $this->handler[1];
    }


    /**
     * @param ServerRequestInterface $request
     * @return ResponseInterface
     * @throws
     */
    public function handle(ServerRequestInterface $request): ResponseInterface
    {
        $controller = Kiri::getDi()->get($this->handler[0]);

        $data = call_user_func([$controller, $this->handler[1]], ...$this->parameters);

        /** 根据返回类型 */
        return $this->format->call($data);
    }

}