Main.php

<?php

/**
 * Copyright 2021 Jeremy Presutti <Jeremy@Presutti.us>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

declare(strict_types=1);

namespace Feast;

use Exception;
use Exception\InvalidDateException;
use Feast\Attributes\AccessControl;
use Feast\Attributes\JsonParam;
use Feast\Attributes\Path;
use Feast\Enums\ResponseCode;
use Feast\Exception\Error404Exception;
use Feast\Exception\ServerFailureException;
use Feast\Exception\ThrottleException;
use Feast\Interfaces\ConfigInterface;
use Feast\Interfaces\ControllerInterface;
use Feast\Interfaces\ErrorLoggerInterface;
use Feast\Interfaces\MainInterface;
use Feast\Interfaces\RequestInterface;
use Feast\Interfaces\ResponseInterface;
use Feast\Interfaces\RouterInterface;
use Feast\ServiceContainer\NotFoundException;
use Feast\ServiceContainer\ServiceContainer;
use Feast\ServiceContainer\ServiceContainerItemInterface;
use ReflectionClass;
use ReflectionException;
use ReflectionNamedType;
use ReflectionParameter;

/**
 * @since 1.0
 * @version 1.0
 *
 * Main entry point of the Application.
 */
class Main implements MainInterface
{

    final public const RUN_AS_WEBAPP = 'webapp';
    final public const RUN_AS_CLI = 'cli';
    final public const FRAMEWORK_ROOT = __DIR__;

    private array $plugins = [];
    private ErrorLoggerInterface $logger;
    protected ?ControllerInterface $ranController = null;
    protected string $routePath = '';
    protected bool $isJson = false;

    /**
     * Main constructor.
     *
     * @param ServiceContainer $serviceContainer
     * @param string $runAs
     * @throws NotFoundException
     */
    public function __construct(protected ServiceContainer $serviceContainer, protected string $runAs)
    {
        /** @var ConfigInterface $config */
        $config = $this->serviceContainer->get(ConfigInterface::class);
        ini_set('display_errors', $config->getSetting('showerrors') ? 'true' : 'false');
        $this->logger = $this->serviceContainer->get(ErrorLoggerInterface::class);
    }

    /**
     * @throws NotFoundException
     */
    protected function buildCliArguments(RouterInterface $router): void
    {
        /** @var array{argv:array<string>} $_SERVER */
        $router->buildRouteForRequestUrl('CLI/index/index');

        $_SERVER['argv'][0] = str_replace(':', '/', $_SERVER['argv'][0]);
        $path = 'CLI' . '/' . implode('/', $_SERVER['argv']);
        $router->buildCliArguments($path);
    }

    /**
     * @throws NotFoundException
     */
    protected function buildWebArguments(RouterInterface $router): void
    {
        /** @var ?string $path */
        $path = $_SERVER['REQUEST_URI'] ?? null;
        if (isset($path)) {
            $router->buildRouteForRequestUrl(parse_url($path, PHP_URL_PATH));
        } else {
            $router->buildRouteForRequestUrl('index/index');
        }

        $router->assignArguments($_GET);
        $router->assignArguments($_POST);
        $router->assignArguments($_FILES);
        if ($this->isJsonRequest()) {
            /** @var array $data */
            $data = json_decode(file_get_contents('php://input'), true) ?? [];
            $router->assignArguments($data);
        }
    }

    protected function isJsonRequest(): bool
    {
        return isset($_SERVER['CONTENT_TYPE'])
            && stripos($_SERVER['CONTENT_TYPE'], 'application/json') !== false;
    }

    protected function buildInitialArguments(RouterInterface $router): void
    {
        if ($this->runAs == self::RUN_AS_WEBAPP) {
            $this->buildWebArguments($router);
        } elseif ($this->runAs == self::RUN_AS_CLI) {
            $this->buildCliArguments($router);
        }
    }

