<?php

class UserService {
    private DatabaseInterface $database;

    public function __construct(DatabaseInterface $database) {
        $this->database = $database;
    }

    public function saveUser(User $user): void {
        $this->database->save($user);
    }
}

<?php

declare(strict_types=1);

namespace DJWeb\Framework\Container\Contracts;

use DJWeb\Framework\Container\Definition;

/**
 * The ContainerContract defines the methods that a service container must implement.
 * It extends the PSR-11 ContainerContract and provides additional methods for setting
 * services, adding definitions, and registering service providers.
 */
interface ContainerContract extends \Psr\Container\ContainerInterface
{
    public function set(string $key, mixed $value): ContainerContract;

    public function register(
        ServiceProviderContract $provider
    ): ContainerContract;

    public function bind(string $key, string|int|float|bool|null $value): void;

    public function getBinding(string $key): string|int|float|bool|null;
}

<?php

declare(strict_types=1);

namespace DJWeb\Framework\Container;

use DJWeb\Framework\Base\DotContainer;
use DJWeb\Framework\Container\Contracts\ContainerContract;
use DJWeb\Framework\Container\Contracts\ServiceProviderContract;
use DJWeb\Framework\Exceptions\Container\NotFoundError;

class Container implements ContainerContract
{
    private DotContainer $entries;
    private Autowire $autowire;

    /**
     * @var array<string, string|int|float|bool|null>
     */
    private array $bindings = [];

    public function __construct()
    {
        $this->entries = new DotContainer();
        $this->autowire = new Autowire($this);
    }

    public function bind(string $key, string|int|float|bool|null $value): void
    {
        $this->bindings[$key] = $value;
    }

    public function getBinding(string $key): string|int|float|bool|null
    {
        return $this->bindings[$key] ?? null;
    }

    /**
     * @param class-string $id
     *
     * @return mixed
     *
     * @throws NotFoundError
     */
    public function get(string $id): mixed
    {
        $entry = $this->entries->get($id);
        if (! $this->has($id)) {
            return $this->autowire->instantiate($id);
        }

        if ($entry instanceof Definition) {
            return $this->autowire->instantiate($entry::class);
        }
        return $entry;
    }

    public function has(string $id): bool
    {
        return $this->entries->has($id);
    }

    /**
     * Sets item in container
     *
     * @param string $key
     * @param mixed $value
     *
     * @return ContainerContract
     */
    public function set(string $key, mixed $value): ContainerContract
    {
        $this->entries->set($key, $value);
        return $this;
    }


    /**
     * Register a service provider.
     *
     * @param ServiceProviderContract $provider
     *
     * @return self
     */
    public function register(
        ServiceProviderContract $provider
    ): ContainerContract {
        $provider->register($this);
        return $this;
    }
}

<?php

declare(strict_types=1);

namespace DJWeb\Framework\Container;

use DJWeb\Framework\Container\Contracts\ContainerContract;
use DJWeb\Framework\Exceptions\Container\NotFoundError;
use ReflectionClass;
use ReflectionException;

/**
 * Class Autowire
 *
 * Responsible for automatically resolving and injecting dependencies.
 */
class Autowire
{
    private ReflectionResolver $resolver;

    public function __construct(
        private ContainerContract $container,
    ) {
        $this->resolver = new ReflectionResolver();
    }

    /**
     * Autowire and instantiate a class.
     *
     * @template T of object
     *
     * @param class-string<T> $className The name of the class to instantiate
     *
     * @return T The instantiated object
     *
     * @throws ReflectionException If the class cannot be reflected
     * @throws NotFoundError If a dependency cannot be resolved
     */
    public function instantiate(string $className): object
    {
        $reflectionClass = new ReflectionClass($className);
        $constructor = $reflectionClass->getConstructor();

        if ($constructor === null) {
            return $reflectionClass->newInstance();
        }

        $parameters = $this->resolver->getConstructorParameters($className);
        $arguments = $this->resolveParameters($parameters);

        return $reflectionClass->newInstanceArgs($arguments);
    }

    /**
     * Resolve parameters for dependency injection.
     *
     * @param array<\ReflectionParameter> $parameters
     *
     * @return array<mixed>
     *
     * @throws NotFoundError If a dependency cannot be resolved
     */
    private function resolveParameters(array $parameters): array
    {
        return array_map(function (\ReflectionParameter $parameter) {
            $parameterName = $parameter->getName();
            /** @var string $type */
            $type = $this->resolver->getParameterType($parameter);

            return match (true) {
                // 1. return given value if exists
                $this->container->has($parameterName) => $this->container->get($parameterName),
                $this->container->has($type) => $this->container->get($type),
                // 2. return default value if exist
                $this->resolver->hasDefaultValue($parameter) => $this->resolver->getDefaultValue($parameter),

                // 3. return null if allowed
                $this->resolver->allowsNull($parameter) => null,

                // 4. for builtin types return default value
                $type && $this->isBuiltInType($type) => $this->resolver->getDefaultValueForBuiltInType($type),

                // 5. for object check recursively
                $type && class_exists($type) => $this->instantiate($type),
                // otherwise throw not found exception
                default => throw new NotFoundError(
                    "Unable to resolve parameter {$parameterName} of type {$type}"
                )
            };
        }, $parameters);
    }

    private function isBuiltInType(string $type): bool
    {
        return in_array($type, ['int', 'float', 'string', 'bool', 'array']);
    }
}