    /**
     * Main Program execution
     *
     * @throws NotFoundException
     * @throws Error404Exception
     * @throws ServerFailureException|ReflectionException
     */
    public function main(): void
    {
        // Fetch dependencies from service container
        $view = $this->serviceContainer->get(View::class);
        $router = $this->serviceContainer->get(RouterInterface::class);
        $config = $this->serviceContainer->get(ConfigInterface::class);
        $request = $this->serviceContainer->get(RequestInterface::class);
        $response = $this->serviceContainer->get(ResponseInterface::class);
        $router->setRunAs($this->runAs);
        $view->setTitle((string)$config->getSetting('title'));

        if ($config->getSetting('buildroutes') === true && $this->runAs === self::RUN_AS_WEBAPP) {
            $router->buildRoutes();
        }
        require_once(APPLICATION_ROOT . 'bootstrap.php');

        $this->loadPlugins($config, $request);

        $this->buildInitialArguments($router);
        try {
            $this->runPlugins('preDispatch', $router, $request);
            if ($this->runAs == self::RUN_AS_WEBAPP) {
                $this->isJson = $request->getArgumentString('format') == 'json';

                $redirectPath = $response->getRedirectPath();
                if (is_string($redirectPath)) {
                    header('Location:' . $redirectPath);
                    return;
                }
            }

            $this->runRequest($router, $request, $response, $config, $view);
        } catch (Error404Exception $exception) {
            if ($this->runAs === self::RUN_AS_WEBAPP) {
                $this->handle404Exception($config, $exception);
            } else {
                throw $exception;
            }
        } catch (Exception|ServerFailureException $exception) {
            $this->handleExceptions($exception, $response, $config);
        }
    }

    /**
     * @throws Error404Exception
     * @throws ReflectionException
     * @throws NotFoundException
     * @throws ServerFailureException
     */
    protected function runControllerLoop(
        RouterInterface $router,
        RequestInterface $request,
        ResponseInterface $response,
        ConfigInterface $config
    ): void {
        do {
            $router->forward(false);
            $controllerName = $router->getControllerClass();
            $actionName = $router->getActionMethodName();
            /** @var class-string<ControllerInterface> $controllerClass */
            $controllerClass = $router->getControllerFullyQualifiedName();
            $moduleName = $router->getModuleName();
            $this->routePath = $moduleName != 'Default' ? '/Modules/' . $moduleName . '/' : '';

            $this->checkForControllerAndAction($controllerClass, $controllerName, $actionName, $config);
            /* @var $controller ControllerInterface */
            $arguments = $this->buildDynamicParameters($controllerClass, '__construct', $request, false);
            /** @var HttpController $controller */
            $controller = new $controllerClass(...$arguments);
            $allowRunning = $controller->init();

            if ($allowRunning) {
                $this->runAction($controller, $actionName, $request);
            } else {
                throw new ServerFailureException('Request not allowed.');
            }
        } while ($router->forwarded());

        $this->ranController = $controller;
        $this->isJson = $this->isJson || $this->ranController->alwaysJson(
                $router->getActionName()
            );// Mark as json if it is
        if ($this->isJson && $this->ranController->jsonAllowed()) {
            $response->setJson();
        }
    }

    /**
     * @param ControllerInterface $controller
     * @param string $actionName
     * @param RequestInterface $request
     * @throws NotFoundException
     * @throws ReflectionException
     * @throws ServerFailureException
     */
    protected function runAction(ControllerInterface $controller, string $actionName, RequestInterface $request): void
    {
        $arguments = $this->buildDynamicParameters($controller, $actionName, $request);
        // Argument gathering

        $controller->$actionName(...$arguments);
    }

    /**
     * @param ControllerInterface|Plugin|class-string $controller
     * @param string $function
     * @param RequestInterface $request
     * @param bool $buildUnknown
     * @return array
     * @throws NotFoundException
     * @throws ReflectionException
     * @throws ServerFailureException
     */
    protected function buildDynamicParameters(
        ControllerInterface|Plugin|string $controller,
        string $function,
        RequestInterface $request,
        bool $buildUnknown = true
    ): array {
        // Argument gathering
        $reflection = new ReflectionClass($controller);
        $method = $reflection->getMethod($function);
        $argumentCount = $method->getNumberOfParameters();

        if ($argumentCount === 0) {
            return [];
        } else {
            $arguments = $method->getParameters();

            return $this->buildArguments($arguments, $request, $buildUnknown);
        }
    }

    /**
     * @param array $arguments
     * @param RequestInterface $request
     * @param bool $buildUnknown
     * @return array
     * @throws NotFoundException
     * @throws ReflectionException
     * @throws ServerFailureException
     */
    protected function buildArguments(array $arguments, RequestInterface $request, bool $buildUnknown = true): array
    {
        /** @var array<mixed> $return */
        $return = [];
        /** @var ReflectionParameter $argument */
        foreach ($arguments as $argument) {
            $this->buildArgument($request, $argument, $buildUnknown, $return);
        }
        if (!empty($return) && is_array($return[count($return) - 1])) {
            /** @var array $arrayValues */
            $arrayValues = array_pop($return);
            /** @var string|int|bool|float|object|null $value */
            foreach ($arrayValues as $value) {
                $return[] = $value;
            }
        }

        return $return;
    }

    /**
     * @throws ReflectionException|NotFoundException|ServerFailureException
     */
    protected function buildArgument(
        RequestInterface $request,
        ReflectionParameter $argument,
        bool $buildUnknown,
        array &$return
    ): void {
        /** @var ?ReflectionNamedType $type */
        $type = $argument->getType();
        if ($type !== null) {
            $argumentType = $type->getName();
            /** @var string|int|float|bool|null|object $default */
            $default = $argument->isOptional() && $argument->isDefaultValueAvailable() ? $argument->getDefaultValue(
            ) : null;
            $jsonParam = $argument->getAttributes(JsonParam::class);
            $isJsonItem = !empty($jsonParam);

            if ($isJsonItem && $this->isValidType($argumentType)) {
                $return = $this->parseJsonParam($jsonParam[0], $request, $argumentType, $return);
            } elseif (is_subclass_of($argumentType, BaseModel::class)) {
                $this->buildBaseModelArgument($argumentType, $request, $argument, $return);
            } elseif (is_subclass_of($argumentType, BaseMapper::class)) {
                $mapper = new $argumentType();
                $return[] = $mapper;
            } elseif (is_subclass_of($argumentType, ServiceContainerItemInterface::class)) {
                $return[] = $this->serviceContainer->get($argumentType);
            } elseif ($buildUnknown) {
                $this->buildUnknownArgument($argument, $argumentType, $default, $request, $return);
            }
        }
    }

    /**
     * Load all plugins
     *
     * @param ConfigInterface $config
     * @param RequestInterface $request
     * @throws ReflectionException
     */
    protected function loadPlugins(ConfigInterface $config, RequestInterface $request): void
    {
        $plugins = [];
        if ($config->getSetting('plugin')) {
            $pluginList = (array)$config->getSetting('plugin');

            /** @var class-string<Plugin> $plugin */
            foreach ($pluginList as $plugin) {
                $arguments = $this->buildDynamicParameters($plugin, '__construct', $request, false);
                /** @psalm-suppress UnsafeInstantiation */
                $plugins[] = new $plugin(...$arguments);
            }
        }
        $this->plugins = $plugins;
    }

    /**
     * Run all plugins for the set method
     *
     * @param string $methodName
     * @param RouterInterface $router
     * @param RequestInterface $request
     * @throws ReflectionException
     */
    protected function runPlugins(string $methodName, RouterInterface $router, RequestInterface $request): void
    {
        if ($this->runAs === self::RUN_AS_CLI) {
            $methodName = 'CLI' . ucfirst($methodName);
        }

        /** @var Plugin $plugin */
        foreach ($this->plugins as $plugin) {
            if (method_exists($plugin, $methodName)) {
                $plugin->init($router);
                $arguments = $this->buildDynamicParameters($plugin, $methodName, $request, false);
                $plugin->$methodName(...$arguments);
            }
        }
    }

    /**
     * @param class-string $argumentType
     * @param RequestInterface $request
     * @param ReflectionParameter $argument
     * @param array $return
     * @throws NotFoundException|ReflectionException|ServerFailureException
     */
    protected function buildBaseModelArgument(
        string $argumentType,
        RequestInterface $request,
        ReflectionParameter $argument,
        array &$return
    ): void {
        $reflected = new ReflectionClass($argumentType);
        /** @var class-string<BaseMapper> $mapperName */
        $mapperName = $reflected->getConstant('MAPPER_NAME');
        /** @var BaseMapper $mapper */
        $mapper = new $mapperName();
        $argumentValue = $request->getArgumentString($argument->getName());
        if ($argumentValue === null) {
            if ($argument->allowsNull()) {
                $return[] = null;
            }
            return;
        }
        $return[] = $mapper->findByPrimaryKey($argumentValue, true);
    }

    protected function buildUnknownArgument(
        ReflectionParameter $argument,
        string $argumentType,
        float|object|bool|int|string|null $default,
        RequestInterface $request,
        array &$return
    ): void {
        $argumentName = $argument->getName();
        if ($argument->isVariadic() || $argumentType === 'array') {
            $this->buildArrayArgument($default, $request, $argumentName, $argumentType, $return);
        } elseif ($argumentType === 'int') {
            $this->buildIntArgument($default, $request, $argumentName, $return);
        } elseif ($argumentType === 'float') {
            $this->buildFloatArgument($default, $request, $argumentName, $return);
        } elseif ($argumentType === 'bool') {
            $this->buildBoolArgument($default, $request, $argumentName, $return);
        } elseif ($argumentType === Date::class) {
            $return[] = $request->getArgumentDate($argumentName);
        } else {
            $this->buildStringArgument($default, $request, $argumentName, $return);
        }
    }

    protected function buildArrayArgument(
        float|object|bool|int|string|null $default,
        RequestInterface $request,
        string $argumentName,
        string $argumentType,
        array &$return
    ): void {
        if (!is_array($default)) {
            $default = [$default];
        }
        $return[] = $request->getArgumentArray($argumentName, $default, $argumentType);
    }

    protected function buildIntArgument(
        float|object|bool|int|string|null $default,
        RequestInterface $request,
        string $argumentName,
        array &$return
    ): void {
        if (is_int($default) === false) {
            $default = null;
        }
        $return[] = $request->getArgumentInt($argumentName, $default);
    }

    protected function buildFloatArgument(
        float|object|bool|int|string|null $default,
        RequestInterface $request,
        string $argumentName,
        array &$return
    ): void {
        if (is_float($default) === false) {
            $default = null;
        }
        $return[] = $request->getArgumentFloat($argumentName, $default);
    }

    protected function buildBoolArgument(
        float|object|bool|int|string|null $default,
        RequestInterface $request,
        string $argumentName,
        array &$return
    ): void {
        if (is_bool($default) === false) {
            $default = null;
        }
        $return[] = $request->getArgumentBool($argumentName, $default);
    }

    protected function buildStringArgument(
        float|object|bool|int|string|null $default,
        RequestInterface $request,
        string $argumentName,
        array &$return
    ): void {
        if (is_string($default) === false) {
            $default = null;
        }
        $return[] = $request->getArgumentString($argumentName, $default);
    }

    /**
     * @throws Error404Exception
     */
    protected function handle404Exception(
        ConfigInterface $config,
        Error404Exception $exception
    ): void {
        /** @var string|null $errorUrl */
        $errorUrl = $config->getSetting('error.http404.url', 'error/fourohfour');
        if (is_string($errorUrl)) {
            header('Location:/' . $errorUrl, true, ResponseCode::HTTP_CODE_302->value);
            return;
        }
        throw $exception;
    }

    protected function handleExceptions(
        Exception|ServerFailureException $exception,
        ResponseInterface $response,
        ConfigInterface $config
    ): void {
        if ($exception instanceof ThrottleException) {
            $response->sendResponseCode();
            $errorUrl = (string)$config->getSetting('error.throttle.url', 'error/rate-limit');
            header('Location:/' . $errorUrl);
            return;
        }
        if ($this->runAs === self::RUN_AS_WEBAPP) {
            if ( $exception instanceof ServerFailureException ) {
                $response->setResponseCode($exception->getResponseCode() ?? ResponseCode::HTTP_CODE_500);
            } else {
                $response->setResponseCode(ResponseCode::HTTP_CODE_500);
            }
            $response->sendResponseCode();            /** @psalm-suppress MissingFile */
            include(APPLICATION_ROOT . 'Views' . DIRECTORY_SEPARATOR . 'Error' . DIRECTORY_SEPARATOR . 'server-failure.phtml');
        }
        $this->logger->exceptionHandler($exception, true);
    }

    /**
     * @throws Error404Exception|ReflectionException|NotFoundException|ServerFailureException
     */
    protected function runRequest(
        RouterInterface $router,
        RequestInterface $request,
        ResponseInterface $response,
        ConfigInterface $config,
        View $view
    ): void {
        $this->runControllerLoop($router, $request, $response, $config);

        // Run Plugins
        $this->runPlugins('postDispatch', $router, $request);
        if ($this->runAs === self::RUN_AS_WEBAPP) {
            $response->sendResponse($view, $router, $this->routePath);
        }
    }

    /**
     * @throws Error404Exception
     */
    protected function checkForControllerAndAction(
        string $controllerClass,
        string $controllerName,
        string $actionName,
        ConfigInterface $config
    ): void {
        if (!class_exists($controllerClass)) {
            throw new Error404Exception('Controller ' . $controllerName . ' does not exist!');
        }
        if (!method_exists($controllerClass, $actionName)) {
            throw new Error404Exception('Action ' . $actionName . ' does not exist!');
        }
        $method = new \ReflectionMethod($controllerClass, $actionName);

        $attributes = $method->getAttributes(AccessControl::class);
        foreach ($attributes as $attribute) {
            /** @var AccessControl $path */
            $path = $attribute->newInstance();
            if ($path->isEnabled($config->getEnvironmentName()) === false) {
                throw new Error404Exception('Controller ' . $controllerName . ' is not available!');
            }
        }
    }

    /**
     * @param \ReflectionAttribute<\Feast\Attributes\JsonParam> $jsonParam
     * @param RequestInterface $request
     * @param class-string|string $argumentType
     * @param array $return
     * @return array
     * @throws \Feast\Exception\InvalidDateException
     * @throws ReflectionException
     * @throws ServerFailureException
     * @throws \JsonException
     */
    protected function parseJsonParam(
        \ReflectionAttribute $jsonParam,
        RequestInterface $request,
        string $argumentType,
        array $return
    ): array {
        /** @var JsonParam $jsonParamInstance */
        $jsonParamInstance = $jsonParam->newInstance();
        $allArguments = $request->getAllArguments();
        if ($jsonParamInstance->key === '') {
            $propertyValue = $allArguments;
        } else {
            /** @var \stdClass|scalar|array|null $value */
            $value = $allArguments->{$jsonParamInstance->key} ?? null;
            $propertyValue = $value;
        }
        if (($propertyValue instanceof \stdClass || is_array($propertyValue)) && class_exists($argumentType)) {
            $return[] = Json::unmarshal(json_encode($propertyValue), $argumentType);
        } else {
            $return[] = $propertyValue;
        }
        return $return;
    }

    protected function isValidType(string $argumentType): bool
    {
        if (class_exists($argumentType)) {
            return true;
        }
        return in_array($argumentType, ['array', 'string', 'bool', 'int', 'float', 'false']);
    }

}